Merge lp:~kdub/mir/mali-client-render-support into lp:~mir-team/mir/trunk

[Kevin DuBois]

android: support driver hooks for the Mali T604 (present in nexus 10)

android: support driver hooks for the Mali T604 (present in nexus 10)

The exynos driver needed some function hooks implemented. This change implements those hooks and gets the TestClientIPCRender test to pass. This test sends buffers over IPC to a client, and the client then establishes an egl context, renders to the buffer, and checks the buffer content back on the server side.

Please note: the nexus 10 display is still broken (so running a demo server won't go well), but supporting the hooks for the driver is the first step.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1075
http://jenkins.qa.ubuntu.com/job/mir-ci/1477/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1995
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1880
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/715
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/715/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-ci/1477/rebuild

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

On android (N4) I get:
./unit-tests
...
[ PASSED ] 730 tests.
[ FAILED ] 1 test, listed below:
[ FAILED ] ClientAndroidBufferTest.buffer_packs_anativewindowbuffer_info

(But it fixes a hang in SwitchingBundleTest.client_framerate_matches_compositor - so I guess it doesn't make anything worse.)

[Alan Griffiths (alan-griffiths)]

SwitchingBundleTest.client_framerate_matches_compositor is racy (and not fixed after all)

But this definitely breaks:

# ./unit-tests --gtest_filter=ClientAndroidBufferTest.buffer_packs_anativewindowbuffer_info
/home/alan/display_server/trunk-mir/tests/unit-tests/client/android/test_client_android_buffer.cpp:151: Failure
Value of: native_handle->stride
  Actual: 66
Expected: expected_stride_in_pixels
Which is: 16
[ FAILED ] ClientAndroidBufferTest.buffer_packs_anativewindowbuffer_info (2 ms)
[----------] 1 test from ClientAndroidBufferTest (2 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test case ran. (4 ms total)
[ PASSED ] 0 tests.
[ FAILED ] 1 test, listed below:
[ FAILED ] ClientAndroidBufferTest.buffer_packs_anativewindowbuffer_info

 1 FAILED TEST

review: Needs Fixing

[Kevin DuBois (kdub)]

will have to take a look at stride on android again

[Robert Carr (robertcarr)]

121 + static MirPixelFormat select_format_for_visual_id(int visual_id)
122 + {
123 + if (visual_id == 5)
124 + return mir_pixel_format_argb_8888;

It would be nice to see some constants for visual_id.

Haven't tested on nexus 4. Let me know if it needs some runs.

==
+ case NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS:
43 + return 2;
===

Wondering if this has implications on existing hardware support (n4, etc...)

review: Needs Information

=== modified file 'include/shared/mir/graphics/android/mir_native_window.h'
--- include/shared/mir/graphics/android/mir_native_window.h	2013-05-16 20:19:12 +0000
+++ include/shared/mir/graphics/android/mir_native_window.h	2013-09-13 21:49:43 +0000
@@ -41,6 +41,7 @@
     int perform(int key, va_list args );
     int dequeueBuffer(struct ANativeWindowBuffer** buffer);
     int queueBuffer(struct ANativeWindowBuffer* buffer, std::shared_ptr<SyncObject> const& fence);
+    int cancelBuffer(struct ANativeWindowBuffer* buffer, std::shared_ptr<SyncObject> const& fence);
     int setSwapInterval(int interval);
 private:
 
 
=== modified file 'src/client/android/android_client_buffer.cpp'
--- src/client/android/android_client_buffer.cpp	2013-08-28 03:41:48 +0000
+++ src/client/android/android_client_buffer.cpp	2013-09-13 21:49:43 +0000
@@ -41,8 +41,7 @@
 
     native_window_buffer->height = static_cast<int32_t>(size.height.as_uint32_t());
     native_window_buffer->width =  static_cast<int32_t>(size.width.as_uint32_t());
-    native_window_buffer->stride = stride.as_uint32_t() /
-                                   geom::bytes_per_pixel(buffer_pf);
+    native_window_buffer->stride = stride.as_uint32_t();
     native_window_buffer->usage = GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER;
     native_window_buffer->handle = native_handle.get();
 }
 
=== modified file 'src/client/android/client_surface_interpreter.cpp'
--- src/client/android/client_surface_interpreter.cpp	2013-05-16 20:19:12 +0000
+++ src/client/android/client_surface_interpreter.cpp	2013-09-13 21:49:43 +0000
@@ -33,6 +33,7 @@
 {
     auto buffer = surface.get_current_buffer();
     auto buffer_to_driver = buffer->native_buffer_handle();
+
     buffer_to_driver->format = driver_pixel_format;
 
     return buffer_to_driver.get();
@@ -65,6 +66,8 @@
             return driver_pixel_format;
         case NATIVE_WINDOW_TRANSFORM_HINT:
             return 0;
+        case NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS:
+            return 2;
         default:
             throw std::runtime_error("driver requested unsupported query");
     }
 
=== modified file 'src/shared/graphics/android/mir_native_window.cpp'
--- src/shared/graphics/android/mir_native_window.cpp	2013-05-20 15:29:28 +0000
+++ src/shared/graphics/android/mir_native_window.cpp	2013-09-13 21:49:43 +0000
@@ -128,16 +128,19 @@
     return 0;
 }
 
-int cancelBuffer_deprecated_static(struct ANativeWindow* /*window*/,
-                        struct ANativeWindowBuffer* /*buffer*/)
+int cancelBuffer_deprecated_static(struct ANativeWindow* window,
+                        struct ANativeWindowBuffer* buffer)
 {
-    return 0;
+    return cancelBuffer_static(window, buffer, -1);
 }
 
-int cancelBuffer_static(struct ANativeWindow* /*window*/,
-                        struct ANativeWindowBuffer* /*buffer*/, int /*fence_fd*/)
+int cancelBuffer_static(struct ANativeWindow* window,
+                        struct ANativeWindowBuffer* buffer, int fence_fd)
 {
-    return 0;
+    auto ioctl_control = std::make_shared<IoctlControl>();
+    auto fence = std::make_shared<mga::SyncFence>(fence_fd, ioctl_control);
+    auto self = static_cast<mga::MirNativeWindow*>(window);
+    return self->cancelBuffer(buffer, fence);
 }
 
 }
@@ -182,7 +185,15 @@
     return 0;
 }
 
-int mga::MirNativeWindow::queueBuffer(struct ANativeWindowBuffer* buffer, std::shared_ptr<mga::SyncObject> const& fence)
+int mga::MirNativeWindow::queueBuffer(struct ANativeWindowBuffer* buffer,
+                                      std::shared_ptr<mga::SyncObject> const& fence)
+{
+    driver_interpreter->driver_returns_buffer(buffer, fence);
+    return 0;
+}
+
+int mga::MirNativeWindow::cancelBuffer(struct ANativeWindowBuffer* buffer,
+                                       std::shared_ptr<mga::SyncObject> const& fence)
 {
     driver_interpreter->driver_returns_buffer(buffer, fence);
     return 0;
 
=== modified file 'tests/integration-tests/client/test_client_render.cpp'
--- tests/integration-tests/client/test_client_render.cpp	2013-08-28 03:41:48 +0000
+++ tests/integration-tests/client/test_client_render.cpp	2013-09-13 21:49:43 +0000
@@ -29,6 +29,7 @@
 
 #include "mir/frontend/communicator.h"
 
+#include <iostream>
 #include <gmock/gmock.h>
 #include <thread>
 #include <hardware/gralloc.h>
@@ -65,10 +66,6 @@
     *surf = surface;
 }
 
-static void next_callback(MirSurface *, void*)
-{
-}
-
 static uint32_t pattern0 [2][2] = {{0x12345678, 0x23456789},
                                    {0x34567890, 0x45678901}};
 
@@ -76,6 +73,15 @@
                                    {0xFF00FF00, 0xFF0000FF}};
 struct TestClient
 {
+    static MirPixelFormat select_format_for_visual_id(int visual_id)
+    {
+        if (visual_id == 5)
+            return mir_pixel_format_argb_8888;
+        if (visual_id == 1)
+            return mir_pixel_format_abgr_8888;
+
+        return mir_pixel_format_invalid;
+    }
 
     static void sig_handle(int)
     {
@@ -115,6 +121,8 @@
         /* render pattern */
         mtd::DrawPatternCheckered<2,2> draw_pattern0(mt::pattern0);
         draw_pattern0.draw(graphics_region);
+ 
+        mir_surface_swap_buffers_sync(surface);
 
         mir_wait_for(mir_surface_release(surface, &create_callback, &surface));
 
@@ -156,11 +164,13 @@
         mtd::DrawPatternCheckered<2,2> draw_pattern0(mt::pattern0);
         draw_pattern0.draw(graphics_region);
 
-        mir_wait_for(mir_surface_swap_buffers(surface, &next_callback, (void*) NULL));
+        mir_surface_swap_buffers_sync(surface);
         mir_surface_get_graphics_region( surface, graphics_region.get());
         mtd::DrawPatternCheckered<2,2> draw_pattern1(mt::pattern1);
         draw_pattern1.draw(graphics_region);
 
+        mir_surface_swap_buffers_sync(surface);
+
         mir_wait_for(mir_surface_release(surface, &create_callback, &surface));
 
         /* release */
@@ -168,68 +178,62 @@
         return 0;
     }
 
+    static MirSurface* create_mir_surface(MirConnection * connection, EGLDisplay display, EGLConfig config)
+    {
+        int visual_id;
+        eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &visual_id);
+
+        /* make surface */
+        MirSurfaceParameters surface_parameters;
+        surface_parameters.name = "testsurface";
+        surface_parameters.width = test_width;
+        surface_parameters.height = test_height;
+        surface_parameters.pixel_format = select_format_for_visual_id(visual_id);
+        return mir_connection_create_surface_sync(connection, &surface_parameters);
+    }
+
     static int render_accelerated()
     {
         if (signal(SIGCONT, sig_handle) == SIG_ERR)
             return -1;
         pause();
 
-        /* only use C api */
-        MirConnection* connection = NULL;
-        MirSurface* surface;
-        MirSurfaceParameters surface_parameters;
-
-         /* establish connection. wait for server to come up */
-        while (connection == NULL)
-        {
-            mir_wait_for(mir_connect("./test_socket_surface", "test_renderer",
-                                         &connected_callback, &connection));
-            std::this_thread::sleep_for(std::chrono::milliseconds(10));
-        }
-        /* make surface */
-        surface_parameters.name = "testsurface";
-        surface_parameters.width = test_width;
-        surface_parameters.height = test_height;
-        surface_parameters.pixel_format = mir_pixel_format_abgr_8888;
-
-        mir_wait_for(mir_connection_create_surface(connection,
-                                                   &surface_parameters,
-                                                   &create_callback,
-                                                   &surface));
-
         int major, minor, n;
-        EGLDisplay disp;
         EGLContext context;
         EGLSurface egl_surface;
         EGLConfig egl_config;
         EGLint attribs[] = {
             EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
-            EGL_GREEN_SIZE, 8,
+            EGL_BUFFER_SIZE, 32,
             EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
             EGL_NONE };
         EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
 
-        EGLNativeDisplayType native_display = (EGLNativeDisplayType)mir_connection_get_egl_native_display(connection);
-        EGLNativeWindowType native_window = (EGLNativeWindowType) mir_surface_get_egl_native_window(surface);
-
-        disp = eglGetDisplay(native_display);
-        eglInitialize(disp, &major, &minor);
-
-        eglChooseConfig(disp, attribs, &egl_config, 1, &n);
-        egl_surface = eglCreateWindowSurface(disp, egl_config, native_window, NULL);
-        context = eglCreateContext(disp, egl_config, EGL_NO_CONTEXT, context_attribs);
-        eglMakeCurrent(disp, egl_surface, egl_surface, context);
+        auto connection = mir_connect_sync("./test_socket_surface", "test_renderer");
+
+        auto native_display = mir_connection_get_egl_native_display(connection);
+        auto egl_display = eglGetDisplay(native_display);
+        eglInitialize(egl_display, &major, &minor);
+        eglChooseConfig(egl_display, attribs, &egl_config, 1, &n); 
+
+        auto mir_surface = create_mir_surface(connection, egl_display, egl_config); 
+        auto native_window = static_cast<EGLNativeWindowType>(
+            mir_surface_get_egl_native_window(mir_surface)); 
+    
+        egl_surface = eglCreateWindowSurface(egl_display, egl_config, native_window, NULL);
+        context = eglCreateContext(egl_display, egl_config, EGL_NO_CONTEXT, context_attribs);
+        eglMakeCurrent(egl_display, egl_surface, egl_surface, context);
 
         glClearColor(1.0, 0.0, 0.0, 1.0);
         glClear(GL_COLOR_BUFFER_BIT);
 
-        eglSwapBuffers(disp, egl_surface);
-        mir_wait_for(mir_surface_release(surface, &create_callback, &surface));
+        eglSwapBuffers(egl_display, egl_surface);
+        
+        mir_surface_release_sync(mir_surface);
 
         /* release */
         mir_connection_release(connection);
         return 0;
-
     }
 
     static int render_accelerated_double()
@@ -238,68 +242,46 @@
             return -1;
         pause();
 
-        /* only use C api */
-        MirConnection* connection = NULL;
-        MirSurface* surface;
-        MirSurfaceParameters surface_parameters;
-
-         /* establish connection. wait for server to come up */
-        while (connection == NULL)
-        {
-            mir_wait_for(mir_connect("./test_socket_surface", "test_renderer",
-                                         &connected_callback, &connection));
-            std::this_thread::sleep_for(std::chrono::milliseconds(10));
-        }
-        /* make surface */
-        surface_parameters.name = "testsurface";
-        surface_parameters.width = test_width;
-        surface_parameters.height = test_height;
-        surface_parameters.pixel_format = mir_pixel_format_abgr_8888;
-
-        mir_wait_for(mir_connection_create_surface(connection,
-                                                   &surface_parameters,
-                                                   &create_callback,
-                                                   &surface));
-
         int major, minor, n;
-        EGLDisplay disp;
         EGLContext context;
         EGLSurface egl_surface;
         EGLConfig egl_config;
         EGLint attribs[] = {
             EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
-            EGL_GREEN_SIZE, 8,
+            EGL_BUFFER_SIZE, 32,
             EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
             EGL_NONE };
         EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
 
-        EGLNativeDisplayType native_display = (EGLNativeDisplayType)mir_connection_get_egl_native_display(connection);
-        EGLNativeWindowType native_window = (EGLNativeWindowType)mir_surface_get_egl_native_window(surface);
-
-        disp = eglGetDisplay(native_display);
-        eglInitialize(disp, &major, &minor);
-
-        eglChooseConfig(disp, attribs, &egl_config, 1, &n);
-        egl_surface = eglCreateWindowSurface(disp, egl_config, native_window, NULL);
-        context = eglCreateContext(disp, egl_config, EGL_NO_CONTEXT, context_attribs);
-        eglMakeCurrent(disp, egl_surface, egl_surface, context);
-
+        auto connection = mir_connect_sync("./test_socket_surface", "test_renderer");
+
+        auto native_display = mir_connection_get_egl_native_display(connection);
+        auto egl_display = eglGetDisplay(native_display);
+        eglInitialize(egl_display, &major, &minor);
+        eglChooseConfig(egl_display, attribs, &egl_config, 1, &n); 
+
+        auto mir_surface = create_mir_surface(connection, egl_display, egl_config); 
+        auto native_window = static_cast<EGLNativeWindowType>(
+            mir_surface_get_egl_native_window(mir_surface)); 
+    
+        egl_surface = eglCreateWindowSurface(egl_display, egl_config, native_window, NULL);
+        context = eglCreateContext(egl_display, egl_config, EGL_NO_CONTEXT, context_attribs);
+        eglMakeCurrent(egl_display, egl_surface, egl_surface, context);
+
+        //draw red
         glClearColor(1.0, 0.0, 0.0, 1.0);
         glClear(GL_COLOR_BUFFER_BIT);
-
-        eglSwapBuffers(disp, egl_surface);
-
+        eglSwapBuffers(egl_display, egl_surface);
+
+        //draw green 
         glClearColor(0.0, 1.0, 0.0, 1.0);
         glClear(GL_COLOR_BUFFER_BIT);
-
-        eglSwapBuffers(disp, egl_surface);
-
-        mir_wait_for(mir_surface_release(surface, &create_callback, &surface));
-
-        /* release */
+        eglSwapBuffers(egl_display, egl_surface);
+        
+        mir_surface_release_sync(mir_surface);
+
         mir_connection_release(connection);
         return 0;
-
     }
 
     static int exit_function()
@@ -311,13 +293,13 @@
 /* server code */
 struct StubServerGenerator : public mt::StubServerTool
 {
-    StubServerGenerator(std::shared_ptr<MirNativeBuffer> const& handle, int id)
-     : handle(handle),
-       next_received(false),
-       next_allowed(false),
-       handle_id(id)
+    StubServerGenerator(std::shared_ptr<MirNativeBuffer> const& handle0,
+                        std::shared_ptr<MirNativeBuffer> const& handle1)
+     : handle0(handle0),
+       handle1(handle1),
+       next_buffer_count(0),
+       buffer_count(2)
     {
-
     }
 
     void create_surface(google::protobuf::RpcController* /*controller*/,
@@ -325,18 +307,21 @@
                  mir::protobuf::Surface* response,
                  google::protobuf::Closure* done)
     {
-        response->mutable_id()->set_value(13); // TODO distinct numbers & tracking
+        auto next_handle = get_next_handle();
+
+        response->mutable_id()->set_value(13); //surface id
         response->set_width(test_width);
         response->set_height(test_height);
+        surface_pf = geom::PixelFormat(request->pixel_format());
         response->set_pixel_format(request->pixel_format());
-        response->mutable_buffer()->set_buffer_id(handle_id);
-        response->mutable_buffer()->set_stride(handle->stride);
+        response->mutable_buffer()->set_buffer_id(next_buffer_count % buffer_count);
+        response->mutable_buffer()->set_stride(next_handle->stride);
 
         response->mutable_buffer()->set_fds_on_side_channel(1);
-        native_handle_t const* native_handle = handle->handle;
-        for(auto i=0; i<native_handle->numFds; i++)
+        native_handle_t const* native_handle = next_handle->handle;
+        for(auto i=0; i < native_handle->numFds; i++)
             response->mutable_buffer()->add_fd(native_handle->data[i]);
-        for(auto i=0; i<native_handle->numInts; i++)
+        for(auto i=0; i < native_handle->numInts; i++)
             response->mutable_buffer()->add_data(native_handle->data[native_handle->numFds+i]);
 
         std::unique_lock<std::mutex> lock(guard);
@@ -352,22 +337,12 @@
         ::mir::protobuf::Buffer* response,
         ::google::protobuf::Closure* done)
     {
-        {
-            std::unique_lock<std::mutex> lk(next_guard);
-            next_received = true;
-            next_cv.notify_all();
-
-            while (!next_allowed) {
-                allow_cv.wait(lk);
-            }
-            next_allowed = false;
-        }
-
-        response->set_buffer_id(handle_id);
+        auto next_handle = get_next_handle();
+        response->set_buffer_id(next_buffer_count % buffer_count);
 
         response->set_fds_on_side_channel(1);
-        native_handle_t const* native_handle = handle->handle;
-        response->set_stride(handle->stride);
+        native_handle_t const* native_handle = next_handle->handle;
+        response->set_stride(next_handle->stride);
         for(auto i=0; i<native_handle->numFds; i++)
             response->add_fd(native_handle->data[i]);
         for(auto i=0; i<native_handle->numInts; i++)
@@ -376,41 +351,46 @@
         done->Run();
     }
 
-    void wait_on_next_buffer()
-    {
-        std::unique_lock<std::mutex> lk(next_guard);
-        while (!next_received)
-            next_cv.wait(lk);
-        next_received = false;
-    }
-
-    void allow_next_continue()
-    {
-        std::unique_lock<std::mutex> lk(next_guard);
-        next_allowed = true;
-        allow_cv.notify_all();
-        lk.unlock();
-    }
-
-    void set_handle(std::shared_ptr<MirNativeBuffer> const& pack, int id)
-    {
-        handle = pack;
-        handle_id = id;
+    std::shared_ptr<MirNativeBuffer> get_next_handle()
+    {
+        std::swap(handle0, handle1);
+        next_buffer_count++;
+        return handle0;
+    }
+
+    std::shared_ptr<MirNativeBuffer> second_to_last_returned()
+    {
+        return handle0;
+    }
+
+    std::shared_ptr<MirNativeBuffer> last_returned()
+    {
+        return handle1;
+    }
+
+    uint32_t red_value_for_surface()
+    {
+        if ((surface_pf == geom::PixelFormat::abgr_8888) || (surface_pf == geom::PixelFormat::xbgr_8888))
+            return 0xFF0000FF;
+
+        if ((surface_pf == geom::PixelFormat::argb_8888) || (surface_pf == geom::PixelFormat::xrgb_8888))
+            return 0xFFFF0000;
+
+        return 0x0;
+    }
+
+    uint32_t green_value_for_surface()
+    {
+        return 0xFF00FF00;
     }
 
 private:
-    std::shared_ptr<MirNativeBuffer> handle;
-
-    std::mutex next_guard;
-    std::condition_variable next_cv;
-    std::condition_variable allow_cv;
-    bool next_received;
-    bool next_allowed;
-
-    int handle_id;
+    geom::PixelFormat surface_pf; //must be a 32 bit one;
+    std::shared_ptr<MirNativeBuffer> handle0, handle1;
+    int next_buffer_count;
+    int const buffer_count;
 };
 
-
 }
 }
 
@@ -429,11 +409,6 @@
             mt::TestClient::render_double,
             mt::TestClient::exit_function);
 
-        second_render_with_same_buffer_client_process
-             = mtf::fork_and_run_in_a_different_process(
-                            mt::TestClient::render_double,
-                            mt::TestClient::exit_function);
-
         render_accelerated_process
              = mtf::fork_and_run_in_a_different_process(
                             mt::TestClient::render_accelerated,
@@ -448,22 +423,22 @@
     void SetUp() {
         ASSERT_FALSE(mtd::is_surface_flinger_running());
 
-        size = geom::Size{test_width, test_height};
-        pf = geom::PixelFormat::abgr_8888;
+        auto size = geom::Size{test_width, test_height};
+        auto pf = geom::PixelFormat::argb_8888;
+
+        buffer_converter = std::make_shared<mtd::TestGrallocMapper>();
 
         auto initializer = std::make_shared<mg::NullBufferInitializer>();
-        allocator = std::make_shared<mga::AndroidGraphicBufferAllocator> (initializer);
+        auto allocator = std::make_shared<mga::AndroidGraphicBufferAllocator> (initializer);
         mg::BufferProperties properties(size, pf, mg::BufferUsage::hardware);
-        android_buffer = allocator->alloc_buffer(properties);
-        second_android_buffer = allocator->alloc_buffer(properties);
-
-        buffer_converter = std::make_shared<mtd::TestGrallocMapper>();
-
-        handle = android_buffer->native_buffer_handle();
-        second_handle = second_android_buffer->native_buffer_handle();
+        android_buffer0 = allocator->alloc_buffer(properties);
+        android_buffer1 = allocator->alloc_buffer(properties);
+
+        auto handle0 = android_buffer0->native_buffer_handle();
+        auto handle1 = android_buffer1->native_buffer_handle();
 
         /* start a server */
-        mock_server = std::make_shared<mt::StubServerGenerator>(handle, 14);
+        mock_server = std::make_shared<mt::StubServerGenerator>(handle0, handle1);
         test_server = std::make_shared<mt::TestProtobufServer>("./test_socket_surface", mock_server);
         test_server->comm->start();
     }
@@ -478,29 +453,19 @@
     std::shared_ptr<mt::TestProtobufServer> test_server;
     std::shared_ptr<mt::StubServerGenerator> mock_server;
 
-    geom::Size size;
-    geom::PixelFormat pf;
-    mg::BufferID id1;
-    mg::BufferID id2;
     std::shared_ptr<mtd::TestGrallocMapper> buffer_converter;
     std::shared_ptr<mtf::Process> client_process;
 
-    std::shared_ptr<MirNativeBuffer> handle;
-    std::shared_ptr<MirNativeBuffer> second_handle;
-
-    std::shared_ptr<mg::Buffer> android_buffer;
-    std::shared_ptr<mg::Buffer> second_android_buffer;
-    std::shared_ptr<mga::AndroidGraphicBufferAllocator>  allocator;
+    std::shared_ptr<mg::Buffer> android_buffer0;
+    std::shared_ptr<mg::Buffer> android_buffer1;
 
     static std::shared_ptr<mtf::Process> render_single_client_process;
     static std::shared_ptr<mtf::Process> render_double_client_process;
-    static std::shared_ptr<mtf::Process> second_render_with_same_buffer_client_process;
     static std::shared_ptr<mtf::Process> render_accelerated_process;
     static std::shared_ptr<mtf::Process> render_accelerated_process_double;
 };
 std::shared_ptr<mtf::Process> TestClientIPCRender::render_single_client_process;
 std::shared_ptr<mtf::Process> TestClientIPCRender::render_double_client_process;
-std::shared_ptr<mtf::Process> TestClientIPCRender::second_render_with_same_buffer_client_process;
 std::shared_ptr<mtf::Process> TestClientIPCRender::render_accelerated_process;
 std::shared_ptr<mtf::Process> TestClientIPCRender::render_accelerated_process_double;
 
@@ -514,8 +479,8 @@
     EXPECT_TRUE(render_single_client_process->wait_for_termination().succeeded());
 
     /* check content */
-    auto region = buffer_converter->graphic_region_from_handle(handle);
-    EXPECT_TRUE(rendered_pattern.check(region));
+    auto last_handle = mock_server->last_returned();
+    EXPECT_TRUE(rendered_pattern.check(buffer_converter->graphic_region_from_handle(last_handle)));
 }
 
 TEST_F(TestClientIPCRender, test_render_double)
@@ -525,80 +490,42 @@
     /* activate client */
     render_double_client_process->cont();
 
-    /* wait for next buffer */
-    mock_server->wait_on_next_buffer();
-    auto region = buffer_converter->graphic_region_from_handle(handle);
+    /* wait for client to finish */
+    EXPECT_TRUE(render_double_client_process->wait_for_termination().succeeded());
+
+    auto second_to_last_handle = mock_server->second_to_last_returned();
+    auto region = buffer_converter->graphic_region_from_handle(second_to_last_handle);
     EXPECT_TRUE(rendered_pattern0.check(region));
 
-    mock_server->set_handle(second_handle, 15);
-    mock_server->allow_next_continue();
-
-    /* wait for client to finish */
-    EXPECT_TRUE(render_double_client_process->wait_for_termination().succeeded());
-
-    auto second_region = buffer_converter->graphic_region_from_handle(second_handle);
+    auto last_handle = mock_server->last_returned();
+    auto second_region = buffer_converter->graphic_region_from_handle(last_handle);
     EXPECT_TRUE(rendered_pattern1.check(second_region));
 }
 
-TEST_F(TestClientIPCRender, test_second_render_with_same_buffer)
-{
-    mtd::DrawPatternCheckered<2,2> rendered_pattern(mt::pattern1);
-    /* activate client */
-    second_render_with_same_buffer_client_process->cont();
-
-    /* wait for next buffer */
-    mock_server->wait_on_next_buffer();
-    mock_server->allow_next_continue();
-
-    /* wait for client to finish */
-    EXPECT_TRUE(second_render_with_same_buffer_client_process->wait_for_termination().succeeded());
-
-    /* check content */
-    auto region = buffer_converter->graphic_region_from_handle(handle);
-    EXPECT_TRUE(rendered_pattern.check(region));
-}
-
 TEST_F(TestClientIPCRender, test_accelerated_render)
 {
-    mtd::DrawPatternSolid red_pattern(0xFF0000FF);
-
-    /* activate client */
     render_accelerated_process->cont();
-
-    /* wait for next buffer */
-    mock_server->wait_on_next_buffer();
-    mock_server->allow_next_continue();
-
-    /* wait for client to finish */
     EXPECT_TRUE(render_accelerated_process->wait_for_termination().succeeded());
 
     /* check content */
-    auto region = buffer_converter->graphic_region_from_handle(handle);
-    EXPECT_TRUE(red_pattern.check(region));
+    mtd::DrawPatternSolid red_pattern(mock_server->red_value_for_surface());
+    auto last_handle = mock_server->last_returned();
+    EXPECT_TRUE(red_pattern.check(buffer_converter->graphic_region_from_handle(last_handle)));
 }
 
 TEST_F(TestClientIPCRender, test_accelerated_render_double)
 {
-    mtd::DrawPatternSolid red_pattern(0xFF0000FF);
-    mtd::DrawPatternSolid green_pattern(0xFF00FF00);
-    /* activate client */
     render_accelerated_process_double->cont();
-
-    /* wait for next buffer */
-    mock_server->wait_on_next_buffer();
-    mock_server->set_handle(second_handle, 15);
-    mock_server->allow_next_continue();
-
-    mock_server->wait_on_next_buffer();
-    mock_server->allow_next_continue();
-
-    /* wait for client to finish */
     EXPECT_TRUE(render_accelerated_process_double->wait_for_termination().succeeded());
 
     /* check content */
-    auto region = buffer_converter->graphic_region_from_handle(handle);
+    mtd::DrawPatternSolid red_pattern(mock_server->red_value_for_surface());
+    auto second_to_last_handle = mock_server->second_to_last_returned();
+    auto region = buffer_converter->graphic_region_from_handle(second_to_last_handle);
     EXPECT_TRUE(red_pattern.check(region));
 
-    auto second_region = buffer_converter->graphic_region_from_handle(second_handle);
+    mtd::DrawPatternSolid green_pattern(mock_server->green_value_for_surface());
+    auto last_handle = mock_server->last_returned();
+    auto second_region = buffer_converter->graphic_region_from_handle(last_handle);
     EXPECT_TRUE(green_pattern.check(second_region));
 }
 
=== modified file 'tests/unit-tests/client/android/test_android_native_window.cpp'
--- tests/unit-tests/client/android/test_android_native_window.cpp	2013-05-16 20:07:39 +0000
+++ tests/unit-tests/client/android/test_android_native_window.cpp	2013-09-13 21:49:43 +0000
@@ -288,3 +288,17 @@
     auto ret = window->dequeueBuffer(window.get(), &tmp, &fencefd);
     EXPECT_EQ(0, ret);
 }
+
+TEST_F(AndroidNativeWindowTest, native_window_cancel_hook_behavior)
+{
+    using namespace testing;
+    ANativeWindowBuffer buffer;
+    int fence_fd = 33;
+
+    EXPECT_CALL(*mock_driver_interpreter, driver_returns_buffer(&buffer, _))
+        .Times(1);
+
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mga::MirNativeWindow>(mock_driver_interpreter);
+    auto rc = window->cancelBuffer(window.get(), &buffer, fence_fd);
+    EXPECT_EQ(0, rc);
+}
 
=== modified file 'tests/unit-tests/client/android/test_client_surface_interpreter.cpp'
--- tests/unit-tests/client/android/test_client_surface_interpreter.cpp	2013-07-01 15:10:36 +0000
+++ tests/unit-tests/client/android/test_client_surface_interpreter.cpp	2013-09-13 21:49:43 +0000
@@ -227,3 +227,19 @@
 
     EXPECT_EQ(surf_params.height, height);
 }
+
+/* this is query key is a bit confusing from the system/window.h description.
+   what it means is the minimum number of buffers that the server reserves for its own use in steady 
+   state. The drivers consider 'steady state' to begin after the first call to queueBuffer.
+   So, for instance, if a driver requires 3 buffers to run at steady state, and the server needs
+   to keep 2 buffers on hand at all time, the driver might dequeue 5 buffers, then cancel those 5 buffers.
+   After the first call to queueBuffer however, the client may never own more than the number it has
+   reserved (in this case, 3 buffers) */
+TEST_F(AndroidInterpreterTest, native_window_minimum_undequeued_query_hook)
+{
+    testing::NiceMock<MockMirSurface> mock_surface{surf_params};
+    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
+
+    auto num_buffers = interpreter.driver_requests_info(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS);
+    EXPECT_EQ(2, num_buffers);
+}