Merge lp:~kdub/mir/android-internal-client into lp:~mir-team/mir/trunk

[Kevin DuBois]

enable internal clients (in-process-egl) for android. refactor platform abstraction for internal clients as well.

tested on my laptop (intel drivers), galaxy nexus, nexus4

fixes: lp:1173191

enable internal clients (in-process-egl) for android. refactor platform abstraction for internal clients as well.

tested on my laptop (intel drivers), galaxy nexus, nexus4

fixes: lp:1173191

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:711
http://jenkins.qa.ubuntu.com/job/mir-ci/567/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/662
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/545/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/51
        deb: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/51/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=precise,flavor=amd64/301

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:712
http://jenkins.qa.ubuntu.com/job/mir-ci/568/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/663
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/546
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/52
        deb: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/52/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=precise,flavor=amd64/302

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

review: Approve (continuous-integration)

[Robert Ancell (robert-ancell)]

I didn't review in depth, but at a high level looks good to me.

review: Approve

[Kevin DuBois (kdub)]

Here are some places to zone in:

l70: the in-process client registers sigint/sigterm handlers to stop the render loop. this is what fixes one of the bugs I noticed in this branch.

l86/87: mg::InternalClient is the current way that the platform constructs an internal (in-process-egl) client. It is constructed in mg::Platform via an mf::Surface. I'd expect mg::InternalClient to expand in the future (say, so the internal clients can get at size/pixelformat/etc info about the surface they were granted). A full example is in the integration test in line 1546.

I rolled src/graphics/egl into src/graphics/gbm like I was talking about at the sprint. This involved a bit of refactoring of ShellMesaEGLNativeDisplay, which is now called mgg::InternalNativeDisplay. what used to be in src/graphics/egl is really just gbm-specific code for a different sort of EGLNativeWindowType, (very analagous to mga::ServerRenderWindow and mga::InternalClientWindow) so it should be in the gbm directory.

[Kevin DuBois (kdub)]

furthermore, I added some comments in a bug that exists in current lp:mir (https://bugs.launchpad.net/mir/+bug/1177902) which is a namespace collision in our .so's for the symbol mir_egl_mesa_display_is_valid. The workaround in lines 1105-1114 can be removed with some coordination with changing the mir platform in mesa

[Alan Griffiths (alan-griffiths)]

I'm not clear on some of the semantics - e.g. what does this do and why does it need a surface:

266 + virtual std::shared_ptr<InternalClient> create_internal_client(std::shared_ptr<frontend::Surface> const&) = 0;

But it seems to work without anything that leaps out as ugly.

review: Approve

[Kevin DuBois (kdub)]

> I'm not clear on some of the semantics - e.g. what does this do and why does
> it need a surface:
>
> 266 + virtual std::shared_ptr<InternalClient>
> create_internal_client(std::shared_ptr<frontend::Surface> const&) = 0;
>
> But it seems to work without anything that leaps out as ugly.

the drivers need to understand our surfaces to use them internally. With mesa/gbm platform, we can just use the mf::Surface interface directly, because we control those drivers. With Android, we wrap the mf::Surface interface in an interface that driver can understand, and then give that out to our clients. essentially, what the user of this function gets back is a platform-friendly representation of the mf::Surface that they can plug into their egl driver

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/mir-autolanding/253/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/674/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/557
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-autolanding/43
        deb: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-autolanding/43/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-autolanding-build/./distribution=quantal,flavor=amd64/141

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'examples/CMakeLists.txt'
--- examples/CMakeLists.txt	2013-05-01 00:58:45 +0000
+++ examples/CMakeLists.txt	2013-05-09 21:03:25 +0000
@@ -120,10 +120,7 @@
   mir_eglplasma
 )
 
-if (MIR_PLATFORM STREQUAL "gbm")
-  add_subdirectory(demo-inprocess-egl)
-endif()
-
+add_subdirectory(demo-inprocess-egl)
 add_subdirectory(demo-shell)
 
 install(TARGETS ${DEMO_CLIENTS} RUNTIME DESTINATION bin)

=== modified file 'examples/demo-inprocess-egl/demo_inprocess_egl.cpp'
--- examples/demo-inprocess-egl/demo_inprocess_egl.cpp	2013-05-02 00:11:18 +0000
+++ examples/demo-inprocess-egl/demo_inprocess_egl.cpp	2013-05-09 21:03:25 +0000
@@ -46,6 +46,7 @@
     mir::run_mir(config, [&config, &client](mir::DisplayServer&)
     {
         client = std::make_shared<me::InprocessEGLClient>(
+              config.the_main_loop(),
               config.the_graphics_platform(),
               config.the_shell_surface_factory());
     });

=== modified file 'examples/demo-inprocess-egl/inprocess_egl_client.cpp'
--- examples/demo-inprocess-egl/inprocess_egl_client.cpp	2013-05-02 00:11:18 +0000
+++ examples/demo-inprocess-egl/inprocess_egl_client.cpp	2013-05-09 21:03:25 +0000
@@ -19,12 +19,14 @@
 #include "inprocess_egl_client.h"
 #include "example_egl_helper.h"
 
+#include "mir/main_loop.h"
 #include "mir/shell/surface_factory.h"
 #include "mir/shell/surface.h"
 #include "mir/frontend/surface_creation_parameters.h"
 #include "mir/geometry/size.h"
 #include "mir/compositor/buffer_properties.h"
 #include "mir/graphics/platform.h"
+#include "mir/graphics/internal_client.h"
 
 #include "graphics.h"
 
@@ -33,6 +35,8 @@
 #include <functional>
 
 #include <assert.h>
+#include <signal.h>
+
 
 namespace mf = mir::frontend;
 namespace mc = mir::compositor;
@@ -41,12 +45,20 @@
 namespace me = mir::examples;
 namespace geom = mir::geometry;
 
-me::InprocessEGLClient::InprocessEGLClient(std::shared_ptr<mg::Platform> const& graphics_platform,
+me::InprocessEGLClient::InprocessEGLClient(std::shared_ptr<mir::MainLoop> const& main_loop,
+                                           std::shared_ptr<mg::Platform> const& graphics_platform,
                                            std::shared_ptr<msh::SurfaceFactory> const& surface_factory)
   : graphics_platform(graphics_platform),
     surface_factory(surface_factory),
-    client_thread(std::mem_fn(&InprocessEGLClient::thread_loop), this)
+    client_thread(std::mem_fn(&InprocessEGLClient::thread_loop), this),
+    terminate(false)
 {
+    main_loop->register_signal_handler({SIGTERM, SIGINT},
+        [this](int)
+        {
+            terminate = true;
+        }
+    );
     client_thread.detach();
 }
 
@@ -61,9 +73,8 @@
         .of_buffer_usage(mc::BufferUsage::hardware)
         .of_pixel_format(geom::PixelFormat::argb_8888);
     auto surface = surface_factory->create_surface(params, mf::SurfaceId(), std::shared_ptr<events::EventSink>());
-
-    auto native_display = graphics_platform->shell_egl_display();
-    me::EGLHelper helper(reinterpret_cast<EGLNativeDisplayType>(native_display), reinterpret_cast<EGLNativeWindowType>(surface.get()));
+    auto internal_client = graphics_platform->create_internal_client(surface);
+    me::EGLHelper helper(internal_client->egl_native_display(), internal_client->egl_native_window());
 
     auto rc = eglMakeCurrent(helper.the_display(), helper.the_surface(), helper.the_surface(), helper.the_context());
     assert(rc == EGL_TRUE);
@@ -73,7 +84,7 @@
     ///\internal [setup_tag]
 
     ///\internal [loop_tag]
-    for(;;)
+    while(!terminate)
     {
         gl_animation.render_gl();
         rc = eglSwapBuffers(helper.the_display(), helper.the_surface());

=== modified file 'examples/demo-inprocess-egl/inprocess_egl_client.h'
--- examples/demo-inprocess-egl/inprocess_egl_client.h	2013-04-01 16:45:07 +0000
+++ examples/demo-inprocess-egl/inprocess_egl_client.h	2013-05-09 21:03:25 +0000
@@ -24,6 +24,7 @@
 
 namespace mir
 {
+class MainLoop;
 namespace graphics
 {
 class Platform;
@@ -40,7 +41,8 @@
 class InprocessEGLClient
 {
 public:
-    InprocessEGLClient(std::shared_ptr<graphics::Platform> const& graphics_platform,
+    InprocessEGLClient(std::shared_ptr<mir::MainLoop> const& main_loop,
+                       std::shared_ptr<graphics::Platform> const& graphics_platform,
                        std::shared_ptr<shell::SurfaceFactory> const& surface_factory);
 
 protected:
@@ -50,9 +52,10 @@
 private:
     std::shared_ptr<graphics::Platform> const graphics_platform;
     std::shared_ptr<shell::SurfaceFactory> const surface_factory;
-    
+
     std::thread client_thread;
     void thread_loop();
+    bool terminate;
 };
 
 }

=== removed directory 'include/server/mir/graphics/egl'
=== removed file 'include/server/mir/graphics/egl/mesa_native_display.h'
--- include/server/mir/graphics/egl/mesa_native_display.h	2013-04-24 05:22:20 +0000
+++ include/server/mir/graphics/egl/mesa_native_display.h	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-/*
- * 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: Robert Carr <[e-mail]>
- */
-
-#ifndef MIR_GRAPHICS_EGL_NATIVE_DISPLAY_H_
-#define MIR_GRAPHICS_EGL_NATIVE_DISPLAY_H_
-
-#include "mir_toolkit/mesa/native_display.h"
-
-#include <memory>
-
-namespace mir
-{
-namespace graphics
-{
-class Platform;
-
-namespace egl
-{
-namespace mesa
-{
-std::shared_ptr<MirMesaEGLNativeDisplay> create_native_display(std::shared_ptr<Platform> const& platform);
-}
-}
-}
-} // namespace mir
-
-#endif // MIR_GRAPHICS_EGL_NATIVE_DISPLAY_H_

=== added file 'include/server/mir/graphics/internal_client.h'
--- include/server/mir/graphics/internal_client.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/graphics/internal_client.h	2013-05-09 21:03:25 +0000
@@ -0,0 +1,43 @@
+/*
+ * 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]>
+ */
+
+
+#ifndef MIR_GRAPHICS_INTERNAL_CLIENT_H_
+#define MIR_GRAPHICS_INTERNAL_CLIENT_H_
+
+#include <EGL/egl.h>
+
+namespace mir
+{
+namespace graphics
+{
+class InternalClient
+{
+public:
+    virtual EGLNativeDisplayType egl_native_display() = 0;
+    virtual EGLNativeWindowType egl_native_window() = 0;
+protected:
+    InternalClient() = default;
+    virtual ~InternalClient() = default;
+    InternalClient(InternalClient const&) = delete;
+    InternalClient& operator=(InternalClient const&) = delete;
+};
+}
+}
+
+#endif /* MIR_GRAPHICS_INTERNAL_CLIENT_H_ */

=== modified file 'include/server/mir/graphics/platform.h'
--- include/server/mir/graphics/platform.h	2013-04-24 05:22:20 +0000
+++ include/server/mir/graphics/platform.h	2013-05-09 21:03:25 +0000
@@ -20,12 +20,14 @@
 #ifndef MIR_GRAPHICS_PLATFORM_H_
 #define MIR_GRAPHICS_PLATFORM_H_
 
-#include <EGL/egl.h>
-
 #include <memory>
 
 namespace mir
 {
+namespace frontend
+{
+class Surface;
+}
 namespace compositor
 {
 class GraphicBufferAllocator;
@@ -39,7 +41,7 @@
 class Display;
 struct PlatformIPCPackage;
 class BufferInitializer;
-
+class InternalClient;
 class DisplayReport;
 
 /// Interface to platform specific support for graphics operations.
@@ -54,8 +56,7 @@
         std::shared_ptr<BufferInitializer> const& buffer_initializer) = 0;
     virtual std::shared_ptr<Display> create_display() = 0;
     virtual std::shared_ptr<PlatformIPCPackage> get_ipc_package() = 0;
-    
-    virtual EGLNativeDisplayType shell_egl_display() = 0;
+    virtual std::shared_ptr<InternalClient> create_internal_client(std::shared_ptr<frontend::Surface> const&) = 0;
 };
 
 // Create and return a new graphics platform.

=== modified file 'include/shared/mir_toolkit/mesa/native_display.h'
--- include/shared/mir_toolkit/mesa/native_display.h	2013-05-03 22:53:42 +0000
+++ include/shared/mir_toolkit/mesa/native_display.h	2013-05-09 21:03:25 +0000
@@ -48,7 +48,16 @@
     void *context;
 };
 
+typedef enum mir_display_type
+{
+    MIR_DISPLAY_TYPE_CLIENT,
+    MIR_DISPLAY_TYPE_SERVER_INTERNAL
+} mir_display_type;
+
+mir_display_type mir_get_display_type(MirMesaEGLNativeDisplay* display);
+
 int mir_egl_mesa_display_is_valid(MirMesaEGLNativeDisplay* display);
+int mir_server_internal_display_is_valid(MirMesaEGLNativeDisplay* display);
 
 #ifdef __cplusplus
 } // extern "C"

=== added file 'include/test/mir_test_doubles/mock_interpreter_resource_cache.h'
--- include/test/mir_test_doubles/mock_interpreter_resource_cache.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_interpreter_resource_cache.h	2013-05-09 21:03:25 +0000
@@ -0,0 +1,37 @@
+/*
+ * 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]>
+ */
+#ifndef MIR_TEST_DOUBLES_MOCK_INTERPRETER_RESOURCE_CACHE_H_
+#define MIR_TEST_DOUBLES_MOCK_INTERPRETER_RESOURCE_CACHE_H_
+
+#include "src/server/graphics/android/interpreter_resource_cache.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+struct MockInterpreterResourceCache : public graphics::android::InterpreterResourceCache
+{
+    MOCK_METHOD2(store_buffer, void(std::shared_ptr<compositor::Buffer>const&, ANativeWindowBuffer*));
+    MOCK_METHOD1(retrieve_buffer, std::shared_ptr<compositor::Buffer>(ANativeWindowBuffer*));
+};
+}
+}
+}
+#endif /* MIR_TEST_DOUBLES_MOCK_INTERPRETER_RESOURCE_CACHE_H_ */

=== modified file 'include/test/mir_test_doubles/mock_swapper.h'
--- include/test/mir_test_doubles/mock_swapper.h	2013-05-02 16:29:48 +0000
+++ include/test/mir_test_doubles/mock_swapper.h	2013-05-09 21:03:25 +0000
@@ -32,6 +32,7 @@
 struct MockSwapper : public compositor::BufferSwapper
 {
 public:
+    MockSwapper() {}
     MockSwapper(std::shared_ptr<compositor::Buffer> buffer)
         : default_buffer(buffer)
     {

=== added file 'include/test/mir_test_doubles/stub_platform.h'
--- include/test/mir_test_doubles/stub_platform.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_platform.h	2013-05-09 21:03:25 +0000
@@ -0,0 +1,60 @@
+/*
+ * 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]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_PLATFORM_H_
+#define MIR_TEST_DOUBLES_STUB_PLATFORM_H_
+
+#include "mir/graphics/platform.h"
+#include "mir/graphics/platform_ipc_package.h"
+#include "null_display.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+class StubPlatform : public graphics::Platform
+{
+ public:
+    std::shared_ptr<compositor::GraphicBufferAllocator> create_buffer_allocator(
+            const std::shared_ptr<graphics::BufferInitializer>& /*buffer_initializer*/)
+    {
+        return std::shared_ptr<compositor::GraphicBufferAllocator>();
+    }
+
+    std::shared_ptr<graphics::Display> create_display()
+    {
+        return std::make_shared<NullDisplay>();
+    }
+
+    std::shared_ptr<graphics::PlatformIPCPackage> get_ipc_package()
+    {
+        return std::make_shared<graphics::PlatformIPCPackage>();
+    }
+ 
+    std::shared_ptr<graphics::InternalClient> create_internal_client(std::shared_ptr<frontend::Surface> const&)
+    {
+        return std::shared_ptr<graphics::InternalClient>();   
+    } 
+};
+}
+}
+} // namespace mir
+
+#endif // MIR_TEST_DOUBLES_STUB_INPUT_LISTENER_H_

=== modified file 'src/server/graphics/CMakeLists.txt'
--- src/server/graphics/CMakeLists.txt	2013-04-24 05:22:20 +0000
+++ src/server/graphics/CMakeLists.txt	2013-05-09 21:03:25 +0000
@@ -19,10 +19,6 @@
   null_display_report.cpp
 )
 
-if (MIR_PLATFORM STREQUAL "gbm")
-  add_subdirectory(egl/)
-endif()
-
 add_library(
   mirgraphics STATIC
 

=== modified file 'src/server/graphics/android/CMakeLists.txt'
--- src/server/graphics/android/CMakeLists.txt	2013-05-02 16:29:48 +0000
+++ src/server/graphics/android/CMakeLists.txt	2013-05-09 21:03:25 +0000
@@ -26,6 +26,9 @@
   default_framebuffer_factory.cpp
   fb_simple_swapper.cpp
   fb_device.cpp
+  internal_client_window.cpp
+  interpreter_cache.cpp
+  internal_client.cpp
 )
 
 target_link_libraries(

=== modified file 'src/server/graphics/android/android_platform.cpp'
--- src/server/graphics/android/android_platform.cpp	2013-04-26 00:00:27 +0000
+++ src/server/graphics/android/android_platform.cpp	2013-05-09 21:03:25 +0000
@@ -23,6 +23,7 @@
 #include "android_display_allocator.h"
 #include "android_display_factory.h"
 #include "default_framebuffer_factory.h"
+#include "internal_client.h"
 #include "mir/graphics/platform_ipc_package.h"
 #include "mir/graphics/buffer_initializer.h"
 #include "mir/compositor/buffer_id.h"
@@ -30,6 +31,7 @@
 namespace mg=mir::graphics;
 namespace mga=mir::graphics::android;
 namespace mc=mir::compositor;
+namespace mf=mir::frontend;
 
 mga::AndroidPlatform::AndroidPlatform(std::shared_ptr<mg::DisplayReport> const& display_report)
     : display_report(display_report)
@@ -59,10 +61,10 @@
     return std::make_shared<mg::PlatformIPCPackage>();
 }
 
-EGLNativeDisplayType mga::AndroidPlatform::shell_egl_display()
+std::shared_ptr<mg::InternalClient> mga::AndroidPlatform::create_internal_client(
+    std::shared_ptr<mf::Surface> const& surface)
 {
-    // TODO: Implement
-    return static_cast<EGLNativeDisplayType>(0);
+    return std::make_shared<mga::InternalClient>(surface);
 }
 
 std::shared_ptr<mg::Platform> mg::create_platform(std::shared_ptr<DisplayReport> const& display_report)

=== modified file 'src/server/graphics/android/android_platform.h'
--- src/server/graphics/android/android_platform.h	2013-04-26 00:00:27 +0000
+++ src/server/graphics/android/android_platform.h	2013-05-09 21:03:25 +0000
@@ -38,9 +38,8 @@
     std::shared_ptr<compositor::GraphicBufferAllocator> create_buffer_allocator(
             const std::shared_ptr<BufferInitializer>& buffer_initializer);
     std::shared_ptr<Display> create_display();
-    std::shared_ptr<PlatformIPCPackage> get_ipc_package();
-    
-    EGLNativeDisplayType shell_egl_display();
+    std::shared_ptr<PlatformIPCPackage> get_ipc_package(); 
+    std::shared_ptr<InternalClient> create_internal_client(std::shared_ptr<frontend::Surface> const&);
 
 private:
     std::shared_ptr<DisplayReport> const display_report;

=== modified file 'src/server/graphics/android/default_framebuffer_factory.cpp'
--- src/server/graphics/android/default_framebuffer_factory.cpp	2013-05-06 17:11:28 +0000
+++ src/server/graphics/android/default_framebuffer_factory.cpp	2013-05-09 21:03:25 +0000
@@ -24,6 +24,7 @@
 #include "fb_simple_swapper.h"
 #include "graphic_buffer_allocator.h"
 #include "server_render_window.h"
+#include "interpreter_cache.h"
 
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
@@ -51,7 +52,8 @@
     }
 
     auto swapper = std::make_shared<mga::FBSimpleSwapper>(buffers);
-    auto interpreter = std::make_shared<mga::ServerRenderWindow>(swapper, info_provider);
+    auto cache = std::make_shared<mga::InterpreterCache>();
+    auto interpreter = std::make_shared<mga::ServerRenderWindow>(swapper, info_provider, cache);
     return std::make_shared<mga::MirNativeWindow>(interpreter); 
 }
 

=== added file 'src/server/graphics/android/internal_client.cpp'
--- src/server/graphics/android/internal_client.cpp	1970-01-01 00:00:00 +0000
+++ src/server/graphics/android/internal_client.cpp	2013-05-09 21:03:25 +0000
@@ -0,0 +1,42 @@
+/*
+ * 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 "internal_client.h"
+#include "interpreter_cache.h"
+#include "internal_client_window.h"
+#include "mir/graphics/android/mir_native_window.h"
+
+namespace mf=mir::frontend;
+namespace mga=mir::graphics::android;
+
+mga::InternalClient::InternalClient(std::shared_ptr<frontend::Surface> const& surface)
+{
+    auto cache = std::make_shared<mga::InterpreterCache>();
+    auto interpreter = std::make_shared<mga::InternalClientWindow>(surface, cache); 
+    client_window = std::make_shared<mga::MirNativeWindow>(interpreter);
+}
+
+EGLNativeDisplayType mga::InternalClient::egl_native_display()
+{
+    return EGL_DEFAULT_DISPLAY;
+}
+
+EGLNativeWindowType mga::InternalClient::egl_native_window()
+{
+    return client_window.get();
+}

=== added file 'src/server/graphics/android/internal_client.h'
--- src/server/graphics/android/internal_client.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/android/internal_client.h	2013-05-09 21:03:25 +0000
@@ -0,0 +1,52 @@
+/*
+ * 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]>
+ */
+
+#ifndef MIR_GRAPHICS_ANDROID_INTERNAL_CLIENT_H_
+#define MIR_GRAPHICS_ANDROID_INTERNAL_CLIENT_H_
+
+#include "mir/graphics/internal_client.h"
+#include <memory>
+
+namespace mir
+{
+namespace frontend
+{
+class Surface;
+}
+namespace graphics
+{
+namespace android
+{
+
+class MirNativeWindow;
+class InternalClient : public mir::graphics::InternalClient
+{
+public:
+    InternalClient(std::shared_ptr<frontend::Surface> const&);
+    EGLNativeDisplayType egl_native_display();
+    EGLNativeWindowType egl_native_window();
+
+private:
+    std::shared_ptr<MirNativeWindow> client_window;
+};
+
+}
+}
+}
+
+#endif /* MIR_GRAPHICS_ANDROID_INTERNAL_CLIENT_H_ */

=== added file 'src/server/graphics/android/internal_client_window.cpp'
--- src/server/graphics/android/internal_client_window.cpp	1970-01-01 00:00:00 +0000
+++ src/server/graphics/android/internal_client_window.cpp	2013-05-09 21:03:25 +0000
@@ -0,0 +1,79 @@
+/*
+ * 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 "mir/frontend/surface.h"
+#include "mir/compositor/buffer.h"
+#include "internal_client_window.h"
+#include "interpreter_resource_cache.h"
+#include "android_format_conversion-inl.h"
+
+#include <boost/throw_exception.hpp>
+#include <stdexcept>
+namespace mga=mir::graphics::android;
+namespace geom=mir::geometry;
+
+mga::InternalClientWindow::InternalClientWindow(std::shared_ptr<frontend::Surface> const& surface,
+                                                std::shared_ptr<InterpreterResourceCache> const& cache)
+    : surface(surface),
+      resource_cache(cache)
+{
+    format = mga::to_android_format(surface->pixel_format());
+}
+
+ANativeWindowBuffer* mga::InternalClientWindow::driver_requests_buffer()
+{
+    surface->advance_client_buffer();
+    auto buffer = surface->client_buffer();
+    auto handle = buffer->native_buffer_handle().get();
+    resource_cache->store_buffer(buffer, handle);
+    return handle;
+}
+
+void mga::InternalClientWindow::driver_returns_buffer(ANativeWindowBuffer* handle,
+                                                      std::shared_ptr<SyncObject> const&)
+{
+    resource_cache->retrieve_buffer(handle);
+    /* here, the mc::TemporaryBuffer will destruct, triggering buffer advance */
+}
+
+void mga::InternalClientWindow::dispatch_driver_request_format(int request_format)
+{
+    format = request_format;
+}
+
+int mga::InternalClientWindow::driver_requests_info(int key) const
+{
+    geom::Size size;
+    switch(key)
+    {
+        case NATIVE_WINDOW_DEFAULT_WIDTH:
+        case NATIVE_WINDOW_WIDTH:
+            size = surface->size();
+            return size.width.as_uint32_t();
+        case NATIVE_WINDOW_DEFAULT_HEIGHT:
+        case NATIVE_WINDOW_HEIGHT:
+            size = surface->size();
+            return size.height.as_uint32_t();
+        case NATIVE_WINDOW_FORMAT:
+            return format;
+        case NATIVE_WINDOW_TRANSFORM_HINT:
+            return 0; 
+        default:
+            BOOST_THROW_EXCEPTION(std::runtime_error("driver requests info we dont provide. key: " + key));
+    }
+}

=== added file 'src/server/graphics/android/internal_client_window.h'
--- src/server/graphics/android/internal_client_window.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/android/internal_client_window.h	2013-05-09 21:03:25 +0000
@@ -0,0 +1,58 @@
+/*
+ * 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]>
+ */
+
+#ifndef MIR_GRAPHICS_ANDROID_INTERNAL_CLIENT_WINDOW_H_
+#define MIR_GRAPHICS_ANDROID_INTERNAL_CLIENT_WINDOW_H_
+
+#include "mir/graphics/android/android_driver_interpreter.h"
+#include "mir/geometry/size.h"
+#include "mir/geometry/pixel_format.h"
+
+namespace mir
+{
+
+namespace frontend
+{
+class Surface;
+}
+
+namespace graphics
+{
+namespace android
+{
+
+class InterpreterResourceCache;
+class InternalClientWindow : public AndroidDriverInterpreter
+{
+public:
+    InternalClientWindow(std::shared_ptr<frontend::Surface> const&,
+                         std::shared_ptr<InterpreterResourceCache> const&);
+    ANativeWindowBuffer* driver_requests_buffer();
+    void driver_returns_buffer(ANativeWindowBuffer*, std::shared_ptr<SyncObject> const&);
+    void dispatch_driver_request_format(int);
+    int  driver_requests_info(int) const;
+
+private:
+    std::shared_ptr<frontend::Surface> const surface;
+    std::shared_ptr<InterpreterResourceCache> const resource_cache;
+    int format;
+};
+}
+}
+}
+#endif /* MIR_GRAPHICS_ANDROID_INTERNAL_CLIENT_WINDOW_H_ */

=== added file 'src/server/graphics/android/interpreter_cache.cpp'
--- src/server/graphics/android/interpreter_cache.cpp	1970-01-01 00:00:00 +0000
+++ src/server/graphics/android/interpreter_cache.cpp	2013-05-09 21:03:25 +0000
@@ -0,0 +1,41 @@
+/*
+ * 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 "interpreter_cache.h"
+#include <boost/throw_exception.hpp>
+#include <stdexcept>
+
+namespace mga=mir::graphics::android;
+namespace mc=mir::compositor;
+
+void mga::InterpreterCache::store_buffer(std::shared_ptr<compositor::Buffer>const& buffer, ANativeWindowBuffer* key)
+{
+    buffers_in_driver[key] = buffer;
+}
+
+std::shared_ptr<mc::Buffer> mga::InterpreterCache::retrieve_buffer(ANativeWindowBuffer* returned_handle)
+{
+    auto buffer_it = buffers_in_driver.find(returned_handle); 
+    if (buffer_it == buffers_in_driver.end())
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error("driver is returning buffers it never was given!"));
+    }
+    auto buffer_out = buffer_it->second;
+    buffers_in_driver.erase(buffer_it);
+    return buffer_out;
+}

=== added file 'src/server/graphics/android/interpreter_cache.h'
--- src/server/graphics/android/interpreter_cache.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/android/interpreter_cache.h	2013-05-09 21:03:25 +0000
@@ -0,0 +1,45 @@
+/*
+ * 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]>
+ */
+
+#ifndef MIR_GRAPHICS_ANDROID_INTERPRETER_CACHE_H_
+#define MIR_GRAPHICS_ANDROID_INTERPRETER_CACHE_H_
+
+#include "interpreter_resource_cache.h"
+#include <unordered_map>
+
+namespace mir
+{
+namespace graphics
+{
+namespace android
+{
+class InterpreterCache : public InterpreterResourceCache
+{
+public:
+    InterpreterCache() {}
+
+    void store_buffer(std::shared_ptr<compositor::Buffer>const& buffer, ANativeWindowBuffer* key);
+    std::shared_ptr<compositor::Buffer> retrieve_buffer(ANativeWindowBuffer* key);
+
+private:
+    std::unordered_map<ANativeWindowBuffer*, std::shared_ptr<compositor::Buffer>> buffers_in_driver;
+};
+}
+}
+}
+#endif /* MIR_GRAPHICS_ANDROID_INTERPRETER_CACHE_H_ */

=== added file 'src/server/graphics/android/interpreter_resource_cache.h'
--- src/server/graphics/android/interpreter_resource_cache.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/android/interpreter_resource_cache.h	2013-05-09 21:03:25 +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 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]>
+ */
+
+#ifndef MIR_GRAPHICS_ANDROID_INTERPRETER_RESOURCE_CACHE_H_
+#define MIR_GRAPHICS_ANDROID_INTERPRETER_RESOURCE_CACHE_H_
+#include <system/window.h>
+#include <memory>
+
+namespace mir
+{
+namespace compositor
+{
+class Buffer;
+}
+namespace graphics
+{
+namespace android
+{
+class InterpreterResourceCache
+{
+public:
+    InterpreterResourceCache() {}
+
+    virtual void store_buffer(std::shared_ptr<compositor::Buffer>const& buffer, ANativeWindowBuffer* key) = 0;
+    virtual std::shared_ptr<compositor::Buffer> retrieve_buffer(ANativeWindowBuffer* key) = 0;
+
+protected:
+    virtual ~InterpreterResourceCache() {}
+    InterpreterResourceCache(const InterpreterResourceCache&) = delete;
+    InterpreterResourceCache& operator=(const InterpreterResourceCache&) = delete;
+};
+}
+}
+}
+#endif /* MIR_GRAPHICS_ANDROID_INTERPRETER_RESOURCE_CACHE_H_ */

=== modified file 'src/server/graphics/android/server_render_window.cpp'
--- src/server/graphics/android/server_render_window.cpp	2013-05-06 15:38:52 +0000
+++ src/server/graphics/android/server_render_window.cpp	2013-05-09 21:03:25 +0000
@@ -23,11 +23,11 @@
 #include "fb_swapper.h"
 #include "buffer.h"
 #include "android_format_conversion-inl.h"
+#include "interpreter_resource_cache.h"
 
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
 
-
 #include <thread>
 #include <chrono>
 namespace mc=mir::compositor;
@@ -35,9 +35,11 @@
 namespace geom=mir::geometry;
 
 mga::ServerRenderWindow::ServerRenderWindow(std::shared_ptr<mga::FBSwapper> const& swapper,
-                                            std::shared_ptr<mga::DisplaySupportProvider> const& display_poster)
+                                            std::shared_ptr<mga::DisplaySupportProvider> const& display_poster,
+                                            std::shared_ptr<InterpreterResourceCache> const& cache)
     : swapper(swapper),
       poster(display_poster),
+      resource_cache(cache),
       format(mga::to_android_format(poster->display_format()))
 {
 }
@@ -46,22 +48,14 @@
 {
     auto buffer = swapper->compositor_acquire();
     auto handle = buffer->native_buffer_handle().get();
-    buffers_in_driver[handle] = buffer;
-
+    resource_cache->store_buffer(buffer, handle);
     return handle;
 }
 
 //sync object could be passed to hwc. we don't need to that yet though
 void mga::ServerRenderWindow::driver_returns_buffer(ANativeWindowBuffer* returned_handle, std::shared_ptr<SyncObject> const&)
 {
-    auto buffer_it = buffers_in_driver.find(returned_handle); 
-    if (buffer_it == buffers_in_driver.end())
-    {
-        BOOST_THROW_EXCEPTION(std::runtime_error("driver is returning buffers it never was given!"));
-    }
-
-    auto buffer = buffer_it->second;
-    buffers_in_driver.erase(buffer_it);
+    auto buffer = resource_cache->retrieve_buffer(returned_handle); 
     poster->set_next_frontbuffer(buffer);
     swapper->compositor_release(buffer);
 }

=== modified file 'src/server/graphics/android/server_render_window.h'
--- src/server/graphics/android/server_render_window.h	2013-05-06 15:38:52 +0000
+++ src/server/graphics/android/server_render_window.h	2013-05-09 21:03:25 +0000
@@ -42,11 +42,13 @@
 
 class FBSwapper;
 class DisplaySupportProvider;
+class InterpreterResourceCache;
 class ServerRenderWindow : public AndroidDriverInterpreter 
 {
 public:
     ServerRenderWindow(std::shared_ptr<FBSwapper> const& swapper,
-                       std::shared_ptr<DisplaySupportProvider> const& display_poster);
+                       std::shared_ptr<DisplaySupportProvider> const& display_poster,
+                       std::shared_ptr<InterpreterResourceCache> const&);
 
     ANativeWindowBuffer* driver_requests_buffer();
     void driver_returns_buffer(ANativeWindowBuffer*, std::shared_ptr<SyncObject> const&);
@@ -56,8 +58,7 @@
 private:
     std::shared_ptr<FBSwapper> const swapper;
     std::shared_ptr<DisplaySupportProvider> const poster;
-
-    std::unordered_map<ANativeWindowBuffer*, std::shared_ptr<compositor::Buffer>> buffers_in_driver;
+    std::shared_ptr<InterpreterResourceCache> const resource_cache;
 
     int format;
 }; 

=== removed directory 'src/server/graphics/egl'
=== removed file 'src/server/graphics/egl/CMakeLists.txt'
--- src/server/graphics/egl/CMakeLists.txt	2013-03-27 00:11:32 +0000
+++ src/server/graphics/egl/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,10 +0,0 @@
-list(
-  APPEND GRAPHICS_SOURCES
-  ${CMAKE_CURRENT_SOURCE_DIR}/mesa_native_display.cpp
-)
-
-set(
-  GRAPHICS_SOURCES
-  ${GRAPHICS_SOURCES}
-  PARENT_SCOPE
-)
\ No newline at end of file

=== modified file 'src/server/graphics/gbm/CMakeLists.txt'
--- src/server/graphics/gbm/CMakeLists.txt	2013-04-30 21:38:41 +0000
+++ src/server/graphics/gbm/CMakeLists.txt	2013-05-09 21:03:25 +0000
@@ -26,6 +26,8 @@
   kms_output_container.cpp
   kms_page_flipper.cpp
   linux_virtual_terminal.cpp
+  internal_native_display.cpp
+  internal_client.cpp
 )
 
 target_link_libraries(

=== modified file 'src/server/graphics/gbm/gbm_platform.cpp'
--- src/server/graphics/gbm/gbm_platform.cpp	2013-04-24 05:22:20 +0000
+++ src/server/graphics/gbm/gbm_platform.cpp	2013-05-09 21:03:25 +0000
@@ -20,9 +20,10 @@
 
 #include "gbm_buffer_allocator.h"
 #include "gbm_display.h"
+#include "internal_client.h"
+#include "internal_native_display.h"
 #include "linux_virtual_terminal.h"
 #include "mir/graphics/platform_ipc_package.h"
-#include "mir/graphics/egl/mesa_native_display.h"
 
 #include <xf86drm.h>
 
@@ -31,9 +32,7 @@
 
 namespace mg = mir::graphics;
 namespace mgg = mg::gbm;
-namespace mgeglm = mg::egl::mesa;
 namespace mc = mir::compositor;
-
 namespace
 {
 
@@ -76,15 +75,24 @@
 
 }
 
+std::shared_ptr<mgg::InternalNativeDisplay> mgg::GBMPlatform::internal_native_display;
+bool mgg::GBMPlatform::internal_display_clients_present;
 mgg::GBMPlatform::GBMPlatform(std::shared_ptr<DisplayReport> const& listener,
                               std::shared_ptr<VirtualTerminal> const& vt)
     : listener{listener},
-      vt{vt},
-      native_display{0}
+      vt{vt}
 {
     drm.setup();
     gbm.setup(drm);
-}
+    internal_display_clients_present = false;
+}
+
+mgg::GBMPlatform::~GBMPlatform()
+{
+    internal_native_display.reset();
+    internal_display_clients_present = false;
+}
+
 
 std::shared_ptr<mc::GraphicBufferAllocator> mgg::GBMPlatform::create_buffer_allocator(
         const std::shared_ptr<mg::BufferInitializer>& buffer_initializer)
@@ -110,13 +118,13 @@
     drm.auth_magic(magic);
 }
 
-EGLNativeDisplayType mgg::GBMPlatform::shell_egl_display()
+std::shared_ptr<mg::InternalClient> mgg::GBMPlatform::create_internal_client(
+    std::shared_ptr<frontend::Surface> const& surface)
 {
-    if (native_display)
-        return reinterpret_cast<EGLNativeDisplayType>(native_display.get());
-    native_display = mgeglm::create_native_display(this->shared_from_this());
-    
-    return reinterpret_cast<EGLNativeDisplayType>(native_display.get());
+    if (!internal_native_display)
+        internal_native_display = std::make_shared<mgg::InternalNativeDisplay>(get_ipc_package()); 
+    internal_display_clients_present = true;
+    return std::make_shared<mgg::InternalClient>(internal_native_display, surface);
 }
 
 std::shared_ptr<mg::Platform> mg::create_platform(std::shared_ptr<DisplayReport> const& report)
@@ -125,3 +133,21 @@
     auto vt = std::make_shared<mgg::LinuxVirtualTerminal>(real_fops, report);
     return std::make_shared<mgg::GBMPlatform>(report, vt);
 }
+
+extern "C"
+{
+int mir_server_internal_display_is_valid(MirMesaEGLNativeDisplay* display)
+{
+    return ((mgg::GBMPlatform::internal_display_clients_present) &&
+            (display == mgg::GBMPlatform::internal_native_display.get()));
+}
+
+/* TODO: this function is a bit fragile because libmirserver and libmirclient both have very different
+ *       implementations and both have symbols for it.
+ *       bug filed: lp:1177902
+ */
+int mir_egl_mesa_display_is_valid(MirMesaEGLNativeDisplay* display)
+{
+    return mir_server_internal_display_is_valid(display);
+}
+}

=== modified file 'src/server/graphics/gbm/gbm_platform.h'
--- src/server/graphics/gbm/gbm_platform.h	2013-04-24 05:22:20 +0000
+++ src/server/graphics/gbm/gbm_platform.h	2013-05-09 21:03:25 +0000
@@ -33,7 +33,7 @@
 {
 
 class VirtualTerminal;
-
+class InternalNativeDisplay;
 class GBMPlatform : public Platform,
                     public DRMAuthenticator,
                     public std::enable_shared_from_this<GBMPlatform>
@@ -41,14 +41,14 @@
 public:
     explicit GBMPlatform(std::shared_ptr<DisplayReport> const& reporter,
                          std::shared_ptr<VirtualTerminal> const& vt);
+    ~GBMPlatform();
 
     /* From Platform */
     std::shared_ptr<compositor::GraphicBufferAllocator> create_buffer_allocator(
             const std::shared_ptr<BufferInitializer>& buffer_initializer);
     std::shared_ptr<Display> create_display();
-    std::shared_ptr<PlatformIPCPackage> get_ipc_package();
-    
-    EGLNativeDisplayType shell_egl_display();
+    std::shared_ptr<PlatformIPCPackage> get_ipc_package(); 
+    std::shared_ptr<InternalClient> create_internal_client(std::shared_ptr<frontend::Surface> const&);
 
     /* From DRMAuthenticator */
     void drm_auth_magic(drm_magic_t magic);
@@ -59,8 +59,9 @@
     std::shared_ptr<DisplayReport> const listener;
     std::shared_ptr<VirtualTerminal> const vt;
 
-private:
-    std::shared_ptr<MirMesaEGLNativeDisplay> native_display;
+    //connection shared by all internal clients
+    static bool internal_display_clients_present;
+    static std::shared_ptr<InternalNativeDisplay> internal_native_display;
 };
 
 }

=== added file 'src/server/graphics/gbm/internal_client.cpp'
--- src/server/graphics/gbm/internal_client.cpp	1970-01-01 00:00:00 +0000
+++ src/server/graphics/gbm/internal_client.cpp	2013-05-09 21:03:25 +0000
@@ -0,0 +1,40 @@
+/*
+ * 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 "internal_client.h"
+
+namespace mg=mir::graphics;
+namespace mgg=mir::graphics::gbm;
+namespace mf=mir::frontend;
+
+mgg::InternalClient::InternalClient(std::shared_ptr<MirMesaEGLNativeDisplay> const& native_display,
+                                    std::shared_ptr<mf::Surface> const& surface)
+    : native_display(native_display),
+      surface(surface)
+{
+}
+
+EGLNativeDisplayType mgg::InternalClient::egl_native_display()
+{
+    return reinterpret_cast<EGLNativeDisplayType>(native_display.get());
+}
+
+EGLNativeWindowType mgg::InternalClient::egl_native_window()
+{
+    return reinterpret_cast<EGLNativeWindowType>(surface.get());
+}

=== added file 'src/server/graphics/gbm/internal_client.h'
--- src/server/graphics/gbm/internal_client.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/gbm/internal_client.h	2013-05-09 21:03:25 +0000
@@ -0,0 +1,55 @@
+/*
+ * 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]>
+ */
+
+#ifndef MIR_GRAPHICS_GBM_INTERNAL_CLIENT_H_
+#define MIR_GRAPHICS_GBM_INTERNAL_CLIENT_H_
+
+#include "mir/graphics/internal_client.h"
+#include "internal_native_display.h"
+#include <memory>
+
+namespace mir
+{
+namespace frontend
+{
+class Surface;
+}
+namespace graphics
+{
+class Platform;
+namespace gbm
+{
+
+class InternalClient : public mir::graphics::InternalClient
+{
+public:
+    InternalClient(std::shared_ptr<MirMesaEGLNativeDisplay> const&,
+                   std::shared_ptr<frontend::Surface> const&);
+    EGLNativeDisplayType egl_native_display();
+    EGLNativeWindowType egl_native_window();
+
+private:
+    std::shared_ptr<MirMesaEGLNativeDisplay> const native_display;
+    std::shared_ptr<frontend::Surface> const surface;
+};
+
+}
+}
+}
+
+#endif /* MIR_GRAPHICS_GBM_INTERNAL_CLIENT_H_ */

=== renamed file 'src/server/graphics/egl/mesa_native_display.cpp' => 'src/server/graphics/gbm/internal_native_display.cpp'
--- src/server/graphics/egl/mesa_native_display.cpp	2013-05-02 00:11:18 +0000
+++ src/server/graphics/gbm/internal_native_display.cpp	2013-05-09 21:03:25 +0000
@@ -16,8 +16,8 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
+#include "internal_native_display.h"
 #include "mir/display_server.h"
-#include "mir/graphics/egl/mesa_native_display.h"
 #include "mir/graphics/platform_ipc_package.h"
 #include "mir/graphics/platform.h"
 #include "mir/frontend/surface.h"
@@ -30,118 +30,71 @@
 #include <set>
 
 namespace mg = mir::graphics;
-namespace mgeglm = mg::egl::mesa;
+namespace mgg = mir::graphics::gbm;
 namespace mf = mir::frontend;
 
-std::mutex valid_displays_guard;
-std::set<MirMesaEGLNativeDisplay*> valid_displays;
-
-namespace
-{
-struct ShellMesaEGLNativeDisplay : MirMesaEGLNativeDisplay
-{
-public:
-    ShellMesaEGLNativeDisplay(std::shared_ptr<mg::Platform> const& graphics_platform)
-        : graphics_platform(graphics_platform)
-    {
-        context = this;
-        this->display_get_platform = &ShellMesaEGLNativeDisplay::native_display_get_platform;
-        this->surface_get_current_buffer = &ShellMesaEGLNativeDisplay::native_display_surface_get_current_buffer;
-        this->surface_get_parameters = &ShellMesaEGLNativeDisplay::native_display_surface_get_parameters;
-        this->surface_advance_buffer = &ShellMesaEGLNativeDisplay::native_display_surface_advance_buffer;
-    }
-
-    static void native_display_get_platform(MirMesaEGLNativeDisplay* display, MirPlatformPackage* package)
-    {
-        auto native_disp = static_cast<ShellMesaEGLNativeDisplay*>(display);
-        if (!native_disp->platform_package)
-            native_disp->platform_package = native_disp->graphics_platform->get_ipc_package();
-        package->data_items = native_disp->platform_package->ipc_data.size();
-        for (int i = 0; i < package->data_items; i++)
-        {
-            package->data[i] = native_disp->platform_package->ipc_data[i];
-        }
-        package->fd_items = native_disp->platform_package->ipc_fds.size();
-        for (int i = 0; i < package->fd_items; i++)
-        {
-            package->fd[i] = native_disp->platform_package->ipc_fds[i];
-        }
-
-    }
-    
-    static void native_display_surface_get_current_buffer(MirMesaEGLNativeDisplay* /* display */, 
-                                                          MirEGLNativeWindowType surface,
-                                                          MirBufferPackage* package)
-    {
-        auto mir_surface = static_cast<mf::Surface*>(surface);
-
-        auto buffer = mir_surface->client_buffer();
-        auto buffer_package = buffer->get_ipc_package();
-        package->data_items = buffer_package->ipc_data.size();
-        for (int i = 0; i < package->data_items; i++)
-        {
-            package->data[i] = buffer_package->ipc_data[i];
-        }
-        package->fd_items = buffer_package->ipc_fds.size();
-        for (int i = 0; i < package->fd_items; i++)
-        {
-            package->fd[i] = buffer_package->ipc_fds[i];
-        }
-        package->stride = buffer_package->stride;
-    }
-
-    static void native_display_surface_get_parameters(MirMesaEGLNativeDisplay* /* display  */, 
+mgg::InternalNativeDisplay::InternalNativeDisplay(std::shared_ptr<mg::PlatformIPCPackage> const& platform_package)
+    : platform_package(platform_package)
+{
+    context = this;
+    this->display_get_platform = &InternalNativeDisplay::native_display_get_platform;
+    this->surface_get_current_buffer = &InternalNativeDisplay::native_display_surface_get_current_buffer;
+    this->surface_get_parameters = &InternalNativeDisplay::native_display_surface_get_parameters;
+    this->surface_advance_buffer = &InternalNativeDisplay::native_display_surface_advance_buffer;
+}
+
+void mgg::InternalNativeDisplay::native_display_get_platform(MirMesaEGLNativeDisplay* display, MirPlatformPackage* package)
+{
+    auto native_disp = static_cast<InternalNativeDisplay*>(display);
+    package->data_items = native_disp->platform_package->ipc_data.size();
+    for (int i = 0; i < package->data_items; i++)
+    {
+        package->data[i] = native_disp->platform_package->ipc_data[i];
+    }
+    package->fd_items = native_disp->platform_package->ipc_fds.size();
+    for (int i = 0; i < package->fd_items; i++)
+    {
+        package->fd[i] = native_disp->platform_package->ipc_fds[i];
+    }
+
+}
+
+void mgg::InternalNativeDisplay::native_display_surface_get_current_buffer(MirMesaEGLNativeDisplay*, 
                                                       MirEGLNativeWindowType surface,
-                                                      MirSurfaceParameters* parameters)
-    {
-        auto mir_surface = static_cast<mf::Surface*>(surface);
-
-        parameters->width = mir_surface->size().width.as_uint32_t();
-        parameters->height = mir_surface->size().height.as_uint32_t();
-        parameters->pixel_format = static_cast<MirPixelFormat>(mir_surface->pixel_format());
-        parameters->buffer_usage = mir_buffer_usage_hardware;
-    }
-
-    static void native_display_surface_advance_buffer(MirMesaEGLNativeDisplay* /* display */, 
-                                                      MirEGLNativeWindowType surface)
-    {
-        auto mir_surface = static_cast<mf::Surface*>(surface);
-        mir_surface->advance_client_buffer();
-    }
-
-private:
-    std::shared_ptr<mg::Platform> graphics_platform;
-    std::shared_ptr<mg::PlatformIPCPackage> platform_package;
-};
-
-struct NativeDisplayDeleter
-{
-    void operator()(MirMesaEGLNativeDisplay* display)
-    {
-        std::unique_lock<std::mutex> lg(valid_displays_guard);
-        valid_displays.erase(display);
-        auto disp = static_cast<ShellMesaEGLNativeDisplay*>(display->context);
-        delete disp;
-    }
-};
-
-}
-
-extern "C"
-{
-int mir_egl_mesa_display_is_valid(MirMesaEGLNativeDisplay* display)
-{
-    std::unique_lock<std::mutex> lg(valid_displays_guard);
-    return valid_displays.find(display) != valid_displays.end();
-}
-}
-
-std::shared_ptr<MirMesaEGLNativeDisplay> mgeglm::create_native_display(std::shared_ptr<mg::Platform> const& platform)
-{
-    auto native_display = std::shared_ptr<ShellMesaEGLNativeDisplay>(new ShellMesaEGLNativeDisplay(platform), 
-                                                                     NativeDisplayDeleter());
-    std::unique_lock<std::mutex> lg(valid_displays_guard);
-    valid_displays.insert(native_display.get());
-    
-    return native_display;
+                                                      MirBufferPackage* package)
+{
+    auto mir_surface = static_cast<mf::Surface*>(surface);
+
+    auto buffer = mir_surface->client_buffer();
+    auto buffer_package = buffer->get_ipc_package();
+    package->data_items = buffer_package->ipc_data.size();
+    for (int i = 0; i < package->data_items; i++)
+    {
+        package->data[i] = buffer_package->ipc_data[i];
+    }
+    package->fd_items = buffer_package->ipc_fds.size();
+    for (int i = 0; i < package->fd_items; i++)
+    {
+        package->fd[i] = buffer_package->ipc_fds[i];
+    }
+    package->stride = buffer_package->stride;
+}
+
+void mgg::InternalNativeDisplay::native_display_surface_get_parameters(MirMesaEGLNativeDisplay*, 
+                                                  MirEGLNativeWindowType surface,
+                                                  MirSurfaceParameters* parameters)
+{
+    auto mir_surface = static_cast<mf::Surface*>(surface);
+
+    parameters->width = mir_surface->size().width.as_uint32_t();
+    parameters->height = mir_surface->size().height.as_uint32_t();
+    parameters->pixel_format = static_cast<MirPixelFormat>(mir_surface->pixel_format());
+    parameters->buffer_usage = mir_buffer_usage_hardware;
+}
+
+void mgg::InternalNativeDisplay::native_display_surface_advance_buffer(MirMesaEGLNativeDisplay*, 
+                                                  MirEGLNativeWindowType surface)
+{
+    auto mir_surface = static_cast<mf::Surface*>(surface);
+    mir_surface->advance_client_buffer();
 }

=== added file 'src/server/graphics/gbm/internal_native_display.h'
--- src/server/graphics/gbm/internal_native_display.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/gbm/internal_native_display.h	2013-05-09 21:03:25 +0000
@@ -0,0 +1,56 @@
+
+/*
+ * 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: Robert Carr <[e-mail]>
+ *              Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_GBM_INTERNAL_NATIVE_DISPLAY_H_
+#define MIR_GRAPHICS_GBM_INTERNAL_NATIVE_DISPLAY_H_
+
+#include "mir_toolkit/mesa/native_display.h"
+#include <memory>
+
+namespace mir
+{
+namespace graphics
+{
+struct PlatformIPCPackage;
+namespace gbm
+{
+
+class InternalNativeDisplay : public MirMesaEGLNativeDisplay
+{
+public:
+    InternalNativeDisplay(std::shared_ptr<PlatformIPCPackage> const& platform_package);
+
+    static void native_display_get_platform(MirMesaEGLNativeDisplay* display, MirPlatformPackage* package);
+    static void native_display_surface_get_current_buffer(MirMesaEGLNativeDisplay* /* display */, 
+                                                          MirEGLNativeWindowType surface,
+                                                          MirBufferPackage* package);
+    static void native_display_surface_get_parameters(MirMesaEGLNativeDisplay* /* display  */, 
+                                                      MirEGLNativeWindowType surface,
+                                                      MirSurfaceParameters* parameters);
+    static void native_display_surface_advance_buffer(MirMesaEGLNativeDisplay* /* display */, 
+                                                      MirEGLNativeWindowType surface);
+private:
+    std::shared_ptr<PlatformIPCPackage> platform_package;
+};
+
+}
+}
+}
+#endif /* MIR_GRAPHICS_GBM_INTERNAL_NATIVE_DISPLAY_H_ */

=== modified file 'tests/integration-tests/graphics/android/CMakeLists.txt'
--- tests/integration-tests/graphics/android/CMakeLists.txt	2013-05-02 16:29:48 +0000
+++ tests/integration-tests/graphics/android/CMakeLists.txt	2013-05-09 21:03:25 +0000
@@ -2,6 +2,7 @@
   APPEND INTEGRATION_TESTS_SRCS
   ${CMAKE_CURRENT_SOURCE_DIR}/test_buffer_integration.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_display_integration.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_internal_client.cpp
 )
 
 set(

=== added file 'tests/integration-tests/graphics/android/test_internal_client.cpp'
--- tests/integration-tests/graphics/android/test_internal_client.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/graphics/android/test_internal_client.cpp	2013-05-09 21:03:25 +0000
@@ -0,0 +1,132 @@
+/*
+ * 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/server/graphics/android/android_graphic_buffer_allocator.h"
+#include "src/server/graphics/android/internal_client_window.h"
+#include "src/server/graphics/android/interpreter_cache.h"
+#include "mir/compositor/swapper_factory.h"
+#include "mir/compositor/buffer_swapper.h"
+#include "mir/compositor/buffer_bundle_manager.h"
+#include "mir/graphics/buffer_initializer.h"
+#include "mir/graphics/null_display_report.h"
+#include "mir/graphics/android/mir_native_window.h"
+#include "mir/graphics/platform.h"
+#include "mir/graphics/internal_client.h"
+#include "mir/surfaces/surface_stack.h"
+#include "mir/surfaces/surface_controller.h"
+#include "mir/shell/surface_source.h"
+#include "mir/shell/surface.h"
+#include "mir/frontend/surface_creation_parameters.h"
+#include "mir/frontend/surface_id.h"
+#include "mir/input/input_channel_factory.h"
+
+#include <EGL/egl.h>
+#include <gtest/gtest.h>
+
+#include <GLES2/gl2.h>
+
+
+namespace mg=mir::graphics;
+namespace mga=mir::graphics::android;
+namespace mc=mir::compositor;
+namespace geom=mir::geometry;
+namespace ms=mir::surfaces;
+namespace msh=mir::shell;
+namespace mf=mir::frontend;
+namespace mi=mir::input;
+
+namespace
+{
+class AndroidInternalClient : public ::testing::Test
+{
+protected:
+    virtual void SetUp()
+    {
+    }
+};
+
+struct StubInputFactory : public mi::InputChannelFactory 
+{
+    std::shared_ptr<mi::InputChannel> make_input_channel()
+    {
+        return std::shared_ptr<mi::InputChannel>();
+    }
+};
+}
+
+TEST_F(AndroidInternalClient, internal_client_creation_and_use)
+{
+    auto size = geom::Size{geom::Width{334},
+                      geom::Height{122}};
+    auto pf  = geom::PixelFormat::abgr_8888;
+    mf::SurfaceCreationParameters params;
+    params.name = std::string("test");
+    params.size = size; 
+    params.pixel_format = pf;
+    params.buffer_usage = mc::BufferUsage::hardware; 
+    auto id = mf::SurfaceId{4458};
+
+    auto stub_input_factory = std::make_shared<StubInputFactory>();
+    auto null_buffer_initializer = std::make_shared<mg::NullBufferInitializer>();
+    auto allocator = std::make_shared<mga::AndroidGraphicBufferAllocator>(null_buffer_initializer);
+    auto strategy = std::make_shared<mc::SwapperFactory>(allocator);
+    auto buffer_bundle_factory = std::make_shared<mc::BufferBundleManager>(strategy);
+    auto ss = std::make_shared<ms::SurfaceStack>(buffer_bundle_factory);
+    auto surface_controller = std::make_shared<ms::SurfaceController>(ss);
+    auto surface_source = std::make_shared<msh::SurfaceSource>(surface_controller, stub_input_factory);
+    auto mir_surface = surface_source->create_surface(params, id, std::shared_ptr<mir::events::EventSink>());
+
+    auto report = std::shared_ptr<mg::NullDisplayReport>(); 
+    auto platform = mg::create_platform(report);
+    auto internal_client = platform->create_internal_client(mir_surface);
+
+    int major, minor, n;
+    EGLContext egl_context;
+    EGLSurface egl_surface;
+    EGLConfig egl_config;
+    EGLint attribs[] = {
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+        EGL_RED_SIZE, 8,
+        EGL_GREEN_SIZE, 8,
+        EGL_BLUE_SIZE, 8,
+        EGL_ALPHA_SIZE, 8,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+        EGL_NONE };
+    EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
+
+    auto egl_display = eglGetDisplay(internal_client->egl_native_display());
+    int rc = eglInitialize(egl_display, &major, &minor);
+    EXPECT_EQ(EGL_TRUE, rc);
+
+    rc = eglChooseConfig(egl_display, attribs, &egl_config, 1, &n);
+    EXPECT_EQ(EGL_TRUE, rc);
+
+    egl_surface = eglCreateWindowSurface(egl_display, egl_config, internal_client->egl_native_window(), NULL);
+    EXPECT_NE(EGL_NO_SURFACE, egl_surface);
+
+    egl_context = eglCreateContext(egl_display, egl_config, EGL_NO_CONTEXT, context_attribs);
+    EXPECT_NE(EGL_NO_CONTEXT, egl_context);
+
+    rc = eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context);
+    EXPECT_EQ(EGL_TRUE, rc);
+
+    glClearColor(1.0f, 0.0, 0.0, 1.0);
+    glClear(GL_COLOR_BUFFER_BIT);
+    rc = eglSwapBuffers(egl_display, egl_surface);
+    EXPECT_EQ(EGL_TRUE, rc);
+}

=== modified file 'tests/integration-tests/graphics/gbm/test_buffer_integration.cpp'
--- tests/integration-tests/graphics/gbm/test_buffer_integration.cpp	2013-04-24 05:22:20 +0000
+++ tests/integration-tests/graphics/gbm/test_buffer_integration.cpp	2013-05-09 21:03:25 +0000
@@ -100,9 +100,9 @@
         return std::shared_ptr<mg::PlatformIPCPackage>();
     }
 
-    EGLNativeDisplayType shell_egl_display()
+    std::shared_ptr<mg::InternalClient> create_internal_client(std::shared_ptr<mir::frontend::Surface> const&)
     {
-        return static_cast<EGLNativeDisplayType>(0);
+        return std::shared_ptr<mg::InternalClient>();
     }
 };
 

=== modified file 'tests/integration-tests/test_display_info.cpp'
--- tests/integration-tests/test_display_info.cpp	2013-04-24 05:22:20 +0000
+++ tests/integration-tests/test_display_info.cpp	2013-05-09 21:03:25 +0000
@@ -34,6 +34,7 @@
 namespace mg = mir::graphics;
 namespace mc = mir::compositor;
 namespace geom = mir::geometry;
+namespace mf = mir::frontend;
 namespace mtf = mir_test_framework;
 namespace mtd = mir::test::doubles;
 
@@ -103,10 +104,11 @@
     {
         return std::make_shared<mg::PlatformIPCPackage>();
     }
-    EGLNativeDisplayType shell_egl_display()
+
+    std::shared_ptr<mg::InternalClient> create_internal_client(std::shared_ptr<mf::Surface> const&)
     {
-        return static_cast<EGLNativeDisplayType>(0);
-    }
+        return std::shared_ptr<mg::InternalClient>();   
+    } 
 };
 
 void connection_callback(MirConnection* connection, void* context)

=== modified file 'tests/integration-tests/test_drm_auth_magic.cpp'
--- tests/integration-tests/test_drm_auth_magic.cpp	2013-04-24 05:22:20 +0000
+++ tests/integration-tests/test_drm_auth_magic.cpp	2013-05-09 21:03:25 +0000
@@ -80,9 +80,9 @@
         return std::make_shared<mg::PlatformIPCPackage>();
     }
 
-    EGLNativeDisplayType shell_egl_display()
+    std::shared_ptr<mg::InternalClient> create_internal_client(std::shared_ptr<mir::frontend::Surface> const&)
     {
-        return static_cast<EGLNativeDisplayType>(0);
+        return std::shared_ptr<mg::InternalClient>();
     }
 
     MOCK_METHOD1(drm_auth_magic, void(unsigned int));

=== modified file 'tests/integration-tests/test_surfaceloop.cpp'
--- tests/integration-tests/test_surfaceloop.cpp	2013-05-01 21:55:49 +0000
+++ tests/integration-tests/test_surfaceloop.cpp	2013-05-09 21:03:25 +0000
@@ -42,6 +42,7 @@
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
 namespace geom = mir::geometry;
+namespace mf = mir::frontend;
 namespace mtf = mir_test_framework;
 namespace mtd = mir::test::doubles;
 
@@ -355,10 +356,10 @@
             return std::make_shared<mg::PlatformIPCPackage>();
         }
 
-        EGLNativeDisplayType shell_egl_display()
+        std::shared_ptr<mg::InternalClient> create_internal_client(std::shared_ptr<mf::Surface> const&)
         {
-            return static_cast<EGLNativeDisplayType>(0);
-        }
+            return std::shared_ptr<mg::InternalClient>();   
+        } 
     };
 
     std::shared_ptr<mg::Platform> the_graphics_platform()
@@ -487,9 +488,9 @@
             return std::make_shared<mg::PlatformIPCPackage>();
         }
 
-        EGLNativeDisplayType shell_egl_display()
+        std::shared_ptr<mg::InternalClient> create_internal_client(std::shared_ptr<mf::Surface> const&)
         {
-            return (EGLNativeDisplayType) 0;
+            return std::shared_ptr<mg::InternalClient>();   
         }
     };
 

=== modified file 'tests/mir_test_framework/testing_server_options.cpp'
--- tests/mir_test_framework/testing_server_options.cpp	2013-05-02 04:17:41 +0000
+++ tests/mir_test_framework/testing_server_options.cpp	2013-05-09 21:03:25 +0000
@@ -119,9 +119,9 @@
         return std::make_shared<mg::PlatformIPCPackage>();
     }
 
-    EGLNativeDisplayType shell_egl_display()
+    std::shared_ptr<mg::InternalClient> create_internal_client(std::shared_ptr<mf::Surface> const&)
     {
-        return (EGLNativeDisplayType) 0;
+        return std::shared_ptr<mg::InternalClient>();   
     }
 };
 

=== modified file 'tests/unit-tests/client/gbm/test_gbm_client_platform.cpp'
--- tests/unit-tests/client/gbm/test_gbm_client_platform.cpp	2013-04-24 05:22:20 +0000
+++ tests/unit-tests/client/gbm/test_gbm_client_platform.cpp	2013-05-09 21:03:25 +0000
@@ -40,6 +40,10 @@
     EXPECT_EQ(reinterpret_cast<EGLNativeWindowType>(&surface), *native_window);
 }
 
+/* TODO: mir_egl_mesa_display_is_valid is a bit fragile because libmirserver and libmirclient both have very
+ *       different implementations and both have symbols for it. If the linking order of the test changes,
+ *       specifically, if mir_egl_mesa_display_is_valid resolves into libmirserver, then this test will break. 
+ */
 TEST(GBMClientPlatformTest, egl_native_display_is_valid_until_released)
 {
     mtd::MockClientContext context;

=== modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
--- tests/unit-tests/frontend/test_session_mediator.cpp	2013-04-25 09:48:54 +0000
+++ tests/unit-tests/frontend/test_session_mediator.cpp	2013-05-09 21:03:25 +0000
@@ -33,6 +33,7 @@
 #include "mir_test_doubles/mock_buffer.h"
 #include "mir_test_doubles/stub_session.h"
 #include "mir_test_doubles/stub_surface_builder.h"
+#include "mir_test_doubles/stub_platform.h"
 #include "mir_test/fake_shared.h"
 #include "mir/events/event_sink.h"
 #include "mir/shell/surface.h"
@@ -104,31 +105,6 @@
     MOCK_METHOD0(supported_pixel_formats, std::vector<geom::PixelFormat>());
 };
 
-class StubPlatform : public mg::Platform
-{
- public:
-    std::shared_ptr<mc::GraphicBufferAllocator> create_buffer_allocator(
-            const std::shared_ptr<mg::BufferInitializer>& /*buffer_initializer*/)
-    {
-        return std::shared_ptr<mc::GraphicBufferAllocator>();
-    }
-
-    std::shared_ptr<mg::Display> create_display()
-    {
-        return std::make_shared<mtd::NullDisplay>();
-    }
-
-    std::shared_ptr<mg::PlatformIPCPackage> get_ipc_package()
-    {
-        return std::make_shared<mg::PlatformIPCPackage>();
-    }
-    
-    EGLNativeDisplayType shell_egl_display()
-    {
-        return static_cast<EGLNativeDisplayType>(0);
-    }
-};
-
 class NullEventSink : public mir::events::EventSink
 {
 public:
@@ -139,7 +115,7 @@
 {
     SessionMediatorTest()
         : shell{std::make_shared<testing::NiceMock<mtd::MockShell>>()},
-          graphics_platform{std::make_shared<StubPlatform>()},
+          graphics_platform{std::make_shared<mtd::StubPlatform>()},
           graphics_display{std::make_shared<mtd::NullDisplay>()},
           buffer_allocator{std::make_shared<testing::NiceMock<MockGraphicBufferAllocator>>()},
           report{std::make_shared<mf::NullSessionMediatorReport>()},

=== modified file 'tests/unit-tests/frontend/test_session_mediator_android.cpp'
--- tests/unit-tests/frontend/test_session_mediator_android.cpp	2013-04-25 09:48:54 +0000
+++ tests/unit-tests/frontend/test_session_mediator_android.cpp	2013-05-09 21:03:25 +0000
@@ -30,6 +30,7 @@
 #include "mir_test_doubles/null_display.h"
 #include "mir_test_doubles/mock_session.h"
 #include "mir_test_doubles/stub_shell.h"
+#include "mir_test_doubles/stub_platform.h"
 
 #include "mir/events/event_sink.h"
 
@@ -62,31 +63,6 @@
     }
 };
 
-class StubPlatform : public mg::Platform
-{
- public:
-    std::shared_ptr<mc::GraphicBufferAllocator> create_buffer_allocator(
-            const std::shared_ptr<mg::BufferInitializer>& /*buffer_initializer*/)
-    {
-        return std::shared_ptr<mc::GraphicBufferAllocator>();
-    }
-
-    std::shared_ptr<mg::Display> create_display()
-    {
-        return std::make_shared<mtd::NullDisplay>();
-    }
-
-    std::shared_ptr<mg::PlatformIPCPackage> get_ipc_package()
-    {
-        return std::make_shared<mg::PlatformIPCPackage>();
-    }
-
-    EGLNativeDisplayType shell_egl_display()
-    {
-        return static_cast<EGLNativeDisplayType>(0);
-    }
-};
-
 class NullEventSink : public mir::events::EventSink
 {
 public:
@@ -97,7 +73,7 @@
 {
     SessionMediatorAndroidTest()
         : shell{std::make_shared<mtd::StubShell>()},
-          graphics_platform{std::make_shared<StubPlatform>()},
+          graphics_platform{std::make_shared<mtd::StubPlatform>()},
           graphics_display{std::make_shared<mtd::NullDisplay>()},
           buffer_allocator{std::make_shared<StubGraphicBufferAllocator>()},
           report{std::make_shared<mf::NullSessionMediatorReport>()},
@@ -111,7 +87,7 @@
     }
 
     std::shared_ptr<mtd::StubShell> const shell;
-    std::shared_ptr<StubPlatform> const graphics_platform;
+    std::shared_ptr<mtd::StubPlatform> const graphics_platform;
     std::shared_ptr<mg::Display> const graphics_display;
     std::shared_ptr<mc::GraphicBufferAllocator> const buffer_allocator;
     std::shared_ptr<mf::SessionMediatorReport> const report;

=== modified file 'tests/unit-tests/frontend/test_session_mediator_gbm.cpp'
--- tests/unit-tests/frontend/test_session_mediator_gbm.cpp	2013-04-25 09:48:54 +0000
+++ tests/unit-tests/frontend/test_session_mediator_gbm.cpp	2013-05-09 21:03:25 +0000
@@ -83,9 +83,9 @@
         return std::make_shared<mg::PlatformIPCPackage>();
     }
 
-    EGLNativeDisplayType shell_egl_display()
+    std::shared_ptr<mg::InternalClient> create_internal_client(std::shared_ptr<mf::Surface> const&)
     {
-        return static_cast<EGLNativeDisplayType>(0);
+        return std::shared_ptr<mg::InternalClient>();
     }
 
     MOCK_METHOD1(drm_auth_magic, void(drm_magic_t));

=== modified file 'tests/unit-tests/graphics/CMakeLists.txt'
--- tests/unit-tests/graphics/CMakeLists.txt	2013-04-24 05:22:20 +0000
+++ tests/unit-tests/graphics/CMakeLists.txt	2013-05-09 21:03:25 +0000
@@ -11,7 +11,6 @@
 
 if (MIR_PLATFORM STREQUAL "gbm")
 add_subdirectory(gbm/)
-add_subdirectory(egl)
 endif()
 
 set(UNIT_TEST_SOURCES ${UNIT_TEST_SOURCES} PARENT_SCOPE)

=== modified file 'tests/unit-tests/graphics/android/CMakeLists.txt'
--- tests/unit-tests/graphics/android/CMakeLists.txt	2013-05-02 16:29:48 +0000
+++ tests/unit-tests/graphics/android/CMakeLists.txt	2013-05-09 21:03:25 +0000
@@ -8,17 +8,20 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_alloc_adaptor.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_alloc_adaptor_native_win.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_buffer_allocator.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_gpu_display.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_hwc_device.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_hwc10_device.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_hwc11_device.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_hwc_display.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/test_gpu_display.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_internal_client_interpreter.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_internal_client.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_framebuffer_factory.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_fb_simple_swapper.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_fb_device.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_hwc_layerlist.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_server_interpreter.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_pixel_format.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_interpreter_buffer_cache.cpp
 )
 
 set(UNIT_TEST_SOURCES ${UNIT_TEST_SOURCES} PARENT_SCOPE)

=== added file 'tests/unit-tests/graphics/android/test_internal_client.cpp'
--- tests/unit-tests/graphics/android/test_internal_client.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/graphics/android/test_internal_client.cpp	2013-05-09 21:03:25 +0000
@@ -0,0 +1,87 @@
+/*
+ * 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 "mir/frontend/surface.h"
+#include "src/server/graphics/android/internal_client.h"
+#include <system/window.h>
+#include <gtest/gtest.h>
+
+namespace geom=mir::geometry;
+namespace mc=mir::compositor;
+namespace mga=mir::graphics::android;
+
+namespace
+{
+class StubSurface : public mir::frontend::Surface
+{
+    void destroy()
+    {
+    }
+    void force_requests_to_complete()
+    {
+    }
+    geom::Size size() const
+    {
+        return geom::Size{geom::Width{4},geom::Height{2}};
+    }
+    geom::PixelFormat pixel_format() const
+    {
+        return geom::PixelFormat::xbgr_8888;
+    }
+    void advance_client_buffer()
+    {
+    }
+    std::shared_ptr<mc::Buffer> client_buffer() const
+    {
+        return std::shared_ptr<mc::Buffer>();
+    }
+    bool supports_input() const
+    {
+        return false;
+    }
+    int client_input_fd() const
+    {
+        return 5;
+    }
+    int configure(MirSurfaceAttrib, int)
+    {
+        return 218181;
+    }
+}; 
+}
+
+TEST(InternalClient, native_display)
+{
+    auto surface = std::make_shared<StubSurface>();
+    mga::InternalClient client(surface);
+    EXPECT_EQ(EGL_DEFAULT_DISPLAY, client.egl_native_display());
+}
+
+TEST(InternalClient, native_window)
+{
+    auto surface = std::make_shared<StubSurface>();
+    mga::InternalClient client(surface);
+    ANativeWindow* native_window = static_cast<ANativeWindow*>(client.egl_native_window());
+
+    /* check for basic window sanity */
+    ASSERT_NE(nullptr, native_window);
+    EXPECT_NE(nullptr, native_window->queueBuffer);
+    EXPECT_NE(nullptr, native_window->dequeueBuffer);
+    EXPECT_NE(nullptr, native_window->query);
+    EXPECT_NE(nullptr, native_window->perform);
+}

=== added file 'tests/unit-tests/graphics/android/test_internal_client_interpreter.cpp'
--- tests/unit-tests/graphics/android/test_internal_client_interpreter.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/graphics/android/test_internal_client_interpreter.cpp	2013-05-09 21:03:25 +0000
@@ -0,0 +1,149 @@
+/*
+ * 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/server/graphics/android/internal_client_window.h"
+#include "mir_test_doubles/mock_buffer.h"
+#include "mir_test_doubles/mock_swapper.h"
+#include "mir_test_doubles/mock_interpreter_resource_cache.h"
+#include "mir/frontend/surface.h"
+
+#include <gtest/gtest.h>
+#include <stdexcept>
+
+namespace mc=mir::compositor;
+namespace mtd=mir::test::doubles;
+namespace mga=mir::graphics::android;
+namespace geom=mir::geometry;
+namespace mf=mir::frontend;
+ 
+namespace
+{
+struct MockSurface : public mf::Surface
+{
+    MOCK_METHOD0(destroy, void());
+    MOCK_METHOD0(force_requests_to_complete, void());
+    MOCK_CONST_METHOD0(size, geom::Size());
+    MOCK_CONST_METHOD0(pixel_format, geom::PixelFormat());
+
+    MOCK_METHOD0(advance_client_buffer, void());
+    MOCK_CONST_METHOD0(client_buffer, std::shared_ptr<mc::Buffer>());
+
+    MOCK_CONST_METHOD0(supports_input, bool());
+    MOCK_CONST_METHOD0(client_input_fd, int());
+    MOCK_METHOD2(configure, int(MirSurfaceAttrib, int));
+};
+
+struct InternalClientWindow : public ::testing::Test
+{
+    void SetUp()
+    {
+        using namespace testing;
+        sz = geom::Size{geom::Width{4}, geom::Height{23}};
+        pf = geom::PixelFormat::abgr_8888;
+        mock_cache = std::make_shared<mtd::MockInterpreterResourceCache>();
+        mock_surface = std::make_shared<MockSurface>();
+        mock_buffer = std::make_shared<mtd::MockBuffer>();
+        stub_anw = std::make_shared<ANativeWindowBuffer>();
+
+        ON_CALL(*mock_surface, client_buffer())
+            .WillByDefault(Return(mock_buffer));
+        ON_CALL(*mock_surface, pixel_format())
+            .WillByDefault(Return(geom::PixelFormat::abgr_8888));
+        ON_CALL(*mock_buffer, native_buffer_handle())
+            .WillByDefault(Return(stub_anw));
+    }
+
+    std::shared_ptr<ANativeWindowBuffer> stub_anw;
+    std::shared_ptr<mtd::MockInterpreterResourceCache> mock_cache;
+    std::shared_ptr<MockSurface> mock_surface;
+    std::shared_ptr<mtd::MockBuffer> mock_buffer;
+    geom::Size sz;
+    geom::PixelFormat pf;
+};
+}
+
+TEST_F(InternalClientWindow, driver_requests_buffer)
+{
+    using namespace testing;
+    EXPECT_CALL(*mock_surface, client_buffer())
+        .Times(1);
+    EXPECT_CALL(*mock_buffer, native_buffer_handle())
+        .Times(1);
+    std::shared_ptr<mc::Buffer> tmp = mock_buffer;
+    EXPECT_CALL(*mock_cache, store_buffer(tmp, stub_anw.get()))
+        .Times(1);
+
+    mga::InternalClientWindow interpreter(mock_surface, mock_cache);
+    auto test_buffer = interpreter.driver_requests_buffer();
+    EXPECT_EQ(stub_anw.get(), test_buffer); 
+}
+
+TEST_F(InternalClientWindow, driver_returns_buffer)
+{
+    using namespace testing;
+    std::shared_ptr<mga::SyncObject> fake_sync;
+
+    EXPECT_CALL(*mock_cache, retrieve_buffer(stub_anw.get()))
+        .Times(1)
+        .WillOnce(Return(mock_buffer));
+
+    mga::InternalClientWindow interpreter(mock_surface, mock_cache);
+    auto test_bufferptr = interpreter.driver_requests_buffer();
+    interpreter.driver_returns_buffer(test_bufferptr, fake_sync);
+}
+
+TEST_F(InternalClientWindow, size_test)
+{
+    using namespace testing;
+    EXPECT_CALL(*mock_surface, size())
+        .Times(2)
+        .WillOnce(Return(sz)) 
+        .WillOnce(Return(sz)); 
+    mga::InternalClientWindow interpreter(mock_surface, mock_cache);
+
+    unsigned int rc_width = interpreter.driver_requests_info(NATIVE_WINDOW_WIDTH);
+    unsigned int rc_height = interpreter.driver_requests_info(NATIVE_WINDOW_HEIGHT);
+
+    EXPECT_EQ(sz.width.as_uint32_t(), rc_width); 
+    EXPECT_EQ(sz.height.as_uint32_t(), rc_height); 
+}
+
+TEST_F(InternalClientWindow, driver_default_format)
+{
+    using namespace testing;
+    EXPECT_CALL(*mock_surface, pixel_format())
+        .Times(1);
+
+    mga::InternalClientWindow interpreter(mock_surface, mock_cache);
+
+    auto rc_format = interpreter.driver_requests_info(NATIVE_WINDOW_FORMAT);
+    EXPECT_EQ(HAL_PIXEL_FORMAT_RGBA_8888, rc_format); 
+}
+
+TEST_F(InternalClientWindow, driver_sets_format)
+{
+    using namespace testing;
+    EXPECT_CALL(*mock_surface, pixel_format())
+        .Times(AtLeast(1))
+        .WillRepeatedly(Return(geom::PixelFormat::abgr_8888));
+    mga::InternalClientWindow interpreter(mock_surface, mock_cache);
+
+    interpreter.dispatch_driver_request_format(HAL_PIXEL_FORMAT_RGBA_8888);
+    auto rc_format = interpreter.driver_requests_info(NATIVE_WINDOW_FORMAT);
+    EXPECT_EQ(HAL_PIXEL_FORMAT_RGBA_8888, rc_format); 
+}

=== added file 'tests/unit-tests/graphics/android/test_interpreter_buffer_cache.cpp'
--- tests/unit-tests/graphics/android/test_interpreter_buffer_cache.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/graphics/android/test_interpreter_buffer_cache.cpp	2013-05-09 21:03:25 +0000
@@ -0,0 +1,86 @@
+/*
+ * 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/server/graphics/android/interpreter_cache.h"
+#include "mir_test_doubles/stub_buffer.h"
+
+#include <gtest/gtest.h>
+#include <stdexcept>
+
+namespace mga=mir::graphics::android;
+namespace mtd=mir::test::doubles;
+
+struct InterpreterResourceTest : public ::testing::Test
+{
+    void SetUp()
+    {
+        stub_buffer1 = std::make_shared<mtd::StubBuffer>();
+        stub_buffer2 = std::make_shared<mtd::StubBuffer>();
+        stub_buffer3 = std::make_shared<mtd::StubBuffer>();
+        key1 = (ANativeWindowBuffer*)0x1;
+        key2 = (ANativeWindowBuffer*)0x2;
+        key3 = (ANativeWindowBuffer*)0x3;
+    }
+
+    std::shared_ptr<mtd::StubBuffer> stub_buffer1;
+    std::shared_ptr<mtd::StubBuffer> stub_buffer2;
+    std::shared_ptr<mtd::StubBuffer> stub_buffer3;
+    ANativeWindowBuffer *key1;
+    ANativeWindowBuffer *key2;
+    ANativeWindowBuffer *key3; 
+};
+
+TEST_F(InterpreterResourceTest, deposit_buffer)
+{
+    mga::InterpreterCache cache;
+    cache.store_buffer(stub_buffer1, key1);
+
+    auto test_buffer = cache.retrieve_buffer(key1);
+    EXPECT_EQ(stub_buffer1, test_buffer);
+}
+
+TEST_F(InterpreterResourceTest, deposit_many_buffers)
+{
+    mga::InterpreterCache cache;
+    cache.store_buffer(stub_buffer1, key1);
+    cache.store_buffer(stub_buffer2, key2);
+    cache.store_buffer(stub_buffer3, key3);
+
+    EXPECT_EQ(stub_buffer3, cache.retrieve_buffer(key3));
+    EXPECT_EQ(stub_buffer1, cache.retrieve_buffer(key1));
+    EXPECT_EQ(stub_buffer2, cache.retrieve_buffer(key2));
+}
+
+TEST_F(InterpreterResourceTest, deposit_buffer_has_ownership)
+{
+    mga::InterpreterCache cache;
+
+    auto use_count_before = stub_buffer1.use_count();
+    cache.store_buffer(stub_buffer1, key1);
+    EXPECT_EQ(use_count_before+1, stub_buffer1.use_count());
+    cache.retrieve_buffer(key1);
+    EXPECT_EQ(use_count_before, stub_buffer1.use_count());
+}
+
+TEST_F(InterpreterResourceTest, retreive_buffer_with_bad_key_throws)
+{
+    mga::InterpreterCache cache;
+    EXPECT_THROW({
+        cache.retrieve_buffer(key1);
+    }, std::runtime_error);
+}

=== modified file 'tests/unit-tests/graphics/android/test_server_interpreter.cpp'
--- tests/unit-tests/graphics/android/test_server_interpreter.cpp	2013-05-02 15:50:37 +0000
+++ tests/unit-tests/graphics/android/test_server_interpreter.cpp	2013-05-09 21:03:25 +0000
@@ -21,6 +21,7 @@
 
 #include "mir_test_doubles/mock_display_support_provider.h"
 #include "mir_test_doubles/mock_buffer.h"
+#include "mir_test_doubles/mock_interpreter_resource_cache.h"
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
@@ -45,7 +46,8 @@
     ~MockFBSwapper() noexcept {}
     MOCK_METHOD0(compositor_acquire, std::shared_ptr<mc::Buffer>());
     MOCK_METHOD1(compositor_release, void(std::shared_ptr<mc::Buffer> const& released_buffer));
-}; 
+};
+
 struct ServerRenderWindowTest : public ::testing::Test
 {
     virtual void SetUp()
@@ -56,6 +58,7 @@
         mock_buffer3 = std::make_shared<NiceMock<mtd::MockBuffer>>();
         mock_swapper = std::make_shared<NiceMock<MockFBSwapper>>();
         mock_display_poster = std::make_shared<NiceMock<mtd::MockDisplaySupportProvider>>();
+        mock_cache = std::make_shared<mtd::MockInterpreterResourceCache>();
         ON_CALL(*mock_display_poster, display_format())
             .WillByDefault(Return(geom::PixelFormat::abgr_8888));
         stub_sync = std::make_shared<StubFence>();
@@ -64,6 +67,7 @@
     std::shared_ptr<mtd::MockBuffer> mock_buffer1;
     std::shared_ptr<mtd::MockBuffer> mock_buffer2;
     std::shared_ptr<mtd::MockBuffer> mock_buffer3;
+    std::shared_ptr<mtd::MockInterpreterResourceCache> mock_cache;
     std::shared_ptr<MockFBSwapper> mock_swapper;
     std::shared_ptr<mtd::MockDisplaySupportProvider> mock_display_poster;
     std::shared_ptr<StubFence> stub_sync;
@@ -73,7 +77,7 @@
 TEST_F(ServerRenderWindowTest, driver_wants_a_buffer)
 {
     using namespace testing;
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster);
+    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster, mock_cache);
 
     auto stub_anw = std::make_shared<ANativeWindowBuffer>();
 
@@ -84,17 +88,22 @@
         .Times(1)
         .WillOnce(Return(stub_anw));
 
+    std::shared_ptr<mc::Buffer> tmp = mock_buffer1;
+    EXPECT_CALL(*mock_cache, store_buffer(tmp, stub_anw.get()))
+        .Times(1);
+
     auto rc_buffer = render_window.driver_requests_buffer();
-
     EXPECT_EQ(stub_anw.get(), rc_buffer);
 }
 
 TEST_F(ServerRenderWindowTest, driver_is_done_with_a_buffer_properly)
 {
     using namespace testing;
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster);
-
     auto stub_anw = std::make_shared<ANativeWindowBuffer>();
+    EXPECT_CALL(*mock_cache, retrieve_buffer(stub_anw.get()))
+        .Times(1)
+        .WillOnce(Return(mock_buffer1));
+    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster, mock_cache);
 
     EXPECT_CALL(*mock_swapper, compositor_acquire())
         .Times(1)
@@ -116,74 +125,15 @@
     testing::Mock::VerifyAndClearExpectations(mock_swapper.get());
 }
 
-/* note: in real usage, sync is enforced by the swapper class. we make use of the mock's non-blocking 
-         to do the tests. */
-TEST_F(ServerRenderWindowTest, driver_is_done_with_a_few_buffers_properly)
-{
-    using namespace testing;
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster);
-
-    auto stub_anw = std::make_shared<ANativeWindowBuffer>();
-    auto stub_anw2 = std::make_shared<ANativeWindowBuffer>();
-    auto stub_anw3 = std::make_shared<ANativeWindowBuffer>();
-
-    EXPECT_CALL(*mock_swapper, compositor_acquire())
-        .Times(3)
-        .WillOnce(Return(mock_buffer1))
-        .WillOnce(Return(mock_buffer2))
-        .WillOnce(Return(mock_buffer3));
-    EXPECT_CALL(*mock_buffer1, native_buffer_handle())
-        .Times(1)
-        .WillOnce(Return(stub_anw));
-    EXPECT_CALL(*mock_buffer2, native_buffer_handle())
-        .Times(1)
-        .WillOnce(Return(stub_anw2));
-    EXPECT_CALL(*mock_buffer3, native_buffer_handle())
-        .Times(1)
-        .WillOnce(Return(stub_anw3));
-
-    auto handle1 = render_window.driver_requests_buffer();
-    auto handle2 = render_window.driver_requests_buffer();
-    auto handle3 = render_window.driver_requests_buffer();
-    testing::Mock::VerifyAndClearExpectations(mock_swapper.get());
-
-    std::shared_ptr<mc::Buffer> buf1 = mock_buffer1;
-    std::shared_ptr<mc::Buffer> buf2 = mock_buffer2;
-    std::shared_ptr<mc::Buffer> buf3 = mock_buffer3;
-    EXPECT_CALL(*mock_swapper, compositor_release(buf1))
-        .Times(1);
-    EXPECT_CALL(*mock_swapper, compositor_release(buf2))
-        .Times(1);
-    EXPECT_CALL(*mock_swapper, compositor_release(buf3))
-        .Times(1);
-
-    render_window.driver_returns_buffer(handle1, stub_sync);
-    render_window.driver_returns_buffer(handle2, stub_sync);
-    render_window.driver_returns_buffer(handle3, stub_sync);
-    testing::Mock::VerifyAndClearExpectations(mock_swapper.get());
-}
-
-TEST_F(ServerRenderWindowTest, throw_if_driver_returns_weird_buffer)
-{
-    using namespace testing;
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster);
-
-    auto stub_anw = std::make_shared<ANativeWindowBuffer>();
-
-    EXPECT_CALL(*mock_swapper, compositor_release(_))
-        .Times(0);
-
-    EXPECT_THROW({
-        render_window.driver_returns_buffer(nullptr, stub_sync);
-    }, std::runtime_error); 
-}
-
 TEST_F(ServerRenderWindowTest, driver_returns_buffer_posts_to_fb)
 {
     using namespace testing;
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster);
+    auto stub_anw = std::make_shared<ANativeWindowBuffer>();
+    EXPECT_CALL(*mock_cache, retrieve_buffer(_))
+        .Times(1)
+        .WillOnce(Return(mock_buffer1));
+    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster, mock_cache);
 
-    auto stub_anw = std::make_shared<ANativeWindowBuffer>();
     mc::BufferID id{442}, returned_id;
     EXPECT_CALL(*mock_swapper, compositor_acquire())
         .Times(1)
@@ -209,7 +159,7 @@
         .Times(1)
         .WillOnce(Return(geom::PixelFormat::abgr_8888));
 
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster);
+    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster, mock_cache);
 
     EXPECT_EQ(HAL_PIXEL_FORMAT_RGBA_8888, render_window.driver_requests_info(NATIVE_WINDOW_FORMAT));
 }
@@ -218,7 +168,7 @@
 {
     using namespace testing;
 
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster);
+    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster, mock_cache);
     EXPECT_CALL(*mock_display_poster, display_format())
         .Times(0);
 
@@ -235,7 +185,7 @@
         .Times(4)
         .WillRepeatedly(Return(test_size));
 
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster);
+    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster, mock_cache);
 
     unsigned int rc_width = render_window.driver_requests_info(NATIVE_WINDOW_DEFAULT_WIDTH);
     unsigned int rc_height = render_window.driver_requests_info(NATIVE_WINDOW_DEFAULT_HEIGHT);
@@ -252,7 +202,7 @@
 {
     using namespace testing;
 
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster);
+    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster, mock_cache);
 
     EXPECT_EQ(0, render_window.driver_requests_info(NATIVE_WINDOW_TRANSFORM_HINT));
 }
@@ -260,7 +210,7 @@
 TEST_F(ServerRenderWindowTest, driver_unknown_inquiry)
 {
     using namespace testing;
-    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster);
+    mga::ServerRenderWindow render_window(mock_swapper, mock_display_poster, mock_cache);
 
     EXPECT_THROW({
         render_window.driver_requests_info(NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND);

=== removed directory 'tests/unit-tests/graphics/egl'
=== removed file 'tests/unit-tests/graphics/egl/CMakeLists.txt'
--- tests/unit-tests/graphics/egl/CMakeLists.txt	2013-03-27 00:11:32 +0000
+++ tests/unit-tests/graphics/egl/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-list(APPEND UNIT_TEST_SOURCES
-    ${CMAKE_CURRENT_SOURCE_DIR}/test_mirserver_mesa_egl_native_display.cpp
-)
-
-set(UNIT_TEST_SOURCES ${UNIT_TEST_SOURCES} PARENT_SCOPE)
-

=== modified file 'tests/unit-tests/graphics/gbm/CMakeLists.txt'
--- tests/unit-tests/graphics/gbm/CMakeLists.txt	2013-05-02 22:10:08 +0000
+++ tests/unit-tests/graphics/gbm/CMakeLists.txt	2013-05-09 21:03:25 +0000
@@ -5,9 +5,11 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_gbm_display.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_gbm_display_multi_monitor.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_gbm_display_configuration.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_internal_client.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_kms_output.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_kms_page_flipper.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_linux_virtual_terminal.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_internal_native_display.cpp
 )
 
 set(UNIT_TEST_SOURCES ${UNIT_TEST_SOURCES} PARENT_SCOPE)

=== added file 'tests/unit-tests/graphics/gbm/internal_client.h'
=== modified file 'tests/unit-tests/graphics/gbm/test_gbm_platform.cpp'
--- tests/unit-tests/graphics/gbm/test_gbm_platform.cpp	2013-05-02 22:10:08 +0000
+++ tests/unit-tests/graphics/gbm/test_gbm_platform.cpp	2013-05-09 21:03:25 +0000
@@ -19,7 +19,9 @@
 #include "mir/graphics/platform_ipc_package.h"
 #include "mir/graphics/drm_authenticator.h"
 #include "src/server/graphics/gbm/gbm_platform.h"
+#include "src/server/graphics/gbm/internal_client.h"
 #include "mir_test_doubles/null_virtual_terminal.h"
+#include "mir_test_doubles/stub_surface.h"
 
 #include "mir/graphics/null_display_report.h"
 
@@ -139,3 +141,21 @@
         authenticator->drm_auth_magic(magic);
     }, std::runtime_error);
 }
+
+/* TODO: this function is a bit fragile because libmirserver and libmirclient both have very different
+ *       implementations and both have symbols for it. If the linking order of the test changes,
+ *       specifically, if mir_egl_mesa_display_is_valid resolves into libmirclient, then this test will break. 
+ */
+TEST_F(GBMGraphicsPlatform, platform_provides_validation_of_display_for_internal_clients)
+{
+    auto stub_surface = std::make_shared<mtd::StubSurface>();
+    MirMesaEGLNativeDisplay* native_display = nullptr;
+    EXPECT_EQ(0, mir_server_internal_display_is_valid(native_display));
+    {
+        auto platform = create_platform();
+        auto client = platform->create_internal_client(stub_surface);
+        native_display = reinterpret_cast<MirMesaEGLNativeDisplay*>(client->egl_native_display());
+        EXPECT_EQ(1, mir_server_internal_display_is_valid(native_display));
+    }
+    EXPECT_EQ(0, mir_server_internal_display_is_valid(native_display));
+}

=== added file 'tests/unit-tests/graphics/gbm/test_internal_client.cpp'
--- tests/unit-tests/graphics/gbm/test_internal_client.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/graphics/gbm/test_internal_client.cpp	2013-05-09 21:03:25 +0000
@@ -0,0 +1,43 @@
+/*
+ * 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 "mir/frontend/surface.h"
+#include "mir_toolkit/mesa/native_display.h"
+#include "src/server/graphics/gbm/internal_client.h"
+#include "mir_test_doubles/stub_platform.h"
+#include "mir_test_doubles/stub_surface.h"
+
+#include <gtest/gtest.h>
+
+namespace geom=mir::geometry;
+namespace mc=mir::compositor;
+namespace mgg=mir::graphics::gbm;
+namespace mtd=mir::test::doubles;
+
+TEST(InternalClient, native_display)
+{
+    auto stub_window = std::make_shared<mtd::StubSurface>();
+    auto stub_display = std::make_shared<MirMesaEGLNativeDisplay>();
+    mgg::InternalClient client(stub_display, stub_window);
+
+    auto native_display = client.egl_native_display();
+    auto native_window = client.egl_native_window();
+
+    EXPECT_EQ(reinterpret_cast<EGLNativeDisplayType>(stub_display.get()), native_display);
+    EXPECT_EQ(reinterpret_cast<EGLNativeWindowType>(stub_window.get()), native_window);
+}

=== renamed file 'tests/unit-tests/graphics/egl/test_mirserver_mesa_egl_native_display.cpp' => 'tests/unit-tests/graphics/gbm/test_internal_native_display.cpp'
--- tests/unit-tests/graphics/egl/test_mirserver_mesa_egl_native_display.cpp	2013-04-23 08:17:12 +0000
+++ tests/unit-tests/graphics/gbm/test_internal_native_display.cpp	2013-05-09 21:03:25 +0000
@@ -15,7 +15,8 @@
  *
  * Authored by: Robert Carr <[e-mail]>
  */
-#include "mir/graphics/egl/mesa_native_display.h"
+
+#include "src/server/graphics/gbm/internal_native_display.h"
 #include "mir/graphics/platform.h"
 #include "mir/graphics/platform_ipc_package.h"
 #include "mir/compositor/buffer_ipc_package.h"
@@ -31,7 +32,7 @@
 #include <gmock/gmock.h>
 
 namespace mg = mir::graphics;
-namespace mgeglm = mg::egl::mesa;
+namespace mgg = mir::graphics::gbm;
 namespace mc = mir::compositor;
 namespace msh = mir::shell;
 namespace geom = mir::geometry;
@@ -40,55 +41,44 @@
 
 namespace
 {
-
-struct MockGraphicsPlatform : public mg::Platform
-{
-    MOCK_METHOD1(create_buffer_allocator, std::shared_ptr<mc::GraphicBufferAllocator>(std::shared_ptr<mg::BufferInitializer> const&));
-    MOCK_METHOD0(create_display, std::shared_ptr<mg::Display>());
-    MOCK_METHOD0(get_ipc_package, std::shared_ptr<mg::PlatformIPCPackage>());
-    MOCK_METHOD0(shell_egl_display, EGLNativeDisplayType());
-};
-
-struct MirServerMesaEGLNativeDisplaySetup : public testing::Test
-{
-    MirServerMesaEGLNativeDisplaySetup()
+struct InternalNativeDisplay : public testing::Test
+{
+    InternalNativeDisplay()
+    {
+    }
+
+    void SetUp()
     {
         using namespace ::testing;
 
-        test_platform_package.ipc_data = {1, 2};
-        test_platform_package.ipc_fds = {2, 3};
-        
-        ON_CALL(mock_graphics_platform, get_ipc_package())
-            .WillByDefault(Return(mt::fake_shared(test_platform_package)));
+        platform_package = std::make_shared<mg::PlatformIPCPackage>();
+        platform_package->ipc_data = {1, 2};
+        platform_package->ipc_fds = {2, 3};
     }
 
-    // Test dependencies
-    MockGraphicsPlatform mock_graphics_platform;
-
-    // Useful stub data
-    mg::PlatformIPCPackage test_platform_package;
+    std::shared_ptr<mg::PlatformIPCPackage> platform_package;
 };
 
 MATCHER_P(PackageMatches, package, "")
 {
-    if (arg.data_items != static_cast<int>(package.ipc_data.size()))
+    if (arg.data_items != static_cast<int>(package->ipc_data.size()))
         return false;
-    for (uint i = 0; i < package.ipc_data.size(); i++)
+    for (uint i = 0; i < package->ipc_data.size(); i++)
     {
-        if (arg.data[i] != package.ipc_data[i]) return false;
+        if (arg.data[i] != package->ipc_data[i]) return false;
     }
-    if (arg.fd_items != static_cast<int>(package.ipc_fds.size()))
+    if (arg.fd_items != static_cast<int>(package->ipc_fds.size()))
         return false;
-    for (uint i = 0; i < package.ipc_fds.size(); i++)
+    for (uint i = 0; i < package->ipc_fds.size(); i++)
     {
-        if (arg.fd[i] != package.ipc_fds[i]) return false;
+        if (arg.fd[i] != package->ipc_fds[i]) return false;
     }
     return true;
 }
 
 MATCHER_P(StrideMatches, package, "")
 {
-    if (arg.stride != package.stride)
+    if (arg.stride != package->stride)
     {
         return false;
     }
@@ -103,83 +93,62 @@
         return false;
     return true;
 }
-
 }
 
-TEST_F(MirServerMesaEGLNativeDisplaySetup, display_get_platform_is_cached_platform_package)
+TEST_F(InternalNativeDisplay, display_get_platform_matches_construction_platform)
 {
     using namespace ::testing;
     
-    EXPECT_CALL(mock_graphics_platform, get_ipc_package()).Times(1);
-
-    auto display = mgeglm::create_native_display(mt::fake_shared(mock_graphics_platform));
-    
-    MirPlatformPackage package;
-    memset(&package, 0, sizeof(MirPlatformPackage));
-    display->display_get_platform(display.get(), &package);
-    EXPECT_THAT(package, PackageMatches(test_platform_package));
-
-    MirPlatformPackage requeried_package;
-    // The package is cached to allow the package creator to control lifespan of fd members
-    // and so this should not trigger another call to get_ipc_package()
-    display->display_get_platform(display.get(), &requeried_package);
-    
-    EXPECT_FALSE(memcmp(&requeried_package.data, &package.data, sizeof(package.data[0])*package.data_items));
-    EXPECT_FALSE(memcmp(&requeried_package.fd, &package.fd, sizeof(package.fd[0])*package.fd_items));
+    mgg::InternalNativeDisplay native_display(platform_package); 
+    
+    MirPlatformPackage test_package;
+    memset(&test_package, 0, sizeof(MirPlatformPackage));
+    native_display.display_get_platform(&native_display, &test_package);
+    EXPECT_THAT(test_package, PackageMatches(platform_package));
 }
 
-TEST_F(MirServerMesaEGLNativeDisplaySetup, surface_get_current_buffer)
+TEST_F(InternalNativeDisplay, surface_get_current_buffer)
 {
     using namespace ::testing;
     
     mtd::MockSurface surface(std::make_shared<mtd::StubSurfaceBuilder>());
     auto buffer = std::make_shared<mtd::MockBuffer>(geom::Size(), geom::Stride(), geom::PixelFormat());
     
-    mc::BufferIPCPackage test_buffer_package;
+    auto test_buffer_package = std::make_shared<mc::BufferIPCPackage>();
     
-    test_buffer_package.ipc_data = {1, 2};
-    test_buffer_package.ipc_fds = {2, 3};
-    test_buffer_package.stride = 77;
+    test_buffer_package->ipc_data = {1, 2};
+    test_buffer_package->ipc_fds = {2, 3};
+    test_buffer_package->stride = 77;
 
-    auto display = mgeglm::create_native_display(mt::fake_shared(mock_graphics_platform));
+    mgg::InternalNativeDisplay native_display(platform_package); 
     
     EXPECT_CALL(surface, client_buffer()).Times(1)
         .WillOnce(Return(buffer));
     EXPECT_CALL(*buffer, get_ipc_package()).Times(1)
-        .WillOnce(Return(mt::fake_shared(test_buffer_package)));
+        .WillOnce(Return(test_buffer_package));
     
     MirBufferPackage buffer_package;
     memset(&buffer_package, 0, sizeof(MirBufferPackage));
-    display->surface_get_current_buffer(
-        display.get(), static_cast<MirEGLNativeWindowType>(&surface), &buffer_package);
+    native_display.surface_get_current_buffer(
+        &native_display, static_cast<MirEGLNativeWindowType>(&surface), &buffer_package);
     EXPECT_THAT(buffer_package, AllOf(PackageMatches(test_buffer_package), StrideMatches(test_buffer_package)));
 }
 
-TEST_F(MirServerMesaEGLNativeDisplaySetup, surface_advance_buffer)
+TEST_F(InternalNativeDisplay, surface_advance_buffer)
 {
     using namespace ::testing;
     
     mtd::MockSurface surface(std::make_shared<mtd::StubSurfaceBuilder>());
     
-    auto display = mgeglm::create_native_display(mt::fake_shared(mock_graphics_platform));
+    mgg::InternalNativeDisplay native_display(platform_package); 
     
     EXPECT_CALL(surface, advance_client_buffer()).Times(1);
     
-    display->surface_advance_buffer(
-        display.get(), static_cast<MirEGLNativeWindowType>(&surface));
-}
-
-TEST(MirServerMesaEGLNativeDisplayInvariants, pixel_format_formats_are_castable)
-{
-    EXPECT_EQ(static_cast<MirPixelFormat>(geom::PixelFormat::invalid), mir_pixel_format_invalid);
-    EXPECT_EQ(static_cast<MirPixelFormat>(geom::PixelFormat::abgr_8888), mir_pixel_format_abgr_8888);
-    EXPECT_EQ(static_cast<MirPixelFormat>(geom::PixelFormat::xbgr_8888), mir_pixel_format_xbgr_8888);
-    EXPECT_EQ(static_cast<MirPixelFormat>(geom::PixelFormat::argb_8888), mir_pixel_format_argb_8888);
-    EXPECT_EQ(static_cast<MirPixelFormat>(geom::PixelFormat::xrgb_8888), mir_pixel_format_xrgb_8888);
-    EXPECT_EQ(static_cast<MirPixelFormat>(geom::PixelFormat::bgr_888), mir_pixel_format_bgr_888);
-}
-
-TEST_F(MirServerMesaEGLNativeDisplaySetup, surface_get_parameters)
+    native_display.surface_advance_buffer(
+        &native_display, static_cast<MirEGLNativeWindowType>(&surface));
+}
+
+TEST_F(InternalNativeDisplay, surface_get_parameters)
 {
     using namespace ::testing;
     
@@ -187,7 +156,7 @@
                                                     geom::Height{29}};
     geom::PixelFormat const test_pixel_format = geom::PixelFormat::xrgb_8888;
 
-    auto display = mgeglm::create_native_display(mt::fake_shared(mock_graphics_platform));
+    mgg::InternalNativeDisplay native_display(platform_package); 
 
     mtd::MockSurface surface(std::make_shared<mtd::StubSurfaceBuilder>());
     EXPECT_CALL(surface, size()).Times(AtLeast(1)).WillRepeatedly(Return(test_surface_size));
@@ -195,8 +164,8 @@
     
     MirSurfaceParameters parameters;
     memset(&parameters, 0, sizeof(MirSurfaceParameters));
-    display->surface_get_parameters(
-        display.get(), static_cast<MirEGLNativeWindowType>(&surface), &parameters);
+    native_display.surface_get_parameters(
+        &native_display, static_cast<MirEGLNativeWindowType>(&surface), &parameters);
 
     EXPECT_THAT(parameters, ParametersHaveSize(test_surface_size));
     EXPECT_EQ(parameters.pixel_format, static_cast<MirPixelFormat>(geom::PixelFormat::xrgb_8888));
@@ -204,3 +173,13 @@
     // TODO: What to do about buffer usage besides hardware? ~racarr
     EXPECT_EQ(parameters.buffer_usage, mir_buffer_usage_hardware);
 }
+
+TEST(MirServerMesaEGLNativeDisplayInvariants, pixel_format_formats_are_castable)
+{
+    EXPECT_EQ(static_cast<MirPixelFormat>(geom::PixelFormat::invalid), mir_pixel_format_invalid);
+    EXPECT_EQ(static_cast<MirPixelFormat>(geom::PixelFormat::abgr_8888), mir_pixel_format_abgr_8888);
+    EXPECT_EQ(static_cast<MirPixelFormat>(geom::PixelFormat::xbgr_8888), mir_pixel_format_xbgr_8888);
+    EXPECT_EQ(static_cast<MirPixelFormat>(geom::PixelFormat::argb_8888), mir_pixel_format_argb_8888);
+    EXPECT_EQ(static_cast<MirPixelFormat>(geom::PixelFormat::xrgb_8888), mir_pixel_format_xrgb_8888);
+    EXPECT_EQ(static_cast<MirPixelFormat>(geom::PixelFormat::bgr_888), mir_pixel_format_bgr_888);
+}