Merge lp:~kdub/mir/upgrade-anativewindow into lp:~mir-team/mir/trunk

[Kevin DuBois]

Upgrade ANativeWindow to use the newer JB interface to ANativeWindow (largely adding one parameter to the end of 3 functions). This is necessary for the jb driver present on qcom/nexus4

Upgrade ANativeWindow to use the newer JB interface to ANativeWindow (largely adding one parameter to the end of 3 functions). This is necessary for the jb driver present on qcom/nexus4

Basically, what was done is to separate MirNativeWindow into a bit that does the 'basic book-keeping' (like hooking up the C function pointers properly, and figuring out what the C functions are trying to do), and the bit that does the core of what we're trying to do, provide the buffers and buffer info to the driver.

This has the nice effect that 1) we're decoupled from change to the the basic book-keeping bits and 2) we can write different implementations of the AndroidDriverInterpreter interface that do different things without changing the 'basic book-keeping' of MirNativeWindow. For instance, the implementation we have now (ClientSurfaceInterpreter) will serve the client's driver buffers that we got over IPC. I plan on writing an implementation that will serve framebuffer buffers to the compositor's driver, and one that will serve 'in-process egl' buffers too

more nuts and bolts about the changes:
I separated the file, tests/unit-tests/client/test_android_native_window.cpp into tests/unit-tests/client/test_android_native_window.cpp and tests/unit-tests/client/test_client_surface_interpreter.cpp with the intention of preserving the test, but moving the tests that test the AndroidDriverInterpreter portions to the new file

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:493
http://jenkins.qa.ubuntu.com/job/mir-ci/14/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/14//console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/mir-ci/14//rebuild/?

review: Approve (continuous-integration)

[Alexandros Frantzis (afrantzis)]

43 + * Copyright © 2012 Canonical Ltd.
...and at other points

Happy new year!

28 -std::shared_ptr<EGLNativeWindowType> mcla::AndroidClientPlatform::create_egl_native_window(ClientSurface *surface)
29 +std::shared_ptr<EGLNativeWindowType> mcla::AndroidClientPlatform::create_egl_native_window(ClientSurface * surface)

Either left or right.

71 +class AndroidDriverInterpreter

Missing a virtual destructor.
Also, do we support the copy/assignment operations. If not, we should =delete them.

114 +mcla::ClientSurfaceInterpreter::ClientSurfaceInterpreter(ClientSurface* surface)

Although this is in line with how ClientPlatform::create_egl_native_window() accepts the ClientSurface parameter, I don't see a reason to use a pointer instead of a reference, since I don't think we support/handle null pointers for this operation, nor we need to take ownership of the object.

For another MP: Also change ClientPlatform::create_egl_native_window() to accept a reference instead.

786 + EXPECT_NO_THROW({

I used to use EXPECT_NO_THROW, but I found that they are not helpful at all. When an exception is thrown, the test framework will say something like "expected: no to throw, actual: it throws", which is rather useless for debugging. Without the EXPECT_NO_THROW, slightly more detailed information is printed out, and, of course, the test still fails as expected.

review: Needs Fixing

[Kevin DuBois (kdub)]

all good points, the updates should have addressed them all.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:497
http://jenkins.qa.ubuntu.com/job/mir-ci/28/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/28//console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/mir-ci/28//rebuild/?

review: Approve (continuous-integration)

[Alexandros Frantzis (afrantzis)]

The changes look good, some nitpicks left:

29 +std::shared_ptr<EGLNativeWindowType> mcla::AndroidClientPlatform::create_egl_native_window(ClientSurface * surface)

The fate of '*' still hasn't been decided.

75 + virtual void driver_returns_buffer(ANativeWindowBuffer*, int fence_fd ) = 0;
136 +void mcla::ClientSurfaceInterpreter::driver_returns_buffer(ANativeWindowBuffer*, int /*fence_fd*/ )
206 + void driver_returns_buffer(ANativeWindowBuffer*, int fence_fd );

Space before right parenthesis.

421 + explicit MirNativeWindow(std::shared_ptr<AndroidDriverInterpreter> interpreter);

shared_ptr const& ?

432 + std::shared_ptr<AndroidDriverInterpreter> driver_interpreter;

shared_ptr const ?

1143 + EXPECT_EQ(returned_buffer, &buffer);
1171 + EXPECT_EQ(tmp_format, format);

Expected/Actual in reverse order.

review: Needs Fixing

[Robert Carr (robertcarr)]

Looks good to me besides alf's points.

[Alexandros Frantzis (afrantzis)]

Looks good.

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:498
http://jenkins.qa.ubuntu.com/job/mir-ci/57/
Executed test runs:

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/mir-ci/57//rebuild/?

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:498
http://jenkins.qa.ubuntu.com/job/mir-ci/57/
Executed test runs:
    None: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=quantal,flavor=amd64/795/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/mir-ci/57//rebuild/?

review: Approve (continuous-integration)

=== modified file 'src/client/CMakeLists.txt'
--- src/client/CMakeLists.txt	2013-03-07 08:04:05 +0000
+++ src/client/CMakeLists.txt	2013-03-12 15:51:13 +0000
@@ -58,6 +58,7 @@
   android/android_registrar.cpp
   android/android_client_platform.cpp
   android/mir_native_window.cpp
+  android/client_surface_interpreter.cpp
   ${CLIENT_SOURCES}
 )
 endif()

=== modified file 'src/client/android/android_client_platform.cpp'
--- src/client/android/android_client_platform.cpp	2013-03-07 08:04:05 +0000
+++ src/client/android/android_client_platform.cpp	2013-03-12 15:51:13 +0000
@@ -20,6 +20,7 @@
 #include "android_client_platform.h"
 #include "android_registrar_gralloc.h"
 #include "android_client_buffer_depository.h"
+#include "client_surface_interpreter.h"
 #include "../mir_connection.h"
 #include "../native_client_platform_factory.h"
 
@@ -85,7 +86,8 @@
 
 std::shared_ptr<EGLNativeWindowType> mcla::AndroidClientPlatform::create_egl_native_window(ClientSurface *surface)
 {
-    auto mir_native_window = new mcla::MirNativeWindow(surface);
+    auto anativewindow_interpreter = std::make_shared<mcla::ClientSurfaceInterpreter>(*surface);
+    auto mir_native_window = new mcla::MirNativeWindow(anativewindow_interpreter);
     auto egl_native_window = new EGLNativeWindowType;
     *egl_native_window = mir_native_window;
     MirNativeWindowDeleter deleter = MirNativeWindowDeleter(mir_native_window);

=== added file 'src/client/android/android_driver_interpreter.h'
--- src/client/android/android_driver_interpreter.h	1970-01-01 00:00:00 +0000
+++ src/client/android/android_driver_interpreter.h	2013-03-12 15:51:13 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_CLIENT_ANDROID_ANDROID_DRIVER_INTERPRETER_H_
+#define MIR_CLIENT_ANDROID_ANDROID_DRIVER_INTERPRETER_H_
+
+#include <system/window.h>
+
+namespace mir
+{
+namespace client
+{
+namespace android
+{
+class AndroidDriverInterpreter
+{
+public:
+    virtual ANativeWindowBuffer* driver_requests_buffer() = 0;
+    virtual void driver_returns_buffer(ANativeWindowBuffer*, int fence_fd) = 0;
+    virtual void dispatch_driver_request_format(int format) = 0;
+    virtual int  driver_requests_info(int key) const = 0;
+protected:
+    AndroidDriverInterpreter() {};
+    virtual ~AndroidDriverInterpreter() {};
+    AndroidDriverInterpreter(AndroidDriverInterpreter const&) = delete;
+    AndroidDriverInterpreter& operator=(AndroidDriverInterpreter const&) = delete;
+};
+
+}
+}
+}
+
+#endif /* MIR_CLIENT_ANDROID_ANDROID_DRIVER_INTERPRETER_H_ */

=== added file 'src/client/android/client_surface_interpreter.cpp'
--- src/client/android/client_surface_interpreter.cpp	1970-01-01 00:00:00 +0000
+++ src/client/android/client_surface_interpreter.cpp	2013-03-12 15:51:13 +0000
@@ -0,0 +1,69 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "client_surface_interpreter.h"
+#include "../client_buffer.h"
+#include <stdexcept>
+
+namespace mcla=mir::client::android;
+
+mcla::ClientSurfaceInterpreter::ClientSurfaceInterpreter(ClientSurface& surface)
+ :  surface(surface),
+    driver_pixel_format(-1)
+{
+}
+
+ANativeWindowBuffer* mcla::ClientSurfaceInterpreter::driver_requests_buffer()
+{
+    auto buffer = surface.get_current_buffer();
+    auto buffer_to_driver = buffer->get_native_handle();
+    buffer_to_driver->format = driver_pixel_format;
+
+    return buffer_to_driver;
+}
+
+static void empty(MirSurface * /*surface*/, void * /*client_context*/)
+{}
+void mcla::ClientSurfaceInterpreter::driver_returns_buffer(ANativeWindowBuffer*, int /*fence_fd*/)
+{
+    mir_wait_for(surface.next_buffer(empty, NULL));
+}
+
+void mcla::ClientSurfaceInterpreter::dispatch_driver_request_format(int format)
+{
+    driver_pixel_format = format;
+}
+
+int  mcla::ClientSurfaceInterpreter::driver_requests_info(int key) const
+{
+    switch (key)
+    {
+        case NATIVE_WINDOW_WIDTH:
+        case NATIVE_WINDOW_DEFAULT_WIDTH:
+            return surface.get_parameters().width;
+        case NATIVE_WINDOW_HEIGHT:
+        case NATIVE_WINDOW_DEFAULT_HEIGHT:
+            return surface.get_parameters().height;
+        case NATIVE_WINDOW_FORMAT:
+            return driver_pixel_format;
+        case NATIVE_WINDOW_TRANSFORM_HINT:
+            return 0;
+        default:
+            throw std::runtime_error("driver requested unsupported query");
+    }
+}

=== added file 'src/client/android/client_surface_interpreter.h'
--- src/client/android/client_surface_interpreter.h	1970-01-01 00:00:00 +0000
+++ src/client/android/client_surface_interpreter.h	2013-03-12 15:51:13 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_CLIENT_ANDROID_CLIENT_SURFACE_INTERPRETER_H_
+#define MIR_CLIENT_ANDROID_CLIENT_SURFACE_INTERPRETER_H_
+
+#include "android_driver_interpreter.h"
+#include "../mir_client_surface.h"
+
+namespace mir
+{
+namespace client
+{
+namespace android
+{
+
+class ClientSurfaceInterpreter : public AndroidDriverInterpreter
+{
+public:
+    explicit ClientSurfaceInterpreter(ClientSurface& surface);
+
+    ANativeWindowBuffer* driver_requests_buffer();
+    void driver_returns_buffer(ANativeWindowBuffer*, int fence_fd);
+    void dispatch_driver_request_format(int format);
+    int  driver_requests_info(int key) const;
+private:
+    ClientSurface& surface; 
+    int driver_pixel_format;
+};
+
+}
+}
+}
+
+#endif /* MIR_CLIENT_ANDROID_CLIENT_SURFACE_INTERPRETER_H_ */

=== modified file 'src/client/android/mir_native_window.cpp'
--- src/client/android/mir_native_window.cpp	2013-03-07 08:04:05 +0000
+++ src/client/android/mir_native_window.cpp	2013-03-12 15:51:13 +0000
@@ -17,7 +17,7 @@
  */
 
 #include "mir_native_window.h"
-#include "../client_buffer.h"
+#include "android_driver_interpreter.h"
 
 namespace mcl=mir::client;
 namespace mcla=mir::client::android;
@@ -27,13 +27,19 @@
 static int query_static(const ANativeWindow* anw, int key, int* value);
 static int perform_static(ANativeWindow* anw, int key, ...);
 static int setSwapInterval_static (struct ANativeWindow* window, int interval);
+static int dequeueBuffer_deprecated_static (struct ANativeWindow* window,
+                                 struct ANativeWindowBuffer** buffer);
 static int dequeueBuffer_static (struct ANativeWindow* window,
-                                 struct ANativeWindowBuffer** buffer);
+                                 struct ANativeWindowBuffer** buffer, int* fence_fd);
 static int lockBuffer_static(struct ANativeWindow* window,
                              struct ANativeWindowBuffer* buffer);
+static int queueBuffer_deprecated_static(struct ANativeWindow* window,
+                              struct ANativeWindowBuffer* buffer);
 static int queueBuffer_static(struct ANativeWindow* window,
-                              struct ANativeWindowBuffer* buffer);
+                              struct ANativeWindowBuffer* buffer, int fence_fd);
 static int cancelBuffer_static(struct ANativeWindow* window,
+                               struct ANativeWindowBuffer* buffer, int fence_fd);
+static int cancelBuffer_deprecated_static(struct ANativeWindow* window,
                                struct ANativeWindowBuffer* buffer);
 
 static void incRef(android_native_base_t*)
@@ -57,18 +63,34 @@
     return ret;
 }
 
+int dequeueBuffer_deprecated_static (struct ANativeWindow* window,
+                          struct ANativeWindowBuffer** buffer)
+{
+    auto self = static_cast<mcla::MirNativeWindow*>(window);
+    return self->dequeueBuffer(buffer);
+}
+
 int dequeueBuffer_static (struct ANativeWindow* window,
-                          struct ANativeWindowBuffer** buffer)
+                          struct ANativeWindowBuffer** buffer, int* fence_fd)
 {
+    *fence_fd = -1;
     auto self = static_cast<mcla::MirNativeWindow*>(window);
     return self->dequeueBuffer(buffer);
 }
 
+int queueBuffer_deprecated_static(struct ANativeWindow* window,
+                       struct ANativeWindowBuffer* buffer)
+{
+    auto self = static_cast<mcla::MirNativeWindow*>(window);
+    return self->queueBuffer(buffer, -1);
+}
+
 int queueBuffer_static(struct ANativeWindow* window,
-                       struct ANativeWindowBuffer* buffer)
+                       struct ANativeWindowBuffer* buffer, int fence_fd)
 {
     auto self = static_cast<mcla::MirNativeWindow*>(window);
-    return self->queueBuffer(buffer);
+    return self->queueBuffer(buffer, fence_fd);
+
 }
 
 /* setSwapInterval, lockBuffer, and cancelBuffer don't seem to being called by the driver. for now just return without calling into MirNativeWindow */
@@ -83,25 +105,33 @@
     return 0;
 }
 
+int cancelBuffer_deprecated_static(struct ANativeWindow* /*window*/,
+                        struct ANativeWindowBuffer* /*buffer*/)
+{
+    return 0;
+}
+
 int cancelBuffer_static(struct ANativeWindow* /*window*/,
-                        struct ANativeWindowBuffer* /*buffer*/)
+                        struct ANativeWindowBuffer* /*buffer*/, int /*fence_fd*/)
 {
     return 0;
 }
 
 }
 
-mcla::MirNativeWindow::MirNativeWindow(ClientSurface* client_surface)
- : surface(client_surface),
-   driver_pixel_format(-1)
+mcla::MirNativeWindow::MirNativeWindow(std::shared_ptr<AndroidDriverInterpreter> const& interpreter)
+ : driver_interpreter(interpreter)
 {
     ANativeWindow::query = &query_static;
     ANativeWindow::perform = &perform_static;
     ANativeWindow::setSwapInterval = &setSwapInterval_static;
-    ANativeWindow::dequeueBuffer_DEPRECATED = &dequeueBuffer_static;
+    ANativeWindow::dequeueBuffer_DEPRECATED = &dequeueBuffer_deprecated_static;
+    ANativeWindow::dequeueBuffer = &dequeueBuffer_static;
     ANativeWindow::lockBuffer_DEPRECATED = &lockBuffer_static;
-    ANativeWindow::queueBuffer_DEPRECATED = &queueBuffer_static;
-    ANativeWindow::cancelBuffer_DEPRECATED = &cancelBuffer_static;
+    ANativeWindow::queueBuffer_DEPRECATED = &queueBuffer_deprecated_static;
+    ANativeWindow::queueBuffer = &queueBuffer_static;
+    ANativeWindow::cancelBuffer_DEPRECATED = &cancelBuffer_deprecated_static;
+    ANativeWindow::cancelBuffer = &cancelBuffer_static;
 
     ANativeWindow::common.incRef = &incRef;
     ANativeWindow::common.decRef = &incRef;
@@ -112,45 +142,20 @@
 
 int mcla::MirNativeWindow::dequeueBuffer (struct ANativeWindowBuffer** buffer_to_driver)
 {
-    int ret = 0;
-    auto buffer = surface->get_current_buffer();
-    *buffer_to_driver = buffer->get_native_handle();
-    (*buffer_to_driver)->format = driver_pixel_format;
-    return ret;
+    *buffer_to_driver = driver_interpreter->driver_requests_buffer();
+    return 0;
 }
 
-static void empty(MirSurface * /*surface*/, void * /*client_context*/)
-{}
-int mcla::MirNativeWindow::queueBuffer(struct ANativeWindowBuffer* /*buffer*/)
+int mcla::MirNativeWindow::queueBuffer(struct ANativeWindowBuffer* buffer, int fence_fd)
 {
-    mir_wait_for(surface->next_buffer(empty, NULL));
+    driver_interpreter->driver_returns_buffer(buffer, fence_fd);
     return 0;
 }
 
 int mcla::MirNativeWindow::query(int key, int* value ) const
 {
-    int ret = 0;
-    switch (key)
-    {
-        case NATIVE_WINDOW_WIDTH:
-        case NATIVE_WINDOW_DEFAULT_WIDTH:
-            *value = surface->get_parameters().width;
-            break;
-        case NATIVE_WINDOW_HEIGHT:
-        case NATIVE_WINDOW_DEFAULT_HEIGHT:
-            *value = surface->get_parameters().height;
-            break;
-        case NATIVE_WINDOW_FORMAT:
-            *value = driver_pixel_format;
-            break;
-        case NATIVE_WINDOW_TRANSFORM_HINT:
-            *value = 0; /* transform hint is a bitmask. 0 means no transform */
-            break;
-        default:
-            ret = -1;
-            break;
-    }
-    return ret;
+    *value = driver_interpreter->driver_requests_info(key);
+    return 0;
 }
 
 int mcla::MirNativeWindow::perform(int key, va_list arg_list )
@@ -159,10 +164,12 @@
     va_list args;
     va_copy(args, arg_list);
 
+    int driver_format;
     switch(key)
     {
         case NATIVE_WINDOW_SET_BUFFERS_FORMAT:
-            driver_pixel_format = va_arg(args, int);
+            driver_format = va_arg(args, int);
+            driver_interpreter->dispatch_driver_request_format(driver_format);
             break;
         default:
             break;

=== modified file 'src/client/android/mir_native_window.h'
--- src/client/android/mir_native_window.h	2013-03-07 08:04:05 +0000
+++ src/client/android/mir_native_window.h	2013-03-12 15:51:13 +0000
@@ -22,6 +22,7 @@
 #include "../mir_client_surface.h"
 #include <system/window.h>
 #include <cstdarg>
+#include <memory>
 
 namespace mir
 {
@@ -29,20 +30,20 @@
 {
 namespace android
 {
+class AndroidDriverInterpreter;
 
 class MirNativeWindow : public ANativeWindow
 {
 public:
-    explicit MirNativeWindow(ClientSurface* surface);
+    explicit MirNativeWindow(std::shared_ptr<AndroidDriverInterpreter> const& interpreter);
 
     int query(int key, int* value) const;
     int perform(int key, va_list args );
     int dequeueBuffer(struct ANativeWindowBuffer** buffer);
-    int queueBuffer(struct ANativeWindowBuffer* buffer);
+    int queueBuffer(struct ANativeWindowBuffer* buffer, int fence_fd);
 private:
 
-    ClientSurface * surface;
-    int driver_pixel_format;
+    std::shared_ptr<AndroidDriverInterpreter> const driver_interpreter;
 };
 
 }

=== modified file 'tests/unit-tests/client/CMakeLists.txt'
--- tests/unit-tests/client/CMakeLists.txt	2013-03-08 07:20:43 +0000
+++ tests/unit-tests/client/CMakeLists.txt	2013-03-12 15:51:13 +0000
@@ -13,6 +13,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_native_window.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_client_depository.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_client_platform.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_client_surface_interpreter.cpp
 )
 endif()
 

=== modified file 'tests/unit-tests/client/test_android_native_window.cpp'
--- tests/unit-tests/client/test_android_native_window.cpp	2013-03-07 08:04:05 +0000
+++ tests/unit-tests/client/test_android_native_window.cpp	2013-03-12 15:51:13 +0000
@@ -18,54 +18,22 @@
 
 #include "src/client/mir_client_surface.h"
 #include "src/client/android/mir_native_window.h"
-#include "src/client/client_buffer.h"
+#include "src/client/android/android_driver_interpreter.h"
+
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <memory>
-namespace mcl=mir::client;
 namespace mcla=mir::client::android;
-namespace geom=mir::geometry;
 
 namespace
 {
-struct MockClientBuffer : public mcl::ClientBuffer
-{
-    MockClientBuffer()
-    {
-        using namespace testing;
-        ON_CALL(*this, get_native_handle())
-            .WillByDefault(Return(&buffer));
-    }
-    MOCK_METHOD0(secure_for_cpu_write, std::shared_ptr<mcl::MemoryRegion>());
-    MOCK_CONST_METHOD0(size, geom::Size());
-    MOCK_CONST_METHOD0(stride, geom::Stride());
-    MOCK_CONST_METHOD0(pixel_format, geom::PixelFormat());
-
-    MOCK_CONST_METHOD0(get_buffer_package, std::shared_ptr<MirBufferPackage>());
-    MOCK_METHOD0(get_native_handle, ANativeWindowBuffer*());
-
-    ANativeWindowBuffer buffer;
-    native_handle_t handle;
-};
-
-struct MockMirSurface : public mcl::ClientSurface
-{
-    MockMirSurface(MirSurfaceParameters params)
-     : params(params)
-    {
-        using namespace testing;
-        ON_CALL(*this, get_parameters())
-            .WillByDefault(Return(params));
-        ON_CALL(*this, get_current_buffer())
-            .WillByDefault(Return(
-                std::make_shared<NiceMock<MockClientBuffer>>()));
-    }
-
-    MOCK_CONST_METHOD0(get_parameters, MirSurfaceParameters());
-    MOCK_METHOD0(get_current_buffer, std::shared_ptr<mcl::ClientBuffer>());
-    MOCK_METHOD2(next_buffer, MirWaitHandle*(mir_surface_lifecycle_callback callback, void * context));
-
-    MirSurfaceParameters params;
+class MockAndroidDriverInterpreter : public mcla::AndroidDriverInterpreter
+{
+public:
+    MOCK_METHOD0(driver_requests_buffer, ANativeWindowBuffer*());
+    MOCK_METHOD2(driver_returns_buffer, void(ANativeWindowBuffer*, int));
+    MOCK_METHOD1(dispatch_driver_request_format, void(int));
+    MOCK_CONST_METHOD1(driver_requests_info, int(int));
 };
 }
 
@@ -75,333 +43,215 @@
     virtual void SetUp()
     {
         using namespace testing;
-        surf_params.width = 530;
-        surf_params.height = 715;
-        surf_params.pixel_format = mir_pixel_format_abgr_8888;
 
-        mock_surface = std::make_shared<NiceMock<MockMirSurface>>(surf_params);
-        mock_client_buffer =
-            std::make_shared<NiceMock<MockClientBuffer>>();
+        mock_driver_interpreter = std::make_shared<NiceMock<MockAndroidDriverInterpreter>>();
     }
 
-    MirSurfaceParameters surf_params;
-    std::shared_ptr<MockMirSurface> mock_surface;
-    std::shared_ptr<MockClientBuffer> mock_client_buffer;
+    std::shared_ptr<MockAndroidDriverInterpreter> mock_driver_interpreter;
 };
 
 /* Query hook tests */
-TEST_F(AndroidNativeWindowTest, native_window_query_hook_callable)
-{
-    ANativeWindow* anw;
-    int value;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    ASSERT_NE(nullptr, anw->query);
-    EXPECT_NO_THROW({
-        anw->query(anw, NATIVE_WINDOW_WIDTH ,&value);
-    });
-
-
-    delete anw;
-}
-
-TEST_F(AndroidNativeWindowTest, native_window_width_query_hook)
-{
-    using namespace testing;
-    ANativeWindow* anw;
-    int value;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    EXPECT_CALL(*mock_surface, get_parameters())
-        .Times(1);
-
-    auto rc = anw->query(anw, NATIVE_WINDOW_WIDTH ,&value);
-
-    EXPECT_EQ(0, rc);
-    EXPECT_EQ(surf_params.width, value);
-
-    delete anw;
-}
-
-TEST_F(AndroidNativeWindowTest, native_window_height_query_hook)
-{
-    using namespace testing;
-    ANativeWindow* anw;
-    int value;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-    EXPECT_CALL(*mock_surface, get_parameters())
-        .Times(1);
-
-    auto rc = anw->query(anw, NATIVE_WINDOW_HEIGHT ,&value);
-
-    EXPECT_EQ(0, rc);
-    EXPECT_EQ(surf_params.height, value);
-
-    delete anw;
-}
-
-TEST_F(AndroidNativeWindowTest, native_window_hint_query_hook)
-{
-    using namespace testing;
-    ANativeWindow* anw;
-    /* transform hint is a bitmask of a few options for rotation/flipping buffer. a value
-       of zero is no transform */
-    int transform_hint_zero = 0;
-    int value;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    auto rc = anw->query(anw, NATIVE_WINDOW_TRANSFORM_HINT ,&value);
-
-    EXPECT_EQ(0, rc);
-    EXPECT_EQ(transform_hint_zero, value);
-
-    delete anw;
-}
-
-TEST_F(AndroidNativeWindowTest, native_window_default_width_query_hook)
-{
-    using namespace testing;
-    ANativeWindow* anw;
-    int value;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    auto rc = anw->query(anw, NATIVE_WINDOW_DEFAULT_WIDTH ,&value);
-
-    EXPECT_EQ(0, rc);
-    EXPECT_EQ(surf_params.width, value);
-
-    delete anw;
-}
-
-TEST_F(AndroidNativeWindowTest, native_window_default_height_query_hook)
-{
-    using namespace testing;
-    ANativeWindow* anw;
-    int value;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    auto rc = anw->query(anw, NATIVE_WINDOW_DEFAULT_HEIGHT ,&value);
-
-    EXPECT_EQ(0, rc);
-    EXPECT_EQ(surf_params.height, value);
-
-    delete anw;
+TEST_F(AndroidNativeWindowTest, native_window_query_hook)
+{
+    using namespace testing;
+
+    int returned_width, width = 271828;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    ASSERT_NE(nullptr, window->query);
+    EXPECT_CALL(*mock_driver_interpreter, driver_requests_info(NATIVE_WINDOW_WIDTH))
+        .Times(1)
+        .WillOnce(Return(width));
+
+    window->query(window.get(), NATIVE_WINDOW_WIDTH ,&returned_width);
+    
+    EXPECT_EQ(width, returned_width);
 }
 
 /* perform hook tests */
 TEST_F(AndroidNativeWindowTest, native_window_perform_hook_callable)
 {
-    ANativeWindow* anw;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    ASSERT_NE(nullptr, anw->perform);
-    EXPECT_NO_THROW({
-        anw->perform(anw, NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS , 40, 22);
-    });
-
-    delete anw;
-}
-
-/* format is an int that is set by the driver. these are not the HAL_PIXEL_FORMATS in android */
-TEST_F(AndroidNativeWindowTest, native_window_perform_remembers_format)
-{
-    ANativeWindow* anw;
-    int format = 945;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    anw->perform(anw, NATIVE_WINDOW_SET_BUFFERS_FORMAT , format);
-
-    int tmp_format = 0;
-    anw->query(anw, NATIVE_WINDOW_FORMAT, &tmp_format);
-
-    EXPECT_EQ(tmp_format, format);
-
-    delete anw;
+    int format = 4;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    EXPECT_CALL(*mock_driver_interpreter, dispatch_driver_request_format(format))
+        .Times(1);
+
+    ASSERT_NE(nullptr, window->perform);
+    window->perform(window.get(), NATIVE_WINDOW_SET_BUFFERS_FORMAT, format);
 }
 
 /* setSwapInterval hook tests */
 TEST_F(AndroidNativeWindowTest, native_window_setswapinterval_hook_callable)
 {
-    ANativeWindow* anw;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    ASSERT_NE(nullptr, anw->setSwapInterval);
-    EXPECT_NO_THROW({
-        anw->setSwapInterval(anw, 22);
-    });
-
-    delete anw;
+    int swap = 2;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    ASSERT_NE(nullptr, window->setSwapInterval);
+    window->setSwapInterval(window.get(), swap);
 }
 
 /* dequeue hook tests */
 TEST_F(AndroidNativeWindowTest, native_window_dequeue_hook_callable)
 {
-    ANativeWindow* anw;
-    ANativeWindowBuffer* tmp;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    ASSERT_NE(nullptr, anw->dequeueBuffer_DEPRECATED);
-    EXPECT_NO_THROW({
-        anw->dequeueBuffer_DEPRECATED(anw, &tmp);
-    });
-
-    delete anw;
-}
-
-TEST_F(AndroidNativeWindowTest, native_window_dequeue_calls_surface_get_current)
-{
-    using namespace testing;
-    ANativeWindow* anw;
-    ANativeWindowBuffer* tmp;
-
-    EXPECT_CALL(*mock_surface, get_current_buffer())
-        .Times(1)
-        .WillOnce(Return(mock_client_buffer));
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    anw->dequeueBuffer_DEPRECATED(anw, &tmp);
-
-    delete anw;
-}
-
-TEST_F(AndroidNativeWindowTest, native_window_dequeue_gets_native_handle_from_returned_buffer)
-{
-    using namespace testing;
-    ANativeWindow* anw;
-    native_handle_t handle;
-    ANativeWindowBuffer buffer;
-    buffer.handle = &handle;
-
-    ANativeWindowBuffer* tmp;
-
-    EXPECT_CALL(*mock_client_buffer, get_native_handle())
-        .Times(1)
-        .WillOnce(Return(&buffer));
-    EXPECT_CALL(*mock_surface, get_current_buffer())
-        .Times(1)
-        .WillOnce(Return(mock_client_buffer));
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    anw->dequeueBuffer_DEPRECATED(anw, &tmp);
-
-    EXPECT_EQ(tmp, &buffer);
-    delete anw;
-}
-
-TEST_F(AndroidNativeWindowTest, native_window_dequeue_has_proper_rc)
-{
-    using namespace testing;
-    ANativeWindow* anw;
-
-    ANativeWindowBuffer* tmp;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    auto ret = anw->dequeueBuffer_DEPRECATED(anw, &tmp);
-    EXPECT_EQ(0, ret);
-
-    delete anw;
+    ANativeWindowBuffer* returned_buffer; 
+    int fence_fd;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    ASSERT_NE(nullptr, window->dequeueBuffer);
+    window->dequeueBuffer(window.get(), &returned_buffer, &fence_fd);
+}
+
+TEST_F(AndroidNativeWindowTest, native_window_dequeue_returns_right_buffer)
+{
+    using namespace testing;
+
+    ANativeWindowBuffer* returned_buffer; 
+    ANativeWindowBuffer fake_buffer;
+    int fence_fd;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    EXPECT_CALL(*mock_driver_interpreter, driver_requests_buffer())
+        .Times(1)
+        .WillOnce(Return(&fake_buffer));
+
+    window->dequeueBuffer(window.get(), &returned_buffer, &fence_fd);
+
+    EXPECT_EQ(&fake_buffer, returned_buffer);
+}
+
+
+TEST_F(AndroidNativeWindowTest, native_window_dequeue_indicates_buffer_immediately_usable)
+{
+    ANativeWindowBuffer* returned_buffer; 
+    int fence_fd;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    window->dequeueBuffer(window.get(), &returned_buffer, &fence_fd);
+    EXPECT_EQ(-1, fence_fd);
+}
+
+TEST_F(AndroidNativeWindowTest, native_window_dequeue_deprecated_hook_callable)
+{
+    ANativeWindowBuffer* tmp;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    ASSERT_NE(nullptr, window->dequeueBuffer_DEPRECATED);
+    window->dequeueBuffer_DEPRECATED(window.get(), &tmp);
+}
+
+TEST_F(AndroidNativeWindowTest, native_window_dequeue_deprecated_returns_right_buffer)
+{
+    using namespace testing;
+
+    ANativeWindowBuffer* returned_buffer; 
+    ANativeWindowBuffer fake_buffer;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    EXPECT_CALL(*mock_driver_interpreter, driver_requests_buffer())
+        .Times(1)
+        .WillOnce(Return(&fake_buffer));
+
+    window->dequeueBuffer_DEPRECATED(window.get(), &returned_buffer);
+    EXPECT_EQ(&fake_buffer, returned_buffer);
 }
 
 /* queue hook tests */
 TEST_F(AndroidNativeWindowTest, native_window_queue_hook_callable)
 {
-    ANativeWindow* anw;
-    ANativeWindowBuffer* tmp = 0x0;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    ASSERT_NE(nullptr, anw->queueBuffer_DEPRECATED);
-    EXPECT_NO_THROW({
-        anw->queueBuffer_DEPRECATED(anw, tmp);
-    });
-
-    delete anw;
-}
-
-TEST_F(AndroidNativeWindowTest, native_window_queue_advances_buffer)
-{
-    using namespace testing;
-    ANativeWindow* anw;
-    ANativeWindowBuffer* tmp = 0x0;
-
-    EXPECT_CALL(*mock_surface, next_buffer(_,_))
-        .Times(1);
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    anw->queueBuffer_DEPRECATED(anw, tmp);
-
-    delete anw;
+    ANativeWindowBuffer* tmp = nullptr;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    ASSERT_NE(nullptr, window->queueBuffer);
+    window->queueBuffer(window.get(), tmp, -1);
+}
+
+TEST_F(AndroidNativeWindowTest, native_window_queue_passes_buffer_and_fence_back)
+{
+    ANativeWindowBuffer buffer;
+    int fence_fd = 33;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    EXPECT_CALL(*mock_driver_interpreter, driver_returns_buffer(&buffer, fence_fd))
+        .Times(1);
+
+    window->queueBuffer(window.get(), &buffer, fence_fd);
+}
+
+TEST_F(AndroidNativeWindowTest, native_window_queue_deprecated_hook_callable)
+{
+    ANativeWindowBuffer* tmp = nullptr;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    ASSERT_NE(nullptr, window->queueBuffer_DEPRECATED);
+    window->queueBuffer_DEPRECATED(window.get(), tmp);
+}
+
+TEST_F(AndroidNativeWindowTest, native_window_queue_deprecated_always_indicates_no_wait)
+{
+    ANativeWindowBuffer buffer;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    EXPECT_CALL(*mock_driver_interpreter, driver_returns_buffer(&buffer, -1))
+        .Times(1);
+
+    window->queueBuffer_DEPRECATED(window.get(), &buffer);
 }
 
 /* cancel hook tests */
-TEST_F(AndroidNativeWindowTest, native_window_cancel_hook_callable)
+TEST_F(AndroidNativeWindowTest, native_window_cancel_hooks_callable)
 {
-    ANativeWindow* anw;
-    ANativeWindowBuffer* tmp = 0x0;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    ASSERT_NE(nullptr, anw->cancelBuffer_DEPRECATED);
-    EXPECT_NO_THROW({
-        anw->cancelBuffer_DEPRECATED(anw, tmp);
-    });
-
-    delete anw;
+    ANativeWindowBuffer* tmp = nullptr;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    ASSERT_NE(nullptr, window->cancelBuffer_DEPRECATED);
+    ASSERT_NE(nullptr, window->cancelBuffer);
+    window->cancelBuffer_DEPRECATED(window.get(), tmp);
+    window->cancelBuffer(window.get(), tmp, -1);
 }
 
 /* lock hook tests */
 TEST_F(AndroidNativeWindowTest, native_window_lock_hook_callable)
 {
-    ANativeWindow* anw;
     ANativeWindowBuffer* tmp = 0x0;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    ASSERT_NE(nullptr, anw->lockBuffer_DEPRECATED);
-    EXPECT_NO_THROW({
-        anw->lockBuffer_DEPRECATED(anw, tmp);
-    });
-
-    delete anw;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    ASSERT_NE(nullptr, window->lockBuffer_DEPRECATED);
+    window->lockBuffer_DEPRECATED(window.get(), tmp);
 }
-/* incRef is reffable */
+
 TEST_F(AndroidNativeWindowTest, native_window_incref_hook_callable)
 {
-    ANativeWindow* anw;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    ASSERT_NE(nullptr, anw->common.incRef);
-    EXPECT_NO_THROW({
-        anw->common.incRef(NULL);
-    });
-
-    delete anw;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    ASSERT_NE(nullptr, window->common.incRef);
+    window->common.incRef(NULL);
 }
 
-/* decRef is reffable */
 TEST_F(AndroidNativeWindowTest, native_window_decref_hook_callable)
 {
-    ANativeWindow* anw;
-
-    anw = new mcla::MirNativeWindow(mock_surface.get());
-
-    ASSERT_NE(nullptr, anw->common.decRef);
-    EXPECT_NO_THROW({
-        anw->common.decRef(NULL);
-    });
-
-    delete anw;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    ASSERT_NE(nullptr, window->common.decRef);
+    window->common.decRef(NULL);
+}
+
+TEST_F(AndroidNativeWindowTest, native_window_dequeue_deprecated_has_proper_rc)
+{
+    ANativeWindowBuffer* tmp;
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    auto ret = window->dequeueBuffer_DEPRECATED(window.get(), &tmp);
+    EXPECT_EQ(0, ret);
+}
+
+TEST_F(AndroidNativeWindowTest, native_window_dequeue_has_proper_rc)
+{
+    ANativeWindowBuffer* tmp;
+    int fencefd;
+
+    std::shared_ptr<ANativeWindow> window = std::make_shared<mcla::MirNativeWindow>(mock_driver_interpreter);
+
+    auto ret = window->dequeueBuffer(window.get(), &tmp, &fencefd);
+    EXPECT_EQ(0, ret);
 }

=== added file 'tests/unit-tests/client/test_client_surface_interpreter.cpp'
--- tests/unit-tests/client/test_client_surface_interpreter.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/client/test_client_surface_interpreter.cpp	2013-03-12 15:51:13 +0000
@@ -0,0 +1,202 @@
+/*
+ * Copyright © 2013 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/client/mir_client_surface.h"
+#include "src/client/client_buffer.h"
+#include "src/client/android/client_surface_interpreter.h"
+#include <system/window.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+namespace mcl=mir::client;
+namespace mcla=mir::client::android;
+namespace geom=mir::geometry;
+
+namespace
+{
+struct MockClientBuffer : public mcl::ClientBuffer
+{
+    MockClientBuffer()
+    {
+        using namespace testing;
+        ON_CALL(*this, get_native_handle())
+            .WillByDefault(Return(&buffer));
+    }
+    MOCK_METHOD0(secure_for_cpu_write, std::shared_ptr<mcl::MemoryRegion>());
+    MOCK_CONST_METHOD0(size, geom::Size());
+    MOCK_CONST_METHOD0(stride, geom::Stride());
+    MOCK_CONST_METHOD0(pixel_format, geom::PixelFormat());
+
+    MOCK_CONST_METHOD0(get_buffer_package, std::shared_ptr<MirBufferPackage>());
+    MOCK_METHOD0(get_native_handle, ANativeWindowBuffer*());
+
+    ANativeWindowBuffer buffer;
+    native_handle_t handle;
+};
+
+struct MockMirSurface : public mcl::ClientSurface
+{
+    MockMirSurface(MirSurfaceParameters params)
+     : params(params)
+    {
+        using namespace testing;
+        ON_CALL(*this, get_parameters())
+            .WillByDefault(Return(params));
+        ON_CALL(*this, get_current_buffer())
+            .WillByDefault(Return(
+                std::make_shared<NiceMock<MockClientBuffer>>()));
+    }
+
+    MOCK_CONST_METHOD0(get_parameters, MirSurfaceParameters());
+    MOCK_METHOD0(get_current_buffer, std::shared_ptr<mcl::ClientBuffer>());
+    MOCK_METHOD2(next_buffer, MirWaitHandle*(mir_surface_lifecycle_callback callback, void * context));
+
+    MirSurfaceParameters params;
+};
+}
+
+class AndroidInterpreterTest : public ::testing::Test
+{
+protected:
+    virtual void SetUp()
+    {
+        using namespace testing;
+        surf_params.width = 530;
+        surf_params.height = 715;
+        surf_params.pixel_format = mir_pixel_format_abgr_8888;
+
+        mock_client_buffer = std::make_shared<NiceMock<MockClientBuffer>>();
+    }
+
+    MirSurfaceParameters surf_params;
+    std::shared_ptr<MockClientBuffer> mock_client_buffer;
+};
+
+TEST_F(AndroidInterpreterTest, native_window_dequeue_calls_surface_get_current)
+{
+    using namespace testing;
+    MockMirSurface mock_surface{surf_params};
+    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
+
+    EXPECT_CALL(mock_surface, get_current_buffer())
+        .Times(1)
+        .WillOnce(Return(mock_client_buffer));
+
+    interpreter.driver_requests_buffer();
+}
+
+TEST_F(AndroidInterpreterTest, native_window_dequeue_gets_native_handle_from_returned_buffer)
+{
+    using namespace testing;
+    native_handle_t handle;
+    ANativeWindowBuffer buffer;
+    buffer.handle = &handle;
+
+    MockMirSurface mock_surface{surf_params};
+    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
+
+    EXPECT_CALL(*mock_client_buffer, get_native_handle())
+        .Times(1)
+        .WillOnce(Return(&buffer));
+    EXPECT_CALL(mock_surface, get_current_buffer())
+        .Times(1)
+        .WillOnce(Return(mock_client_buffer));
+
+    auto returned_buffer = interpreter.driver_requests_buffer();
+    EXPECT_EQ(&buffer, returned_buffer);
+}
+
+TEST_F(AndroidInterpreterTest, native_window_queue_advances_buffer)
+{
+    using namespace testing;
+    ANativeWindowBuffer buffer;
+    int fence_fd = -1;
+
+    MockMirSurface mock_surface{surf_params};
+    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
+
+    EXPECT_CALL(mock_surface, next_buffer(_,_))
+        .Times(1);
+
+    interpreter.driver_returns_buffer(&buffer, fence_fd);
+}
+
+/* format is an int that is set by the driver. these are not the HAL_PIXEL_FORMATS in android */
+TEST_F(AndroidInterpreterTest, native_window_perform_remembers_format)
+{
+    int format = 945;
+    MockMirSurface mock_surface{surf_params};
+    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
+
+    interpreter.dispatch_driver_request_format(format);
+    auto tmp_format = interpreter.driver_requests_info(NATIVE_WINDOW_FORMAT);
+
+    EXPECT_EQ(format, tmp_format);
+}
+
+TEST_F(AndroidInterpreterTest, native_window_hint_query_hook)
+{
+    MockMirSurface mock_surface{surf_params};
+    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
+    /* transform hint is a bitmask of a few options for rotation/flipping buffer. a value
+       of zero is no transform */
+    int transform_hint_zero = 0;
+    auto transform = interpreter.driver_requests_info(NATIVE_WINDOW_TRANSFORM_HINT);
+
+    EXPECT_EQ(transform_hint_zero, transform);
+}
+
+TEST_F(AndroidInterpreterTest, native_window_default_width_query_hook)
+{
+    MockMirSurface mock_surface{surf_params};
+    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
+
+    auto default_width = interpreter.driver_requests_info(NATIVE_WINDOW_DEFAULT_WIDTH);
+
+    EXPECT_EQ(surf_params.width, default_width);
+}
+
+TEST_F(AndroidInterpreterTest, native_window_default_height_query_hook)
+{
+    MockMirSurface mock_surface{surf_params};
+    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
+
+    auto default_height = interpreter.driver_requests_info(NATIVE_WINDOW_DEFAULT_HEIGHT);
+
+    EXPECT_EQ(surf_params.height, default_height);
+}
+
+TEST_F(AndroidInterpreterTest, native_window_width_query_hook)
+{
+    MockMirSurface mock_surface{surf_params};
+    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
+
+    auto width = interpreter.driver_requests_info(NATIVE_WINDOW_WIDTH);
+
+    EXPECT_EQ(surf_params.width, width);
+}
+
+TEST_F(AndroidInterpreterTest, native_window_height_query_hook)
+{
+    MockMirSurface mock_surface{surf_params};
+    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
+
+    auto height = interpreter.driver_requests_info(NATIVE_WINDOW_HEIGHT);
+
+    EXPECT_EQ(surf_params.height, height);
+}