Merge lp:~kdub/mir/send-client-fences-to-server into lp:mir

[Kevin DuBois]

android: frontend:
send client fences back to the server. This is the complement of lp:~kdub/mir/send-server-fences-to-client. We will start processing the buffer that the client returns at an earlier point. HWC guarantees to wait for the fence before using the buffer, and we ensure that it is waited for in GLES composition in mg::Buffer::bind_to_texture.

android: frontend:
send client fences back to the server. This is the complement of lp:~kdub/mir/send-server-fences-to-client. We will start processing the buffer that the client returns at an earlier point. HWC guarantees to wait for the fence before using the buffer, and we ensure that it is waited for in GLES composition in mg::Buffer::bind_to_texture.

note: I split the ipc functions from test_platform.cpp into test_ipc_operations, as the platform test suite was really testing two objects. I did a bit of cleanup of the test in this area too.

currently testing with the full stack.

Unmerged revisions

2007. By Kevin DuBois on 2014-11-11

merge in mir

2006. By Kevin DuBois on 2014-11-11

further test cleanups

2005. By Kevin DuBois on 2014-11-11

merge in mir

2004. By Kevin DuBois on 2014-11-11

some test cleanups

2003. By Kevin DuBois on 2014-11-10

adjust for loop spacings

2002. By Kevin DuBois on 2014-11-10

merge mir

2001. By Kevin DuBois on 2014-11-10

merge in base

2000. By Kevin DuBois on 2014-10-28

merge in lp:mir

1999. By Kevin DuBois on 2014-10-24

correct problematic mirsurface test

1998. By Kevin DuBois on 2014-10-24

merge base

=== modified file 'src/client/android/client_surface_interpreter.cpp'
--- src/client/android/client_surface_interpreter.cpp	2014-10-01 06:25:56 +0000
+++ src/client/android/client_surface_interpreter.cpp	2014-11-11 18:48:42 +0000
@@ -45,9 +45,8 @@
 
 void mcla::ClientSurfaceInterpreter::driver_returns_buffer(ANativeWindowBuffer*, int fence_fd)
 {
-    //TODO: pass fence to server instead of waiting here
-    mga::SyncFence sync_fence(sync_ops, mir::Fd(fence_fd));
-    sync_fence.wait();
+    auto buffer = surface.get_current_buffer()->native_buffer_handle();
+    buffer->update_usage(fence_fd, mga::BufferAccess::write);
 
     surface.request_and_wait_for_next_buffer();
 }
 
=== modified file 'src/client/mir_surface.cpp'
--- src/client/mir_surface.cpp	2014-11-11 15:50:11 +0000
+++ src/client/mir_surface.cpp	2014-11-11 18:48:42 +0000
@@ -208,6 +208,15 @@
     //TODO: we have extract the per-message information from the buffer
     *buffer_request.mutable_id() = surface.id();
     buffer_request.mutable_buffer()->set_buffer_id(surface.buffer().buffer_id());
+
+    MirNativeBuffer update_msg;
+    memset(&update_msg, 0, sizeof(update_msg));
+    auto client_buffer = buffer_depository->current_buffer();
+    client_buffer->fill_update_msg(update_msg);
+    for (auto i = 0; i < update_msg.data_items; i++)
+        buffer_request.mutable_buffer()->add_data(update_msg.fd[i]);
+    for (auto i = 0; i < update_msg.fd_items; i++)
+        buffer_request.mutable_buffer()->add_fd(update_msg.fd[i]);
     perf_report->end_frame(surface.buffer().buffer_id());
     lock.unlock();
 
@@ -302,6 +311,10 @@
 {
     {
         std::lock_guard<decltype(mutex)> lock(mutex);
+        for (auto fd : buffer_request.buffer().fd())
+            ::close(fd);
+        buffer_request.mutable_buffer()->clear_fd();
+        buffer_request.mutable_buffer()->clear_data();
         process_incoming_buffer();
     }
 
 
=== modified file 'src/platform/graphics/android/ipc_operations.cpp'
--- src/platform/graphics/android/ipc_operations.cpp	2014-10-16 19:07:47 +0000
+++ src/platform/graphics/android/ipc_operations.cpp	2014-11-11 18:48:42 +0000
@@ -45,11 +45,11 @@
         auto buffer_handle = native_buffer->handle();
         int offset = 0;
 
-        for(auto i = 0; i < buffer_handle->numFds; i++)
+        for (auto i = 0; i < buffer_handle->numFds; i++)
         {
             msg.pack_fd(mir::Fd(IntOwnedFd{buffer_handle->data[offset++]}));
         }
-        for(auto i = 0; i < buffer_handle->numInts; i++)
+        for (auto i = 0; i < buffer_handle->numInts; i++)
         {
             msg.pack_data(buffer_handle->data[offset++]);
         }
@@ -59,8 +59,17 @@
     }
 }
 
-void mga::IpcOperations::unpack_buffer(BufferIpcMessage&, Buffer const&) const
+void mga::IpcOperations::unpack_buffer(BufferIpcMessage& msg, Buffer const& buffer) const
 {
+    auto const& fds = msg.fds();
+    auto const& data = msg.data();
+    auto native_buffer = buffer.native_buffer_handle();
+    if ((data.size() >= 1) && (fds.size() >= 1) &&
+        (data[0] == static_cast<int>(mga::BufferFlag::fenced)))
+    {
+        int fence = fds[0];
+        native_buffer->update_usage(fence, mga::BufferAccess::write);
+    }
 }
 
 std::shared_ptr<mg::PlatformIPCPackage> mga::IpcOperations::connection_ipc_package()
 
=== modified file 'tests/include/mir_test_doubles/mock_android_alloc_device.h'
--- tests/include/mir_test_doubles/mock_android_alloc_device.h	2013-06-18 08:00:49 +0000
+++ tests/include/mir_test_doubles/mock_android_alloc_device.h	2014-11-11 18:48:42 +0000
@@ -18,6 +18,7 @@
 #ifndef MIR_TEST_DOUBLES_MOCK_ANDROID_ALLOC_DEVICE_H_
 #define MIR_TEST_DOUBLES_MOCK_ANDROID_ALLOC_DEVICE_H_
 
+#include <memory>
 #include <gmock/gmock.h>
 #include <hardware/gralloc.h>
 
@@ -25,49 +26,27 @@
 {
 namespace test
 {
-namespace android
-{
-class ICSAllocInterface
-{
-public:
-    virtual ~ICSAllocInterface() {/* TODO: make nothrow */}
-    virtual int alloc_interface(alloc_device_t* dev, int w, int h,
-                                int format, int usage, buffer_handle_t* handle, int* stride) = 0;
-    virtual int free_interface(alloc_device_t* dev, buffer_handle_t handle) = 0;
-    virtual int dump_interface(alloc_device_t* dev, char *buf, int len) = 0;
-
-};
-}
 namespace doubles
 {
-class MockAllocDevice : public android::ICSAllocInterface,
-    public alloc_device_t
+std::shared_ptr<native_handle_t> generate_native_handle(size_t num_ints, size_t num_fds);
+struct MockAllocDevice : alloc_device_t
 {
-public:
-
-    MockAllocDevice()
+    MockAllocDevice() :
+        buffer_handle{generate_native_handle(43, 22)},
+        fake_stride{300}
     {
         using namespace testing;
-
-        buffer_handle = mock_generate_sane_android_handle(43, 22);
-        fake_stride = 300;
-
         alloc = hook_alloc;
         free = hook_free;
         dump = hook_dump;
         ON_CALL(*this, alloc_interface(_,_,_,_,_,_,_))
-        .WillByDefault(DoAll(
-                           SetArgPointee<5>(buffer_handle),
+            .WillByDefault(DoAll(
+                           SetArgPointee<5>(buffer_handle.get()),
                            SetArgPointee<6>(fake_stride),
                            Return(0)));
         ON_CALL(*this, free_interface(_,_))
-        .WillByDefault(Return(0));
-
-    }
-
-    ~MockAllocDevice()
-    {
-        ::free((void*)buffer_handle);
+            .WillByDefault(Return(0));
+
     }
 
     static int hook_alloc(alloc_device_t* mock_alloc,
@@ -90,29 +69,11 @@
         mocker->dump_interface(mock_alloc, buf, buf_len);
     }
 
-    native_handle_t* mock_generate_sane_android_handle(int numFd, int numInt)
-    {
-        native_handle_t *handle;
-        int total=numFd + numInt;
-        int header_offset=3;
-
-        handle = (native_handle_t*) malloc(sizeof(int) * (header_offset+ total));
-        handle->version = 0x389;
-        handle->numFds = numFd;
-        handle->numInts = numInt;
-        for(int i=0; i<total; i++)
-        {
-            handle->data[i] = i*3;
-        }
-
-        return handle;
-    }
-
     MOCK_METHOD7(alloc_interface,  int(alloc_device_t*, int, int, int, int, buffer_handle_t*, int*));
     MOCK_METHOD2(free_interface, int(alloc_device_t*, buffer_handle_t));
     MOCK_METHOD3(dump_interface, int(alloc_device_t*, char*, int));
 
-    native_handle_t* buffer_handle;
+    std::shared_ptr<native_handle_t> const buffer_handle;
     unsigned int fake_stride;
 };
 }
 
=== modified file 'tests/mir_test_doubles/mock_android_hw.cpp'
--- tests/mir_test_doubles/mock_android_hw.cpp	2014-03-06 06:05:17 +0000
+++ tests/mir_test_doubles/mock_android_hw.cpp	2014-11-11 18:48:42 +0000
@@ -111,3 +111,14 @@
     int rc =  global_mock_android_hw->hw_get_module(id, module);
     return rc;
 }
+
+std::shared_ptr<native_handle_t> mtd::generate_native_handle(size_t num_ints, size_t num_fds)
+{
+    auto handle_size = sizeof(native_handle_t) + (sizeof(int)*(num_ints + num_fds));
+    auto native_buffer_handle = std::shared_ptr<native_handle_t>(reinterpret_cast<native_handle_t*>(::operator new(handle_size)));
+    native_buffer_handle->numInts = num_ints;
+    native_buffer_handle->numFds = num_fds;
+    for (auto i = 0u; i < (num_ints+num_fds); i++)
+        native_buffer_handle->data[i] = i;
+    return native_buffer_handle;
+}
 
=== modified file 'tests/unit-tests/client/android/test_client_surface_interpreter.cpp'
--- tests/unit-tests/client/android/test_client_surface_interpreter.cpp	2014-10-27 20:20:10 +0000
+++ tests/unit-tests/client/android/test_client_surface_interpreter.cpp	2014-11-11 18:48:42 +0000
@@ -22,6 +22,7 @@
 #include "src/client/client_buffer.h"
 #include "src/client/android/client_surface_interpreter.h"
 #include "mir_test_doubles/stub_android_native_buffer.h"
+#include "mir_test_doubles/mock_android_native_buffer.h"
 #include "mir_test/fake_shared.h"
 #include <system/window.h>
 #include <gmock/gmock.h>
@@ -131,18 +132,25 @@
     EXPECT_EQ(buffer.get(), returned_buffer);
 }
 
-TEST_F(AndroidInterpreter, advances_surface_on_buffer_return)
+TEST_F(AndroidInterpreter, updates_fence_and_advances_surface_on_buffer_plus_fence_return)
 {
     using namespace testing;
-    ANativeWindowBuffer buffer;
-
+    int fake_fence{45};
+    auto buffer = std::make_shared<NiceMock<mtd::MockAndroidNativeBuffer>>();
     testing::NiceMock<MockMirSurface> mock_surface{surf_params};
-    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
 
-    EXPECT_CALL(mock_surface, request_and_wait_for_next_buffer())
+    EXPECT_CALL(*mock_client_buffer, native_buffer_handle())
+        .Times(1)
+        .WillOnce(Return(buffer));
+    EXPECT_CALL(*buffer, update_usage(fake_fence, mga::BufferAccess::write))
         .Times(1);
-
-    interpreter.driver_returns_buffer(&buffer, -1);
+    EXPECT_CALL(mock_surface, get_current_buffer())
+        .Times(1)
+        .WillOnce(Return(mock_client_buffer));
+
+    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
+
+    interpreter.driver_returns_buffer(buffer->anwb(), fake_fence);
 }
 
 /* format is an int that is set by the driver. these are not the HAL_PIXEL_FORMATS in android */
 
=== modified file 'tests/unit-tests/client/test_client_mir_surface.cpp'
--- tests/unit-tests/client/test_client_mir_surface.cpp	2014-10-28 13:59:51 +0000
+++ tests/unit-tests/client/test_client_mir_surface.cpp	2014-11-11 18:48:42 +0000
@@ -31,6 +31,7 @@
 #include "mir/input/input_platform.h"
 #include "mir/input/input_receiver_thread.h"
 
+#include "mir_test_doubles/fd_matcher.h"
 #include "mir_test/test_protobuf_server.h"
 #include "mir_test/stub_server_tool.h"
 #include "mir_test/gmock_fixes.h"
@@ -49,7 +50,7 @@
 namespace mg = mir::graphics;
 namespace geom = mir::geometry;
 namespace mt = mir::test;
-
+namespace mtd = mir::test::doubles;
 namespace
 {
 
@@ -538,10 +539,28 @@
 {
     using namespace testing;
 
-    FakeRpcChannel fake_channel;
-    mir::protobuf::DisplayServer::Stub unresponsive_server{&fake_channel};
-
-    auto const surface = create_surface_with(unresponsive_server, stub_buffer_factory);
+    struct UnresponsiveExchangeServer : public mir::protobuf::DisplayServer::Stub
+    {
+        UnresponsiveExchangeServer(::google::protobuf::RpcChannel* fake_channel) :
+            mir::protobuf::DisplayServer::Stub{fake_channel}
+        {
+        }
+
+        void exchange_buffer(
+            ::google::protobuf::RpcController*,
+            const ::mir::protobuf::BufferRequest*,
+            ::mir::protobuf::Buffer*,
+            ::google::protobuf::Closure*)  override
+        {
+        }
+    };
+
+    TestConnectionConfiguration conf;
+    connection = std::make_shared<MirConnection>(conf);
+    connection->connect("MirClientSurfaceTest", null_connected_callback, 0)->wait_for_all();
+    UnresponsiveExchangeServer unresponsive_server{conf.the_rpc_channel().get()};
+
+    auto const surface = create_and_wait_for_surface_with(unresponsive_server, stub_buffer_factory);
 
     auto buffer_wait_handle = surface->next_buffer(&null_surface_callback, nullptr);
 
@@ -759,3 +778,104 @@
 
     EXPECT_GE(std::chrono::steady_clock::now(), expected_end);
 }
+
+struct FdGeneratingBuffer : public mcl::ClientBuffer
+{
+    FdGeneratingBuffer(mir::Fd fd) :
+        fd{std::move(fd)}
+    {
+    }
+    std::shared_ptr<mcl::MemoryRegion> secure_for_cpu_write()
+    {
+        return std::shared_ptr<mcl::MemoryRegion>();
+    }
+    geom::Size size() const { return size_; }
+    geom::Stride stride() const { return geom::Stride{0};}
+    MirPixelFormat pixel_format() const { return pf_; }
+    uint32_t age() const { return 0; }
+    void increment_age() {}
+    void mark_as_submitted() {}
+    std::shared_ptr<mg::NativeBuffer> native_buffer_handle() const
+    {
+        return std::shared_ptr<mg::NativeBuffer>();
+    }
+    void update_from(MirBufferPackage const&) {}
+    void fill_update_msg(MirBufferPackage& package)
+    {
+        package.data_items = 0;
+        package.fd_items = 1;
+        package.fd[0] = dup(fd);
+    }
+private:
+    mir::Fd const fd;
+    geom::Size size_;
+    MirPixelFormat pf_;
+};
+
+struct StubFdBufferFactory : public mcl::ClientBufferFactory
+{
+    StubFdBufferFactory(mir::Fd fd) :
+        fd{std::move(fd)}
+    {
+    }
+    
+    std::shared_ptr<mcl::ClientBuffer> create_buffer(
+        std::shared_ptr<MirBufferPackage> const&,
+        geom::Size, MirPixelFormat)
+    {
+        return std::make_shared<FdGeneratingBuffer>(fd);
+    }
+    mir::Fd const fd;
+};
+
+struct ExchangeMonitoringRpcServer : mir::protobuf::DisplayServer::Stub
+{
+    ExchangeMonitoringRpcServer(::google::protobuf::RpcChannel* fake_channel) :
+        mir::protobuf::DisplayServer::Stub{fake_channel}
+    {
+    }
+
+    virtual void exchange_buffer(
+        ::google::protobuf::RpcController*,
+        const ::mir::protobuf::BufferRequest* request,
+        ::mir::protobuf::Buffer*,
+        ::google::protobuf::Closure* closure) override
+    {
+        last_exchange_buffer_request = *request;
+        last_exchange_buffer_closure = closure;
+    }
+
+    void complete_exchange_buffer()
+    {
+        if (last_exchange_buffer_closure)
+            last_exchange_buffer_closure->Run();
+    }
+    ::mir::protobuf::BufferRequest last_exchange_buffer_request;
+    ::google::protobuf::Closure* last_exchange_buffer_closure;
+};
+
+TEST_F(MirClientSurfaceTest, sends_fd_that_the_buffer_provides_and_closes_after_call_completes)
+{
+    using namespace testing;
+    mir::Fd fd{fileno(tmpfile())};
+    auto stub_fd_buffer_factory = std::make_shared<StubFdBufferFactory>(fd);
+
+    mir::protobuf::ConnectParameters connect_parameters;
+    connect_parameters.set_application_name("test");
+
+    TestConnectionConfiguration conf;
+    connection = std::make_shared<MirConnection>(conf);
+    MirWaitHandle* wait_handle = connection->connect("MirClientSurfaceTest",
+                                                     null_connected_callback, 0);
+    wait_handle->wait_for_all();
+    ExchangeMonitoringRpcServer server(conf.the_rpc_channel().get());
+    auto const surface = create_and_wait_for_surface_with(server, stub_fd_buffer_factory);
+
+    auto buffer_wait_handle = surface->next_buffer(&null_surface_callback, nullptr);
+    auto& buffer_request = server.last_exchange_buffer_request.buffer(); 
+    ASSERT_THAT(buffer_request.fd().size(), (Eq(1)));
+    EXPECT_THAT(buffer_request.fd(0), mtd::RawFdIsValid());
+    server.complete_exchange_buffer();
+    buffer_wait_handle->wait_for_all();
+    EXPECT_THAT(buffer_request.fd(0), Not(mtd::RawFdIsValid()));
+}
 
=== modified file 'tests/unit-tests/graphics/android/CMakeLists.txt'
--- tests/unit-tests/graphics/android/CMakeLists.txt	2014-10-01 06:25:56 +0000
+++ tests/unit-tests/graphics/android/CMakeLists.txt	2014-11-11 18:48:42 +0000
@@ -28,6 +28,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_device_detection.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_hwc_wrapper.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_hwc_fallback_gl_renderer.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_ipc_operations.cpp
   $<TARGET_OBJECTS:mirplatformgraphicsandroidobjects>
 )
 
 
=== modified file 'tests/unit-tests/graphics/android/test_android_alloc_adaptor.cpp'
--- tests/unit-tests/graphics/android/test_android_alloc_adaptor.cpp	2014-03-06 06:05:17 +0000
+++ tests/unit-tests/graphics/android/test_android_alloc_adaptor.cpp	2014-11-11 18:48:42 +0000
@@ -69,7 +69,7 @@
     using namespace testing;
     EXPECT_CALL(*mock_alloc_device, alloc_interface(_,_,_,_,_,_,_))
     .WillOnce(DoAll(
-                  SetArgPointee<5>(mock_alloc_device->buffer_handle),
+                  SetArgPointee<5>(mock_alloc_device->buffer_handle.get()),
                   SetArgPointee<6>(size.width.as_uint32_t()*4),
                   Return(-1)));
 
@@ -83,7 +83,7 @@
     using namespace testing;
     EXPECT_CALL(*mock_alloc_device, alloc_interface(_,_,_,_,_,_,_))
     .WillOnce(DoAll(
-                  SetArgPointee<5>(mock_alloc_device->buffer_handle),
+                  SetArgPointee<5>(mock_alloc_device->buffer_handle.get()),
                   SetArgPointee<6>(0),
                   Return(0)));
 
@@ -122,10 +122,10 @@
 
     EXPECT_CALL(*mock_alloc_device, alloc_interface(_,_,_,_,_,_,_))
     .WillOnce(DoAll(
-                  SetArgPointee<5>(mock_alloc_device->buffer_handle),
+                  SetArgPointee<5>(mock_alloc_device->buffer_handle.get()),
                   SetArgPointee<6>(size.width.as_uint32_t()*4),
                   Return(0)));
-    EXPECT_CALL(*mock_alloc_device, free_interface(_,mock_alloc_device->buffer_handle));
+    EXPECT_CALL(*mock_alloc_device, free_interface(_,mock_alloc_device->buffer_handle.get()));
 
     alloc_adaptor->alloc_buffer(size, pf, usage);
 }
 
=== added file 'tests/unit-tests/graphics/android/test_ipc_operations.cpp'
--- tests/unit-tests/graphics/android/test_ipc_operations.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/graphics/android/test_ipc_operations.cpp	2014-11-11 18:48:42 +0000
@@ -0,0 +1,192 @@
+/*
+
+ * Copyright © 2012-2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "src/server/report/null_report_factory.h"
+#include "mir/graphics/native_platform.h"
+#include "mir/graphics/platform_ipc_operations.h"
+#include "mir/options/program_option.h"
+#include "src/platform/graphics/android/platform.h"
+#include "src/platform/graphics/android/ipc_operations.h"
+#include "mir_test_doubles/mock_buffer.h"
+#include "mir_test_doubles/mock_android_hw.h"
+#include "mir_test_doubles/mock_buffer_ipc_message.h"
+#include "mir_test_doubles/mock_display_report.h"
+#include "mir_test_doubles/stub_display_builder.h"
+#include "mir_test_doubles/mock_android_native_buffer.h"
+#include "mir_test_doubles/stub_android_native_buffer.h"
+#include "mir_test_doubles/fd_matcher.h"
+#include "mir_test/fake_shared.h"
+#include "mir_test_doubles/mock_android_native_buffer.h"
+#include "mir_test_doubles/mock_android_alloc_device.h"
+#include <gtest/gtest.h>
+
+namespace mg=mir::graphics;
+namespace mga=mir::graphics::android;
+namespace mt=mir::test;
+namespace mtd=mir::test::doubles;
+namespace mr=mir::report;
+namespace geom=mir::geometry;
+namespace mo=mir::options;
+
+struct IpcOperations : testing::Test
+{
+    IpcOperations() :
+        stride{300*4},
+        num_ints{30},
+        num_fds{12},
+        native_buffer{std::make_shared<mtd::MockAndroidNativeBuffer>()},
+        native_buffer_handle{mtd::generate_native_handle(num_ints, num_fds)},
+        mock_buffer{std::make_shared<testing::NiceMock<mtd::MockBuffer>>()}
+    {
+        using namespace testing;
+        ON_CALL(*native_buffer, handle())
+            .WillByDefault(Return(native_buffer_handle.get()));
+        ON_CALL(*mock_buffer, native_buffer_handle())
+            .WillByDefault(Return(native_buffer));
+        ON_CALL(*mock_buffer, stride())
+            .WillByDefault(Return(stride));
+    }
+
+    geom::Stride stride;
+    size_t num_ints;
+    size_t num_fds;
+    std::shared_ptr<mtd::MockAndroidNativeBuffer> native_buffer;
+    std::shared_ptr<native_handle_t> native_buffer_handle;
+    std::shared_ptr<mtd::MockBuffer> mock_buffer;
+    std::shared_ptr<mg::DisplayReport> stub_display_report;
+    mga::IpcOperations ipc_operations;
+};
+
+/* ipc packaging tests */
+TEST_F(IpcOperations, test_ipc_data_packed_correctly_for_full_ipc_with_fence)
+{
+    using namespace ::testing;
+    int fake_fence{333};
+    EXPECT_CALL(*native_buffer, copy_fence())
+        .WillOnce(Return(fake_fence));
+
+    mtd::MockBufferIpcMessage mock_ipc_msg;
+    int offset = 0;
+    EXPECT_CALL(mock_ipc_msg, pack_data(static_cast<int>(mga::BufferFlag::fenced)));
+    EXPECT_CALL(mock_ipc_msg, pack_fd(mtd::RawFdMatcher(fake_fence)));
+    for (auto i = 0u; i < num_fds; i++)
+        EXPECT_CALL(mock_ipc_msg, pack_fd(mtd::RawFdMatcher(native_buffer_handle->data[offset++])));
+    for (auto i = 0u; i < num_ints; i++)
+        EXPECT_CALL(mock_ipc_msg, pack_data(native_buffer_handle->data[offset++]));
+
+    EXPECT_CALL(*mock_buffer, stride())
+        .WillOnce(Return(stride));
+    EXPECT_CALL(mock_ipc_msg, pack_stride(stride))
+        .Times(1);
+
+    EXPECT_CALL(*mock_buffer, size())
+        .WillOnce(Return(mir::geometry::Size{123, 456}));
+    EXPECT_CALL(mock_ipc_msg, pack_size(_))
+        .Times(1);
+
+    ipc_operations.pack_buffer(mock_ipc_msg, *mock_buffer, mg::BufferIpcMsgType::full_msg);
+}
+
+TEST_F(IpcOperations, test_ipc_data_packed_correctly_for_full_ipc_without_fence)
+{
+    using namespace ::testing;
+    EXPECT_CALL(*native_buffer, copy_fence())
+        .WillOnce(Return(-1));
+
+    mtd::MockBufferIpcMessage mock_ipc_msg;
+    int offset = 0;
+    EXPECT_CALL(mock_ipc_msg, pack_data(static_cast<int>(mga::BufferFlag::unfenced)));
+    EXPECT_CALL(mock_ipc_msg, pack_fd(mtd::RawFdMatcher(-1)))
+        .Times(0);
+
+    for (auto i = 0u; i < num_fds; i++)
+    {
+        EXPECT_CALL(mock_ipc_msg, pack_fd(mtd::RawFdMatcher(native_buffer_handle->data[offset++])))
+            .Times(1);
+    }
+    for (auto i = 0u; i < num_ints; i++)
+    {
+        EXPECT_CALL(mock_ipc_msg, pack_data(native_buffer_handle->data[offset++]))
+            .Times(1);
+    }
+
+    EXPECT_CALL(*mock_buffer, stride())
+        .WillOnce(Return(stride));
+    EXPECT_CALL(mock_ipc_msg, pack_stride(stride))
+        .Times(1);
+
+    EXPECT_CALL(*mock_buffer, size())
+        .WillOnce(Return(mir::geometry::Size{123, 456}));
+    EXPECT_CALL(mock_ipc_msg, pack_size(_))
+        .Times(1);
+
+    ipc_operations.pack_buffer(mock_ipc_msg, *mock_buffer, mg::BufferIpcMsgType::full_msg);
+}
+
+TEST_F(IpcOperations, test_ipc_data_packed_correctly_for_partial_ipc)
+{
+    using namespace ::testing;
+
+    int fake_fence{33};
+    mtd::MockBufferIpcMessage mock_ipc_msg;
+
+    Sequence seq;
+    EXPECT_CALL(mock_ipc_msg, pack_data(static_cast<int>(mga::BufferFlag::fenced)))
+        .InSequence(seq);
+    EXPECT_CALL(mock_ipc_msg, pack_fd(mtd::RawFdMatcher(fake_fence)))
+        .InSequence(seq);
+    EXPECT_CALL(mock_ipc_msg, pack_data(static_cast<int>(mga::BufferFlag::unfenced)))
+        .InSequence(seq);
+
+    EXPECT_CALL(*native_buffer, copy_fence())
+        .Times(2)
+        .WillOnce(Return(fake_fence))
+        .WillOnce(Return(-1));
+
+    ipc_operations.pack_buffer(mock_ipc_msg, *mock_buffer, mg::BufferIpcMsgType::update_msg);
+    ipc_operations.pack_buffer(mock_ipc_msg, *mock_buffer, mg::BufferIpcMsgType::update_msg);
+}
+
+TEST_F(IpcOperations, unpacks_fenced_buffer_update)
+{
+    using namespace ::testing;
+    mtd::MockBufferIpcMessage mock_ipc_msg;
+    mir::Fd stub_fd{fileno(tmpfile())};
+
+    EXPECT_CALL(mock_ipc_msg, data())
+        .WillOnce(Return(std::vector<int>{static_cast<int>(mga::BufferFlag::fenced)}));
+    EXPECT_CALL(mock_ipc_msg, fds())
+        .WillOnce(Return(std::vector<mir::Fd>{stub_fd}));
+    EXPECT_CALL(*native_buffer, update_usage(_, mga::BufferAccess::write))
+        .Times(1);
+    ipc_operations.unpack_buffer(mock_ipc_msg, *mock_buffer);
+}
+
+TEST_F(IpcOperations, unpacks_unfenced_buffer)
+{
+    using namespace ::testing;
+    mtd::MockBufferIpcMessage mock_ipc_msg;
+    EXPECT_CALL(mock_ipc_msg, data())
+        .WillOnce(Return(std::vector<int>{static_cast<int>(mga::BufferFlag::unfenced)}));
+    EXPECT_CALL(mock_ipc_msg, fds())
+        .WillOnce(Return(std::vector<mir::Fd>{}));
+    EXPECT_CALL(*native_buffer, update_usage(_, _))
+        .Times(0);
+    ipc_operations.unpack_buffer(mock_ipc_msg, *mock_buffer);
+}
 
=== modified file 'tests/unit-tests/graphics/android/test_platform.cpp'
--- tests/unit-tests/graphics/android/test_platform.cpp	2014-10-27 19:49:37 +0000
+++ tests/unit-tests/graphics/android/test_platform.cpp	2014-11-11 18:48:42 +0000
@@ -17,19 +17,16 @@
  */
 
 #include "src/server/report/null_report_factory.h"
-#include "mir/graphics/native_platform.h"
-#include "mir/graphics/platform_ipc_operations.h"
-#include "mir/options/program_option.h"
+#include "mir_test_doubles/mock_display_report.h"
 #include "src/platform/graphics/android/platform.h"
-#include "mir_test_doubles/mock_buffer.h"
+#include "mir_test_doubles/mock_buffer_ipc_message.h"
 #include "mir_test_doubles/mock_android_hw.h"
-#include "mir_test_doubles/mock_buffer_ipc_message.h"
-#include "mir_test_doubles/mock_display_report.h"
+#include "mir_test_doubles/fd_matcher.h"
 #include "mir_test_doubles/stub_display_builder.h"
-#include "mir_test_doubles/fd_matcher.h"
+#include "mir_test_doubles/mock_android_native_buffer.h"
+#include "mir_test_doubles/mock_buffer.h"
+#include "mir_test_doubles/mock_android_alloc_device.h"
 #include "mir_test/fake_shared.h"
-#include "mir_test_doubles/mock_android_native_buffer.h"
-#include <system/window.h>
 #include <gtest/gtest.h>
 
 namespace mg=mir::graphics;
@@ -38,184 +35,42 @@
 namespace mtd=mir::test::doubles;
 namespace mr=mir::report;
 namespace geom=mir::geometry;
-namespace mo=mir::options;
-
-class PlatformBufferIPCPackaging : public ::testing::Test
-{
-protected:
-    virtual void SetUp()
-    {
-        using namespace testing;
-
-        stub_display_builder = std::make_shared<mtd::StubDisplayBuilder>();
-        stub_display_report = mr::null_display_report();
-        stride = geom::Stride(300*4);
-
-        num_ints = 43;
-        num_fds = 55;
-        auto handle_size = sizeof(native_handle_t) + (sizeof(int)*(num_ints + num_fds));
-        auto native_buffer_raw = (native_handle_t*) ::operator new(handle_size);
-        native_buffer_handle = std::shared_ptr<native_handle_t>(native_buffer_raw);
-
-        native_buffer_handle->numInts = num_ints;
-        native_buffer_handle->numFds = num_fds;
-        for (auto i = 0u; i < (num_ints+num_fds); i++)
-        {
-            native_buffer_handle->data[i] = i;
-        }
-
-        native_buffer = std::make_shared<mtd::MockAndroidNativeBuffer>();
-        mock_buffer = std::make_shared<NiceMock<mtd::MockBuffer>>();
-
-        ON_CALL(*native_buffer, handle())
-            .WillByDefault(Return(native_buffer_handle.get()));
-        ON_CALL(*mock_buffer, native_buffer_handle())
-            .WillByDefault(Return(native_buffer));
-        ON_CALL(*mock_buffer, stride())
-            .WillByDefault(Return(stride));
-    }
-
-    std::shared_ptr<mtd::MockAndroidNativeBuffer> native_buffer;
-    std::shared_ptr<mtd::StubDisplayBuilder> stub_display_builder;
-    std::shared_ptr<mtd::MockBuffer> mock_buffer;
-    std::shared_ptr<native_handle_t> native_buffer_handle;
-    std::shared_ptr<mg::DisplayReport> stub_display_report;
-    geom::Stride stride;
-    unsigned int num_ints, num_fds;
-};
-
-/* ipc packaging tests */
-TEST_F(PlatformBufferIPCPackaging, test_ipc_data_packed_correctly_for_full_ipc_with_fence)
-{
-    using namespace ::testing;
-    int fake_fence{333};
-    EXPECT_CALL(*native_buffer, copy_fence())
-        .WillOnce(Return(fake_fence));
-
-    mga::Platform platform(stub_display_builder, stub_display_report);
-
-    mtd::MockBufferIpcMessage mock_ipc_msg;
-    int offset = 0;
-    EXPECT_CALL(mock_ipc_msg, pack_data(static_cast<int>(mga::BufferFlag::fenced)));
-    EXPECT_CALL(mock_ipc_msg, pack_fd(mtd::RawFdMatcher(fake_fence)));
-    for (auto i = 0u; i < num_fds; i++)
-        EXPECT_CALL(mock_ipc_msg, pack_fd(mtd::RawFdMatcher(native_buffer_handle->data[offset++])));
-    for (auto i = 0u; i < num_ints; i++)
-        EXPECT_CALL(mock_ipc_msg, pack_data(native_buffer_handle->data[offset++]));
-
-    EXPECT_CALL(*mock_buffer, stride())
-        .WillOnce(Return(stride));
-    EXPECT_CALL(mock_ipc_msg, pack_stride(stride))
-        .Times(1);
-
-    EXPECT_CALL(*mock_buffer, size())
-        .WillOnce(Return(mir::geometry::Size{123, 456}));
-    EXPECT_CALL(mock_ipc_msg, pack_size(_))
-        .Times(1);
-
-    platform.fill_buffer_package(
-        &mock_ipc_msg, mock_buffer.get(), mg::BufferIpcMsgType::full_msg);
-}
-
-TEST_F(PlatformBufferIPCPackaging, test_ipc_data_packed_correctly_for_full_ipc_without_fence)
-{
-    using namespace ::testing;
-    EXPECT_CALL(*native_buffer, copy_fence())
-        .WillOnce(Return(-1));
-
-    mga::Platform platform(stub_display_builder, stub_display_report);
-
-    mtd::MockBufferIpcMessage mock_ipc_msg;
-    int offset = 0;
-    EXPECT_CALL(mock_ipc_msg, pack_data(static_cast<int>(mga::BufferFlag::unfenced)));
-    EXPECT_CALL(mock_ipc_msg, pack_fd(mtd::RawFdMatcher(-1)))
-        .Times(0);
-
-    for (auto i = 0u; i < num_fds; i++)
-    {
-        EXPECT_CALL(mock_ipc_msg, pack_fd(mtd::RawFdMatcher(native_buffer_handle->data[offset++])))
-            .Times(1);
-    }
-    for (auto i = 0u; i < num_ints; i++)
-    {
-        EXPECT_CALL(mock_ipc_msg, pack_data(native_buffer_handle->data[offset++]))
-            .Times(1);
-    }
-
-    EXPECT_CALL(*mock_buffer, stride())
-        .WillOnce(Return(stride));
-    EXPECT_CALL(mock_ipc_msg, pack_stride(stride))
-        .Times(1);
-
-    EXPECT_CALL(*mock_buffer, size())
-        .WillOnce(Return(mir::geometry::Size{123, 456}));
-    EXPECT_CALL(mock_ipc_msg, pack_size(_))
-        .Times(1);
-
-    platform.fill_buffer_package(
-        &mock_ipc_msg, mock_buffer.get(), mg::BufferIpcMsgType::full_msg);
-}
-
-TEST_F(PlatformBufferIPCPackaging, test_ipc_data_packed_correctly_for_nested)
-{
-    using namespace ::testing;
-    EXPECT_CALL(*native_buffer, copy_fence())
-        .WillOnce(Return(-1));
-
-    mga::Platform platform(stub_display_builder, stub_display_report);
-
-    mtd::MockBufferIpcMessage mock_ipc_msg;
-    int offset = 0;
-    for (auto i = 0u; i < num_fds; i++)
-    {
-        EXPECT_CALL(mock_ipc_msg, pack_fd(mtd::RawFdMatcher(native_buffer_handle->data[offset++])))
-            .Times(1);
-    }
-    EXPECT_CALL(mock_ipc_msg, pack_data(static_cast<int>(mga::BufferFlag::unfenced)));
-    for (auto i = 0u; i < num_ints; i++)
-    {
-        EXPECT_CALL(mock_ipc_msg, pack_data(native_buffer_handle->data[offset++]))
-            .Times(1);
-    }
-
-    EXPECT_CALL(*mock_buffer, stride())
-        .WillOnce(Return(stride));
-    EXPECT_CALL(mock_ipc_msg, pack_stride(stride))
-        .Times(1);
-
-    EXPECT_CALL(*mock_buffer, size())
-        .WillOnce(Return(mir::geometry::Size{123, 456}));
-    EXPECT_CALL(mock_ipc_msg, pack_size(_))
-        .Times(1);
-
-    platform.fill_buffer_package(&mock_ipc_msg, mock_buffer.get(), mg::BufferIpcMsgType::full_msg);
-}
-
-TEST_F(PlatformBufferIPCPackaging, test_ipc_data_packed_correctly_for_partial_ipc)
-{
-    using namespace ::testing;
-
-    int fake_fence{33};
-    mga::Platform platform(stub_display_builder, stub_display_report);
-    auto ipc_ops = platform.make_ipc_operations();
-
-    mtd::MockBufferIpcMessage mock_ipc_msg;
-
-    Sequence seq;
-    EXPECT_CALL(mock_ipc_msg, pack_data(static_cast<int>(mga::BufferFlag::fenced)))
-        .InSequence(seq);
-    EXPECT_CALL(mock_ipc_msg, pack_fd(mtd::RawFdMatcher(fake_fence)))
-        .InSequence(seq);
-    EXPECT_CALL(mock_ipc_msg, pack_data(static_cast<int>(mga::BufferFlag::unfenced)))
-        .InSequence(seq);
-
-    EXPECT_CALL(*native_buffer, copy_fence())
-        .Times(2)
-        .WillOnce(Return(fake_fence))
-        .WillOnce(Return(-1));
-
-    ipc_ops->pack_buffer(mock_ipc_msg, *mock_buffer, mg::BufferIpcMsgType::update_msg);
-    ipc_ops->pack_buffer(mock_ipc_msg, *mock_buffer, mg::BufferIpcMsgType::update_msg);
+
+TEST(PlatformBufferIPCPackaging, test_ipc_data_packed_correctly_for_nested)
+{
+    using namespace ::testing;
+    unsigned int num_ints{43};
+    unsigned int num_fds{55};
+    int offset = 0;
+    geom::Stride stride{300*4};
+    geom::Size size{123, 456};
+    mtd::MockBuffer mock_buffer;
+    mtd::MockBufferIpcMessage mock_ipc_msg;
+
+    auto native_buffer = std::make_shared<mtd::MockAndroidNativeBuffer>();
+    auto native = mtd::generate_native_handle(num_ints, num_fds);
+    ON_CALL(*native_buffer, handle())
+        .WillByDefault(Return(native.get()));
+    ON_CALL(mock_buffer, native_buffer_handle())
+        .WillByDefault(Return(native_buffer));
+    ON_CALL(mock_buffer, stride())
+        .WillByDefault(Return(stride));
+    ON_CALL(mock_buffer, size())
+        .WillByDefault(Return(size));
+
+    mga::Platform platform(std::make_shared<mtd::StubDisplayBuilder>(), mr::null_display_report());
+
+    EXPECT_CALL(*native_buffer, copy_fence())
+        .WillOnce(Return(-1));
+    EXPECT_CALL(mock_ipc_msg, pack_data(static_cast<int>(mga::BufferFlag::unfenced)));
+    for (auto i = 0u; i < num_fds; i++)
+        EXPECT_CALL(mock_ipc_msg, pack_fd(mtd::RawFdMatcher(native->data[offset++])));
+    for (auto i = 0u; i < num_ints; i++)
+        EXPECT_CALL(mock_ipc_msg, pack_data(native->data[offset++]));
+    EXPECT_CALL(mock_ipc_msg, pack_stride(stride));
+    EXPECT_CALL(mock_ipc_msg, pack_size(size));
+
+    platform.fill_buffer_package(&mock_ipc_msg, &mock_buffer, mg::BufferIpcMsgType::full_msg);
 }
 
 TEST(AndroidGraphicsPlatform, egl_native_display_is_egl_default_display)