Merge lp:~mir-team/mir/trunk-0.1.9 into lp:mir/ubuntu

[kevin gunn]

New upstream Mir release 0.1.9 (development branch r1573)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1574
http://jenkins.qa.ubuntu.com/job/mir-ci/1659/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/1716
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/1714
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/57
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/57/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/57
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/57/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

Verified the branch contents are as advertised. Just tag v0.1.9 plus changelog updates.

I think it would be a better idea to wait for 0.1.10/0.2.0 where we will have landed fixes for all the regressions [1] that 0.1.9 introduces. But that's a calculated risk for other people to decide.

[1] https://launchpad.net/mir/+milestone/0.1.10

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1575
http://jenkins.qa.ubuntu.com/job/mir-ci/1660/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/1766
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/1764
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/58
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/58/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/58
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/58/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1576
http://jenkins.qa.ubuntu.com/job/mir-ci/1662/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/1775
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/1773
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/60
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/60/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/60
        deb: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/60/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

review: Approve

[Daniel van Vugt (vanvugt)]

What!?

Released in Ubuntu: https://launchpad.net/ubuntu/+source/mir
But not landed in lp:mir - https://code.launchpad.net/~mir-team/mir/utopic

What branch is utopic packaging from?

review: Needs Information

[Daniel van Vugt (vanvugt)]

OK, so either lp:mir was meant to be used and this should be landed already, or it's not being used any more and no one will care if it does land. So land it...

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-03-26 05:48:59 +0000
+++ CMakeLists.txt	2014-04-30 13:15:30 +0000
@@ -28,7 +28,7 @@
 
 set(MIR_VERSION_MAJOR 0)
 set(MIR_VERSION_MINOR 1)
-set(MIR_VERSION_PATCH 8)
+set(MIR_VERSION_PATCH 9)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 execute_process(
@@ -152,14 +152,6 @@
 add_subdirectory(src/)
 include_directories(${MIR_GENERATED_INCLUDE_DIRECTORIES})
 
-set (OLD_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-# Don't treat warnings as errors in 3rd_party/{gmock}
-string (REPLACE " -Werror " " " CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-
-
-# Restore -Werror for non-3rd-party code
-set (CMAKE_CXX_FLAGS ${OLD_CMAKE_CXX_FLAGS})
-
 option(MIR_ENABLE_TESTS "Build tests" ON)
 
 if (MIR_ENABLE_TESTS)

=== modified file 'cmake/FindGtest.cmake'
--- cmake/FindGtest.cmake	2013-07-11 18:36:11 +0000
+++ cmake/FindGtest.cmake	2014-04-30 13:15:30 +0000
@@ -21,7 +21,7 @@
 set(GTEST_BINARY_DIR ${GMOCK_BINARY_DIR}/gtest)
 
 set(GTEST_CMAKE_ARGS "")
-if (${MIR_IS_CROSS_COMPILING})
+if (${CMAKE_CROSSCOMPILING})
     set(GTEST_CMAKE_ARGS
         -DCMAKE_TOOLCHAIN_FILE=${CMAKE_MODULE_PATH}/LinuxCrossCompile.cmake)
 endif()

=== modified file 'cmake/LinuxCrossCompile.cmake'
--- cmake/LinuxCrossCompile.cmake	2014-03-06 06:05:17 +0000
+++ cmake/LinuxCrossCompile.cmake	2014-04-30 13:15:30 +0000
@@ -1,7 +1,6 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(CMAKE_SYSTEM_VERSION 1)
 
-set(MIR_IS_CROSS_COMPILING TRUE CACHE STRING "build is a cross compile")
 set(MIR_NDK_PATH $ENV{MIR_NDK_PATH} CACHE STRING "path of mir android bundle")
 set(MIR_ARM_EABI "arm-linux-gnueabihf")
 

=== modified file 'cmake/MirCommon.cmake'
--- cmake/MirCommon.cmake	2014-03-26 05:48:59 +0000
+++ cmake/MirCommon.cmake	2014-04-30 13:15:30 +0000
@@ -7,7 +7,7 @@
   DISABLE_GTEST_TEST_DISCOVERY
   "If set to ON, disables fancy test autodiscovery and switches back to classic add_test behavior"
   OFF
-  "NOT MIR_IS_CROSS_COMPILING"
+  "NOT CMAKE_CROSSCOMPILING"
   ON)
 
 option(

=== modified file 'debian/changelog'
--- debian/changelog	2014-04-11 21:03:54 +0000
+++ debian/changelog	2014-04-30 13:15:30 +0000
@@ -1,3 +1,48 @@
+mir (0.1.9-0ubuntu1) UNRELEASED; urgency=medium
+
+  * New upstream release 0.1.9 (https://launchpad.net/mir/+milestone/0.1.9)
+    - mirclient ABI unchanged, still at 7. Clients do not need rebuilding.
+    - mirserver ABI bumped to 19. Shells need rebuilding.
+    - More libmirserver class changes and reorganization, including;
+      . Moving things from shell:: to scene::
+      . Rewriting/refactoring surface factories.
+    - Added an id() to Renderable.
+    - Scene/Renderer interfaces:
+      . Scene is no longer responsible for its own iteration (no for_each
+        any more). Instead you should iterate over the list returned by
+        Scene::generate_renderable_list().
+    - Bugs fixed:
+      . Stale socket issue. (LP: #1285215)
+      . Qt render gets blocked on EGLSwapBuffers. (LP: #1292306)
+      . Lock order violated found in helgrind (potential deadlock). 
+        (LP: #1296544)
+      . [regression] SwitchingBundle in framedropping mode can hang. 
+        (LP: #1306464)
+      . [DPMS] Display backlight turns back on almost immediately after
+        being turned off. (LP: #1231857)
+      . Wrong frame is seen on wake up/resume/unlock. (LP: #1233564)
+      . Nested platform is not testable (LP: #1299101)
+      . [regression] mir_demo_server_shell crashes on display resume. 
+        (LP: #1308941)
+      . Multi-threaded composition is actually mostly serialized by
+        SurfaceStack::guard. (LP: #1234018)
+      . Mirscreencast slows down compositing and makes it very jerky. 
+        (LP: #1280938)
+      . Mirscreencast can cause clients to render faster than the screen
+        refresh rate. (LP: #1294361)
+      . Screen turns on when a new session/surface appears. (LP: #1297876)
+      . mir-doc package is >56MB in size, expands to >100MB of files. 
+        (LP: #1304998)
+      . [regression] Clang: 'mir::test::doubles::MockSurface::visible'
+        hides overloaded virtual function [-Woverloaded-virtual]. 
+        (LP: #1301135)
+      . [regression] GLRenderer* unit tests have recently become noisy. 
+        (LP: #1308905)
+      . FocusController::set_focus_to() no longer seems to raise a session
+        to the top. (LP: #1302689)
+
+ -- Daniel van Vugt <[e-mail]>  Tue, 15 Apr 2014 13:35:04 +0800
+
 mir (0.1.8+14.04.20140411-0ubuntu1) trusty; urgency=medium
 
   [ Daniel van Vugt ]

=== modified file 'debian/control'
--- debian/control	2014-03-26 17:06:10 +0000
+++ debian/control	2014-04-30 13:15:30 +0000
@@ -70,7 +70,7 @@
  .
  Contains the protocol's definition files.
 
-Package: libmirserver18
+Package: libmirserver19
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
@@ -148,7 +148,7 @@
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmirserver18 (= ${binary:Version}),
+Depends: libmirserver19 (= ${binary:Version}),
          libmirprotobuf-dev (= ${binary:Version}),
          mircommon-dev (= ${binary:Version}),
          libglm-dev,

=== modified file 'debian/create_postinst_prerm_scripts.sh'
--- debian/create_postinst_prerm_scripts.sh	2014-02-14 09:20:28 +0000
+++ debian/create_postinst_prerm_scripts.sh	2014-04-30 13:15:30 +0000
@@ -2,10 +2,19 @@
 
 set -e
 
+dpkg_alternatives_priority=500
+deb_host_arch=$1
+deb_host_multiarch=$2
+
 mir_platform_types="platformgraphics clientplatform"
-mir_platforms="android mesa"
-dpkg_alternatives_priority=500
-deb_host_multiarch=$1
+case $deb_host_arch in
+    arm64)
+        mir_platforms="mesa"
+        ;;
+    *)
+        mir_platforms="android mesa"
+        ;;
+esac
 
 create_script()
 {

=== modified file 'debian/install_ld_so_conf.sh'
--- debian/install_ld_so_conf.sh	2014-02-14 09:20:28 +0000
+++ debian/install_ld_so_conf.sh	2014-04-30 13:15:30 +0000
@@ -2,10 +2,18 @@
 
 set -e
 
+DEB_HOST_ARCH=$1
+DEB_HOST_MULTIARCH=$2
+
 mir_platform_types="platformgraphics clientplatform"
-mir_platforms="android mesa"
-
-DEB_HOST_MULTIARCH=$1
+case $DEB_HOST_ARCH in
+    arm64)
+        mir_platforms="mesa"
+        ;;
+    *)
+        mir_platforms="android mesa"
+        ;;
+esac
 
 for platform_type in $mir_platform_types;
 do

=== renamed file 'debian/libmirserver18.install' => 'debian/libmirserver19.install'
--- debian/libmirserver18.install	2014-03-25 06:34:39 +0000
+++ debian/libmirserver19.install	2014-04-30 13:15:30 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirserver.so.18
+usr/lib/*/libmirserver.so.19

=== modified file 'debian/rules'
--- debian/rules	2014-03-26 05:48:59 +0000
+++ debian/rules	2014-04-30 13:15:30 +0000
@@ -44,8 +44,9 @@
 	dh_install --fail-missing \
 	  -Xusr/lib/$(DEB_HOST_MULTIARCH)/libmirplatformgraphics.so \
 	  -Xusr/lib/$(DEB_HOST_MULTIARCH)/libmirclientplatform.so
-	sh debian/install_ld_so_conf.sh $(DEB_HOST_MULTIARCH)
+	sh debian/install_ld_so_conf.sh $(DEB_HOST_ARCH) $(DEB_HOST_MULTIARCH)
 
 override_dh_installdeb:
-	sh debian/create_postinst_prerm_scripts.sh $(DEB_HOST_MULTIARCH)
+	sh debian/create_postinst_prerm_scripts.sh \
+	  $(DEB_HOST_ARCH) $(DEB_HOST_MULTIARCH)
 	dh_installdeb

=== modified file 'doc/Doxyfile.in'
--- doc/Doxyfile.in	2014-03-06 06:05:17 +0000
+++ doc/Doxyfile.in	2014-04-30 13:15:30 +0000
@@ -118,7 +118,7 @@
 # Doxygen will generate a detailed section even if there is only a brief
 # description.
 
-ALWAYS_DETAILED_SEC    = YES
+ALWAYS_DETAILED_SEC    = NO
 
 # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
 # inherited members of a class in the documentation of that class as if those
@@ -382,7 +382,7 @@
 # defined locally in source files will be included in the documentation.
 # If set to NO only classes defined in header files are included.
 
-EXTRACT_LOCAL_CLASSES  = YES
+EXTRACT_LOCAL_CLASSES  = NO
 
 # This flag is only useful for Objective-C code. When set to YES local
 # methods, which are defined in the implementation section but not in
@@ -748,7 +748,7 @@
 # against the file with absolute path, so to exclude all test directories
 # for example use the pattern */test/*
 
-EXCLUDE_PATTERNS       = */include/mir_test*
+EXCLUDE_PATTERNS       = */include/test/* */3rd_party/*
 
 # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
 # (namespaces, classes, functions, etc.) that should be excluded from the
@@ -1866,7 +1866,7 @@
 # HTML_FILE_EXTENSION to xhtml in order to make the SVG files
 # visible in IE 9+ (other browsers do not have this requirement).
 
-DOT_IMAGE_FORMAT       = png
+DOT_IMAGE_FORMAT       = svg
 
 # If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
 # enable generation of interactive SVG images that allow zooming and panning.

=== modified file 'examples/CMakeLists.txt'
--- examples/CMakeLists.txt	2014-03-26 05:48:59 +0000
+++ examples/CMakeLists.txt	2014-04-30 13:15:30 +0000
@@ -24,6 +24,12 @@
 target_link_libraries(mir_demo_client_egltriangle
   eglapp
 )
+add_executable(mir_demo_client_eglcounter
+  eglcounter.cpp
+)
+target_link_libraries(mir_demo_client_eglcounter
+  eglapp
+)
 add_executable(mir_demo_client_eglplasma
   eglplasma.c
 )

=== modified file 'examples/demo-inprocess-surface-client/inprocess_egl_client.cpp'
--- examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2014-03-12 02:46:58 +0000
+++ examples/demo-inprocess-surface-client/inprocess_egl_client.cpp	2014-04-30 13:15:30 +0000
@@ -22,8 +22,8 @@
 #include "mir/main_loop.h"
 #include "mir/shell/focus_controller.h"
 #include "mir/frontend/surface.h"
-#include "mir/shell/surface_creation_parameters.h"
-#include "mir/shell/session.h"
+#include "mir/scene/surface_creation_parameters.h"
+#include "mir/scene/session.h"
 #include "mir/frontend/session.h"
 #include "mir/frontend/shell.h"
 #include "mir/geometry/size.h"
@@ -49,6 +49,7 @@
 #include <signal.h>
 
 namespace mf = mir::frontend;
+namespace ms = mir::scene;
 namespace msh = mir::shell;
 namespace mg = mir::graphics;
 namespace me = mir::examples;
@@ -91,7 +92,7 @@
     geom::Size const surface_size{512, 512};
 
     ///\internal [setup_tag]
-    auto params = msh::a_surface().of_name("Inprocess EGL Demo")
+    auto params = ms::a_surface().of_name("Inprocess EGL Demo")
         .of_size(surface_size)
         .of_buffer_usage(mg::BufferUsage::hardware)
         .of_pixel_format(mir_pixel_format_argb_8888);

=== modified file 'examples/demo-shell/demo_renderer.cpp'
--- examples/demo-shell/demo_renderer.cpp	2014-03-27 04:50:19 +0000
+++ examples/demo-shell/demo_renderer.cpp	2014-04-30 13:15:30 +0000
@@ -26,6 +26,11 @@
 namespace
 {
 
+struct Color
+{
+     GLubyte r, g, b, a;
+};
+
 float penumbra_curve(float x)
 {
     return 1.0f - std::sin(x * M_PI / 2.0f);
@@ -69,26 +74,23 @@
     return corner;
 }
 
-GLuint generate_frame_corner_texture()
+GLuint generate_frame_corner_texture(float corner_radius,
+                                     Color const& color,
+                                     GLubyte highlight)
 {
-    struct Texel
-    {
-        GLubyte r, g, b, a;
-    };
-
-    int const width = 256;
-    Texel image[width][width];
-
-    int cx = width / 2;
-    int cy = width / 2;
-    int radius_sqr = cx * cx;
-
-    for (int y = 0; y < width; ++y)
+    int const height = 256;
+    int const width = height * corner_radius;
+    Color image[height * height]; // Worst case still much faster than the heap
+
+    int const cx = width;
+    int const cy = cx;
+    int const radius_sqr = cx * cy;
+
+    for (int y = 0; y < height; ++y)
     {
         for (int x = 0; x < width; ++x)
         {
-            GLubyte lum = 128;
-            GLubyte alpha = 255;
+            Color col = color;
 
             // Cut out the corner in a circular shape.
             if (x < cx && y < cy)
@@ -96,20 +98,21 @@
                 int dx = cx - x;
                 int dy = cy - y;
                 if (dx * dx + dy * dy >= radius_sqr)
-                    alpha = 0;
+                    col.a = 0;
             }
 
             // Set gradient
             if (y < cy)
             {
-                float brighten = (1.0f - (static_cast<float>(y) / cy));
-                if (x < cx)
-                    brighten *= std::sin(x * M_PI / width);
+                float brighten = (1.0f - (static_cast<float>(y) / cy)) *
+                                 std::sin(x * M_PI / (2 * (width - 1)));
 
-                lum += (255 - lum) * brighten;
+                col.r += (highlight - col.r) * brighten;
+                col.g += (highlight - col.g) * brighten;
+                col.b += (highlight - col.b) * brighten;
             }
 
-            image[y][x] = {lum, lum, lum, alpha};
+            image[y * width + x] = col;
         }
     }
 
@@ -122,7 +125,7 @@
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
-                 width, width, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                 width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                  image);
     glGenerateMipmap(GL_TEXTURE_2D); // Antialiasing please
 
@@ -131,11 +134,16 @@
 
 } // namespace
 
-DemoRenderer::DemoRenderer(geometry::Rectangle const& display_area)
-    : GLRenderer(display_area)
+DemoRenderer::DemoRenderer(
+    graphics::GLProgramFactory const& program_factory,
+    geometry::Rectangle const& display_area)
+    : GLRenderer(program_factory, display_area)
+    , corner_radius(0.5f)
 {
     shadow_corner_tex = generate_shadow_corner_texture(0.4f);
-    titlebar_corner_tex = generate_frame_corner_texture();
+    titlebar_corner_tex = generate_frame_corner_texture(corner_radius,
+                                                        {128,128,128,255},
+                                                        255);
 }
 
 DemoRenderer::~DemoRenderer()
@@ -267,8 +275,9 @@
     primitives.resize(n + 3);
 
     GLfloat htop = top - titlebar_height;
-    GLfloat inleft = left + titlebar_height;  // Square proportions for corners
-    GLfloat inright = right - titlebar_height;
+    GLfloat in = titlebar_height * corner_radius;
+    GLfloat inleft = left + in;
+    GLfloat inright = right - in;
 
     GLfloat mid = (left + right) / 2.0f;
     if (inleft > mid) inleft = mid;

=== modified file 'examples/demo-shell/demo_renderer.h'
--- examples/demo-shell/demo_renderer.h	2014-03-27 04:50:19 +0000
+++ examples/demo-shell/demo_renderer.h	2014-04-30 13:15:30 +0000
@@ -29,7 +29,7 @@
 class DemoRenderer : public compositor::GLRenderer
 {
 public:
-    DemoRenderer(geometry::Rectangle const& display_area);
+    DemoRenderer(graphics::GLProgramFactory const& factory, geometry::Rectangle const& display_area);
     ~DemoRenderer();
 
     void begin() const override;
@@ -44,6 +44,7 @@
                     float titlebar_height) const;
 
 private:
+    float const corner_radius;
     GLuint shadow_corner_tex;
     GLuint titlebar_corner_tex;
 };

=== modified file 'examples/demo-shell/demo_shell.cpp'
--- examples/demo-shell/demo_shell.cpp	2014-03-06 06:05:17 +0000
+++ examples/demo-shell/demo_shell.cpp	2014-04-30 13:15:30 +0000
@@ -33,7 +33,7 @@
 #include <iostream>
 
 namespace me = mir::examples;
-namespace msh = mir::shell;
+namespace ms = mir::scene;
 namespace mg = mir::graphics;
 namespace mf = mir::frontend;
 namespace mi = mir::input;
@@ -47,11 +47,18 @@
 class DemoRendererFactory : public compositor::RendererFactory
 {
 public:
+    DemoRendererFactory(std::shared_ptr<graphics::GLProgramFactory> const& gl_program_factory) :
+        gl_program_factory(gl_program_factory)
+    {
+    }
+
     std::unique_ptr<compositor::Renderer> create_renderer_for(
         geometry::Rectangle const& rect) override
     {
-        return std::unique_ptr<compositor::Renderer>(new DemoRenderer(rect));
+        return std::unique_ptr<compositor::Renderer>(new DemoRenderer(*gl_program_factory, rect));
     }
+private:
+    std::shared_ptr<graphics::GLProgramFactory> const gl_program_factory;
 };
 
 class DemoServerConfiguration : public mir::examples::ServerConfiguration
@@ -74,15 +81,15 @@
     {
     }
 
-    std::shared_ptr<msh::PlacementStrategy> the_shell_placement_strategy() override
+    std::shared_ptr<ms::PlacementStrategy> the_placement_strategy() override
     {
         return shell_placement_strategy(
-            [this]() -> std::shared_ptr<msh::PlacementStrategy>
+            [this]() -> std::shared_ptr<ms::PlacementStrategy>
             {
                 if (the_options()->is_set("fullscreen-surfaces"))
                     return std::make_shared<me::FullscreenPlacementStrategy>(the_shell_display_layout());
                 else
-                    return DefaultServerConfiguration::the_shell_placement_strategy();
+                    return DefaultServerConfiguration::the_placement_strategy();
             });
     }
 
@@ -97,7 +104,7 @@
 
     std::shared_ptr<compositor::RendererFactory> the_renderer_factory() override
     {
-        return std::make_shared<DemoRendererFactory>();
+        return std::make_shared<DemoRendererFactory>(the_gl_program_factory());
     }
 
 private:

=== modified file 'examples/demo-shell/fullscreen_placement_strategy.cpp'
--- examples/demo-shell/fullscreen_placement_strategy.cpp	2013-08-28 03:41:48 +0000
+++ examples/demo-shell/fullscreen_placement_strategy.cpp	2014-04-30 13:15:30 +0000
@@ -18,11 +18,12 @@
 
 #include "fullscreen_placement_strategy.h"
 
-#include "mir/shell/surface_creation_parameters.h"
+#include "mir/scene/surface_creation_parameters.h"
 #include "mir/shell/display_layout.h"
 #include "mir/geometry/rectangle.h"
 
 namespace me = mir::examples;
+namespace ms = mir::scene;
 namespace msh = mir::shell;
 
 me::FullscreenPlacementStrategy::FullscreenPlacementStrategy(
@@ -31,8 +32,8 @@
 {
 }
 
-msh::SurfaceCreationParameters me::FullscreenPlacementStrategy::place(msh::Session const& /* session */,
-    msh::SurfaceCreationParameters const& request_parameters)
+ms::SurfaceCreationParameters me::FullscreenPlacementStrategy::place(ms::Session const& /* session */,
+    ms::SurfaceCreationParameters const& request_parameters)
 {
     auto placed_parameters = request_parameters;
 

=== modified file 'examples/demo-shell/fullscreen_placement_strategy.h'
--- examples/demo-shell/fullscreen_placement_strategy.h	2013-08-28 03:41:48 +0000
+++ examples/demo-shell/fullscreen_placement_strategy.h	2014-04-30 13:15:30 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_EXAMPLES_FULLSCREEN_PLACEMENT_STRATEGY_H_
 #define MIR_EXAMPLES_FULLSCREEN_PLACEMENT_STRATEGY_H_
 
-#include "mir/shell/placement_strategy.h"
+#include "mir/scene/placement_strategy.h"
 
 #include <memory>
 
@@ -32,13 +32,13 @@
 namespace examples
 {
 
-class FullscreenPlacementStrategy : public shell::PlacementStrategy
+class FullscreenPlacementStrategy : public scene::PlacementStrategy
 {
 public:
     FullscreenPlacementStrategy(std::shared_ptr<shell::DisplayLayout> const& display_layout);
     ~FullscreenPlacementStrategy() = default;
     
-    shell::SurfaceCreationParameters place(shell::Session const&, shell::SurfaceCreationParameters const& request_parameters);
+    scene::SurfaceCreationParameters place(scene::Session const&, scene::SurfaceCreationParameters const& request_parameters);
 
 protected:
     FullscreenPlacementStrategy(FullscreenPlacementStrategy const&) = delete;

=== modified file 'examples/demo-shell/window_manager.cpp'
--- examples/demo-shell/window_manager.cpp	2014-03-26 05:48:59 +0000
+++ examples/demo-shell/window_manager.cpp	2014-04-30 13:15:30 +0000
@@ -20,8 +20,8 @@
 #include "window_manager.h"
 
 #include "mir/shell/focus_controller.h"
-#include "mir/shell/session.h"
-#include "mir/shell/surface.h"
+#include "mir/scene/session.h"
+#include "mir/scene/surface.h"
 #include "mir/graphics/display.h"
 #include "mir/graphics/display_configuration.h"
 #include "mir/compositor/compositor.h"
@@ -195,8 +195,7 @@
         // FIXME: https://bugs.launchpad.net/mir/+bug/1197108
         MirMotionAction action = static_cast<MirMotionAction>(event.motion.action & ~0xff00);
 
-        std::shared_ptr<msh::Session> app =
-            focus_controller->focussed_application().lock();
+        auto const app = focus_controller->focussed_application().lock();
 
         int fingers = static_cast<int>(event.motion.pointer_count);
 
@@ -207,7 +206,7 @@
         {
             // FIXME: We need to be able to select individual surfaces in
             //        future and not just the "default" one.
-            std::shared_ptr<msh::Surface> surf = app->default_surface();
+            auto const surf = app->default_surface();
 
             if (surf &&
                 (event.motion.modifiers & mir_key_modifier_alt ||

=== added file 'examples/eglcounter.cpp'
--- examples/eglcounter.cpp	1970-01-01 00:00:00 +0000
+++ examples/eglcounter.cpp	2014-04-30 13:15:30 +0000
@@ -0,0 +1,281 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Daniel van Vugt <[e-mail]>
+ *         Alberto Aguirre <[e-mail]>
+ */
+
+#include "eglapp.h"
+#include <assert.h>
+#include <stdio.h>
+#include <GLES2/gl2.h>
+
+#include <vector>
+#include <stdexcept>
+#include <iostream>
+
+static GLuint load_shader(const char *src, GLenum type)
+{
+    GLuint shader = glCreateShader(type);
+    if (shader)
+    {
+        GLint compiled;
+        glShaderSource(shader, 1, &src, NULL);
+        glCompileShader(shader);
+        glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+        if (!compiled)
+        {
+            GLchar log[1024];
+            glGetShaderInfoLog(shader, sizeof log - 1, NULL, log);
+            log[sizeof log - 1] = '\0';
+            printf("load_shader compile failed: %s\n", log);
+            glDeleteShader(shader);
+            shader = 0;
+        }
+    }
+    return shader;
+}
+
+class DrawableDigit
+{
+public:
+    DrawableDigit(std::initializer_list<std::vector<GLubyte>> list)
+    {
+        for (auto const& arg : list)
+        {
+            indices.insert(indices.end(), arg.begin(), arg.end());
+        }
+    }
+
+    void draw()
+    {
+        glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_BYTE, indices.data());
+    }
+
+private:
+    DrawableDigit() = delete;
+    std::vector<GLubyte> indices;
+};
+
+class TwoDigitCounter
+{
+public:
+    TwoDigitCounter(GLuint prog, float thickness, unsigned int max_count)
+        : count{0}, max_count{max_count}, program{prog},
+          vertices{create_vertices(thickness)}, digit_drawables{create_digits()}
+    {
+        if (max_count > 99)
+            max_count = 99;
+
+        vpos = glGetAttribLocation(program, "vPosition");
+        if (vpos == -1)
+            throw std::runtime_error("Failed to obtain vPosition attribute");
+
+        xoff = glGetUniformLocation(program, "xOffset");
+        if (xoff == -1)
+            throw std::runtime_error("Failed to obtain xoff uniform");
+
+        xscale = glGetUniformLocation(program, "xScale");
+        if (xscale == -1)
+            throw std::runtime_error("Failed to obtain xscale uniform");
+
+        glUniform1f(xscale, 0.4f);
+        glVertexAttribPointer(vpos, 2, GL_FLOAT, GL_FALSE, 0, vertices.data());
+        glEnableVertexAttribArray(0);
+    }
+
+    void draw()
+    {
+        drawLeftDigit();
+        drawRightDigit();
+        nextCount();
+    }
+
+private:
+    void draw(int digit)
+    {
+        if (static_cast<size_t>(digit) > digit_drawables.size())
+            throw std::logic_error("invalid digit to draw");
+
+        digit_drawables[digit].draw();
+    }
+
+    void drawRightDigit()
+    {
+        glUniform1f(xoff, 0.5f);
+        draw(count % 10);
+    }
+
+    void drawLeftDigit()
+    {
+        glUniform1f(xoff, -0.5f);
+        draw(count/10);
+    }
+
+    void nextCount()
+    {
+        count++;
+        if (count > max_count) count = 0;
+    }
+
+    static std::vector<GLfloat> create_vertices(GLfloat t)
+    {
+        return std::vector<GLfloat>{
+            -1.0f,   -1.0f,
+            -1.0f+t, -1.0f,
+             1.0f-t, -1.0f,
+
+             1.0f,   -1.0f,
+            -1.0f,   -1.0f+t,
+             1.0f,   -1.0f+t,
+
+            -1.0f,   -t/2.0f,
+            -1.0f+t, -t/2.0f,
+             1.0f-t, -t/2.0f,
+
+             1.0f,   -t/2.0f,
+            -1.0f,    t/2.0f,
+             1.0f,    t/2.0f,
+
+            -1.0f,    1.0f-t,
+             1.0f,    1.0f-t,
+            -1.0f,    1.0f,
+
+            -1.0f+t,  1.0f,
+             1.0f-t,  1.0f,
+             1.0f,    1.0f,
+        };
+    }
+
+    static std::vector<DrawableDigit> create_digits()
+    {
+        std::vector<DrawableDigit> digits;
+        /*
+         * Vertex indices for quads which can be used to make
+         * simple number "font" shapes
+         */
+        std::vector<GLubyte> top{12, 14, 13, 13, 14, 17};
+        std::vector<GLubyte> bottom{0, 4, 3, 3, 4, 5};
+        std::vector<GLubyte> middle{6, 10, 9, 9, 10, 11};
+        std::vector<GLubyte> left{0, 14, 1, 1, 14, 15};
+        std::vector<GLubyte> right{2, 16, 3, 3, 16, 17};
+
+        std::vector<GLubyte> top_left{6, 14, 7, 7, 14, 15};
+        std::vector<GLubyte> top_right{8, 16, 9, 9, 16, 17};
+        std::vector<GLubyte> bottom_left{0, 6, 1, 1, 6, 7};
+        std::vector<GLubyte> bottom_right{2, 8, 3, 3, 8, 9};
+
+        digits.push_back({top, bottom, left, right});
+        digits.push_back({right});
+        digits.push_back({top, middle, bottom, top_right, bottom_left});
+        digits.push_back({top, middle, bottom, right});
+        digits.push_back({top_left, middle, right});
+        digits.push_back({top, middle, bottom, top_left, bottom_right});
+        digits.push_back({top, middle, bottom, left, bottom_right});
+        digits.push_back({top, right});
+        digits.push_back({top, middle, bottom, left, right});
+        digits.push_back({top, middle, right, top_left});
+        return digits;
+    }
+
+    unsigned int count;
+    unsigned int max_count;
+
+    GLint vpos;
+    GLint xoff;
+    GLint xscale;
+    GLuint program;
+
+    std::vector<GLfloat> const vertices;
+    std::vector<DrawableDigit> digit_drawables;
+};
+
+/* Colours from http://design.ubuntu.com/brand/colour-palette */
+#define MID_AUBERGINE 0.368627451f, 0.152941176f, 0.31372549f
+#define ORANGE        0.866666667f, 0.282352941f, 0.141414141f
+
+int main(int argc, char *argv[])
+{
+    const char vshadersrc[] =
+        "attribute vec4 vPosition;            \n"
+        "uniform float xOffset;               \n"
+        "uniform float xScale;                \n"
+        "void main()                          \n"
+        "{                                    \n"
+        "    vec4 vertex;                     \n"
+        "    vertex = vPosition;              \n"
+        "    vertex.x *= xScale;              \n"
+        "    vertex.x += xOffset;             \n"
+        "    gl_Position = vertex;            \n"
+        "}                                    \n";
+
+    const char fshadersrc[] =
+        "precision mediump float;             \n"
+        "uniform vec4 col;                    \n"
+        "void main()                          \n"
+        "{                                    \n"
+        "    gl_FragColor = col;              \n"
+        "}                                    \n";
+
+    GLuint vshader, fshader, prog;
+    GLint linked, col;
+    unsigned int width = 512, height = 256;
+
+    if (!mir_eglapp_init(argc, argv, &width, &height))
+        return 1;
+
+    vshader = load_shader(vshadersrc, GL_VERTEX_SHADER);
+    assert(vshader);
+    fshader = load_shader(fshadersrc, GL_FRAGMENT_SHADER);
+    assert(fshader);
+    prog = glCreateProgram();
+    assert(prog);
+    glAttachShader(prog, vshader);
+    glAttachShader(prog, fshader);
+    glLinkProgram(prog);
+
+    glGetProgramiv(prog, GL_LINK_STATUS, &linked);
+    if (!linked)
+    {
+        GLchar log[1024];
+        glGetProgramInfoLog(prog, sizeof log - 1, NULL, log);
+        log[sizeof log - 1] = '\0';
+        printf("Link failed: %s\n", log);
+        return 2;
+    }
+
+    glClearColor(MID_AUBERGINE, mir_eglapp_background_opacity);
+    glViewport(0, 0, width, height);
+
+    glUseProgram(prog);
+
+    col = glGetUniformLocation(prog, "col");
+    glUniform4f(col, ORANGE, 1.0f);
+
+    float thickness = 0.2f;
+    unsigned int max_counter = 60;
+    TwoDigitCounter counter(prog, thickness, max_counter);
+
+    while (mir_eglapp_running())
+    {
+        glClear(GL_COLOR_BUFFER_BIT);
+        counter.draw();
+        mir_eglapp_swap_buffers();
+    }
+
+    mir_eglapp_shutdown();
+
+    return 0;
+}

=== modified file 'examples/render_overlays.cpp'
--- examples/render_overlays.cpp	2014-03-28 22:40:30 +0000
+++ examples/render_overlays.cpp	2014-04-30 13:15:30 +0000
@@ -105,6 +105,11 @@
     {
     }
 
+    ID id() const override
+    {
+        return this;
+    }
+
     std::shared_ptr<mg::Buffer> buffer(void const*) const override
     {
         return client->last_rendered();

=== modified file 'examples/render_surfaces.cpp'
--- examples/render_surfaces.cpp	2014-03-28 17:47:07 +0000
+++ examples/render_surfaces.cpp	2014-04-30 13:15:30 +0000
@@ -22,7 +22,7 @@
 #include "mir/options/default_configuration.h"
 #include "mir/graphics/graphic_buffer_allocator.h"
 #include "mir/frontend/connector.h"
-#include "mir/shell/surface_creation_parameters.h"
+#include "mir/scene/surface_creation_parameters.h"
 #include "mir/geometry/size.h"
 #include "mir/geometry/rectangles.h"
 #include "mir/graphics/buffer_initializer.h"
@@ -30,7 +30,6 @@
 #include "mir/graphics/display.h"
 #include "mir/graphics/display_buffer.h"
 #include "mir/graphics/gl_context.h"
-#include "mir/shell/surface_factory.h"
 #include "mir/scene/surface.h"
 #include "mir/scene/surface_coordinator.h"
 #include "mir/run_mir.h"
@@ -195,7 +194,7 @@
 {
 public:
     Moveable() {}
-    Moveable(std::shared_ptr<msh::Surface> const& s, const geom::Size& display_size,
+    Moveable(std::shared_ptr<ms::Surface> const& s, const geom::Size& display_size,
              float dx, float dy, const glm::vec3& rotation_axis, float alpha_offset)
         : surface(s), display_size(display_size),
           x{static_cast<float>(s->top_left().x.as_uint32_t())},
@@ -251,7 +250,7 @@
     }
 
 private:
-    std::shared_ptr<msh::Surface> surface;
+    std::shared_ptr<ms::Surface> surface;
     geom::Size display_size;
     float x;
     float y;
@@ -466,10 +465,10 @@
         for (auto& m : moveables)
         {
             auto const s = surface_coordinator->add_surface(
-                    msh::a_surface().of_size(surface_size)
+                    ms::a_surface().of_size(surface_size)
                                    .of_pixel_format(surface_pf)
                                    .of_buffer_usage(mg::BufferUsage::hardware),
-                    {});
+                    nullptr);
 
             /*
              * We call swap_buffers() twice so that the surface is

=== modified file 'include/client/mir_toolkit/mir_client_library.h'
--- include/client/mir_toolkit/mir_client_library.h	2014-03-06 06:05:17 +0000
+++ include/client/mir_toolkit/mir_client_library.h	2014-04-30 13:15:30 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012-2013 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License version 3,
@@ -18,395 +18,8 @@
 #ifndef MIR_CLIENT_LIBRARY_H
 #define MIR_CLIENT_LIBRARY_H
 
-#include <mir_toolkit/mir_native_buffer.h>
-#include <mir_toolkit/client_types.h>
-#include <mir_toolkit/common.h>
-
-#ifdef __cplusplus
-/**
- * \addtogroup mir_toolkit
- * @{
- */
-extern "C" {
-#endif
-
-/* This header defines the Mir client library's C API. */
-
-/**
- * Request a connection to the Mir server. The supplied callback is called when
- * the connection is established, or fails. The returned wait handle remains
- * valid until the connection has been released.
- *   \warning callback could be called from another thread. You must do any
- *            locking appropriate to protect your data accessed in the
- *            callback.
- *   \param [in] server       File path of the server socket to connect to, or
- *                            NULL to choose the default server (can be set by
- *                            the $MIR_SOCKET environment variable)
- *   \param [in] app_name     A name referring to the application
- *   \param [in] callback     Callback function to be invoked when request
- *                            completes
- *   \param [in,out] context  User data passed to the callback function
- *   \return                  A handle that can be passed to mir_wait_for
- */
-MirWaitHandle *mir_connect(
-    char const *server,
-    char const *app_name,
-    mir_connected_callback callback,
-    void *context);
-
-/**
- * Perform a mir_connect() but also wait for and return the result.
- *   \param [in] server    File path of the server socket to connect to, or
- *                         NULL to choose the default server
- *   \param [in] app_name  A name referring to the application
- *   \return               The resulting MirConnection
- */
-MirConnection *mir_connect_sync(char const *server, char const *app_name);
-
-/**
- * Test for a valid connection
- * \param [in] connection  The connection
- * \return                 True if the supplied connection is valid, or
- *                         false otherwise.
- */
-MirBool mir_connection_is_valid(MirConnection *connection);
-
-/**
- * Retrieve a text description of the last error. The returned string is owned
- * by the library and remains valid until the connection has been released.
- *   \param [in] connection  The connection
- *   \return                 A text description of any error resulting in an
- *                           invalid connection, or the empty string "" if the
- *                           connection is valid.
- */
-char const *mir_connection_get_error_message(MirConnection *connection);
-
-/**
- * Release a connection to the Mir server
- *   \param [in] connection  The connection
- */
-void mir_connection_release(MirConnection *connection);
-
-/**
- * Query platform-specific data and/or file descriptors that are required to
- * initialize GL/EGL features.
- *   \param [in]  connection        The connection
- *   \param [out] platform_package  Structure to be populated
- */
-void mir_connection_get_platform(MirConnection *connection, MirPlatformPackage *platform_package);
-
-/**
- * Register a callback to be called when a Lifecycle state change occurs.
- *   \param [in] connection     The connection
- *   \param [in] callback       The function to be called when the state change occurs
- *   \param [in,out] context    User data passed to the callback function
- */
-void mir_connection_set_lifecycle_event_callback(MirConnection* connection,
-    mir_lifecycle_event_callback callback, void* context);
-
-/**
- * \deprecated Use mir_connection_create_display_config
- */
-__attribute__((__deprecated__("Use mir_connection_create_display_config()")))
-void mir_connection_get_display_info(MirConnection *connection, MirDisplayInfo *display_info);
-
-/**
- * Query the display
- *   \warning return value must be destroyed via mir_display_config_destroy()
- *   \warning may return null if connection is invalid
- *   \param [in]  connection        The connection
- *   \return                        structure that describes the display configuration
- */
-MirDisplayConfiguration* mir_connection_create_display_config(MirConnection *connection);
-
-/**
- * Register a callback to be called when the hardware display configuration changes
- *
- * Once a change has occurred, you can use mir_connection_create_display_config to see
- * the new configuration.
- *
- *   \param [in] connection  The connection
- *   \param [in] callback     The function to be called when a display change occurs
- *   \param [in,out] context  User data passed to the callback function
- */
-void mir_connection_set_display_config_change_callback(
-    MirConnection* connection,
-    mir_display_config_callback callback, void* context);
-
-/**
- * Destroy the DisplayConfiguration resource acquired from mir_connection_create_display_config
- *   \param [in] display_configuration  The display_configuration information resource to be destroyed
- */
-void mir_display_config_destroy(MirDisplayConfiguration* display_configuration);
-
-/**
- * Apply the display configuration
- *
- * The display configuration is applied to this connection only (per-connection
- * configuration) and is invalidated when a hardware change occurs. Clients should
- * register a callback with mir_connection_set_display_config_change_callback()
- * to get notified about hardware changes, so that the can apply a new configuration.
- *
- *   \warning This request may be denied. Check that the request succeeded with mir_connection_get_error_message.
- *   \param [in] connection             The connection
- *   \param [in] display_configuration  The display_configuration to apply
- *   \return                            A handle that can be passed to mir_wait_for
- */
-MirWaitHandle* mir_connection_apply_display_config(MirConnection *connection, MirDisplayConfiguration* display_configuration);
-
-/**
- * Get a display type that can be used for OpenGL ES 2.0 acceleration.
- *   \param [in] connection  The connection
- *   \return                 An EGLNativeDisplayType that the client can use
- */
-MirEGLNativeDisplayType mir_connection_get_egl_native_display(MirConnection *connection);
-
-/**
- * Get the list of possible formats that a surface can be created with.
- *   \param [in] connection         The connection
- *   \param [out] formats           List of valid formats to create surfaces with
- *   \param [in]  formats_size      size of formats list
- *   \param [out] num_valid_formats number of valid formats returned in formats
- */
-void mir_connection_get_available_surface_formats(
-    MirConnection* connection, MirPixelFormat* formats,
-    unsigned const int format_size, unsigned int *num_valid_formats);
-
-/**
- * Request a new Mir surface on the supplied connection with the supplied
- * parameters. The returned handle remains valid until the surface has been
- * released.
- *   \warning callback could be called from another thread. You must do any
- *            locking appropriate to protect your data accessed in the
- *            callback.
- *   \param [in] connection          The connection
- *   \param [in] surface_parameters  Request surface parameters
- *   \param [in] callback            Callback function to be invoked when
- *                                   request completes
- *   \param [in,out] context         User data passed to the callback function
- *   \return                         A handle that can be passed to
- *                                   mir_wait_for
- */
-MirWaitHandle *mir_connection_create_surface(
-    MirConnection *connection,
-    MirSurfaceParameters const *surface_parameters,
-    mir_surface_callback callback,
-    void *context);
-
-/**
- * Create a surface like in mir_connection_create_surface(), but also wait for
- * creation to complete and return the resulting surface.
- *   \param [in] connection  The connection
- *   \param [in] params      Parameters describing the desired surface
- *   \return                 The resulting surface
- */
-MirSurface *mir_connection_create_surface_sync(
-    MirConnection *connection,
-    MirSurfaceParameters const *params);
-
-/**
- * Set the event handler to be called when events arrive for a surface.
- *   \warning event_handler could be called from another thread. You must do
- *            any locking appropriate to protect your data accessed in the
- *            callback. There is also a chance that different events will be
- *            called back in different threads, for the same surface,
- *            simultaneously.
- *   \param [in] surface        The surface
- *   \param [in] event_handler  The event handler to call
- */
-void mir_surface_set_event_handler(MirSurface *surface,
-                                   MirEventDelegate const *event_handler);
-
-/**
- * Get a window type that can be used for OpenGL ES 2.0 acceleration.
- *   \param [in] surface  The surface
- *   \return              An EGLNativeWindowType that the client can use
- */
-MirEGLNativeWindowType mir_surface_get_egl_native_window(MirSurface *surface);
-
-/**
- * Test for a valid surface
- *   \param [in] surface  The surface
- *   \return              True if the supplied surface is valid, or
- *                        false otherwise.
- */
-MirBool mir_surface_is_valid(MirSurface *surface);
-
-/**
- * Retrieve a text description of the error. The returned string is owned by
- * the library and remains valid until the surface or the associated
- * connection has been released.
- *   \param [in] surface  The surface
- *   \return              A text description of any error resulting in an
- *                        invalid surface, or the empty string "" if the
- *                        connection is valid.
- */
-char const *mir_surface_get_error_message(MirSurface *surface);
-
-/**
- * Get a surface's parameters.
- *   \pre                     The surface is valid
- *   \param [in] surface      The surface
- *   \param [out] parameters  Structure to be populated
- */
-void mir_surface_get_parameters(MirSurface *surface, MirSurfaceParameters *parameters);
-
-/**
- * Get the underlying platform type so the buffer obtained in "raw" representation
- * in mir_surface_get_current_buffer() can be understood
- *   \pre                     The surface is valid
- *   \param [in] surface      The surface
- *   \return                  One of mir_platform_type_android or mir_platform_type_gbm
- */
-MirPlatformType mir_surface_get_platform_type(MirSurface *surface);
-
-/**
- * Get a surface's buffer in "raw" representation.
- *   \pre                         The surface is valid
- *   \param [in] surface          The surface
- *   \param [out] buffer_package  Structure to be populated
- */
-void mir_surface_get_current_buffer(MirSurface *surface, MirNativeBuffer **buffer_package);
-
-/**
- * Get a surface's graphics_region, i.e., map the graphics buffer to main
- * memory.
- *   \pre                          The surface is valid
- *   \param [in] surface           The surface
- *   \param [out] graphics_region  Structure to be populated
- */
-void mir_surface_get_graphics_region(
-    MirSurface *surface,
-    MirGraphicsRegion *graphics_region);
-
-/**
- * Advance a surface's buffer. The returned handle remains valid until the next
- * call to mir_surface_swap_buffers, until the surface has been released or the
- * connection to the server has been released.
- *   \warning callback could be called from another thread. You must do any
- *            locking appropriate to protect your data accessed in the
- *            callback.
- *   \param [in] surface      The surface
- *   \param [in] callback     Callback function to be invoked when the request
- *                            completes
- *   \param [in,out] context  User data passed to the callback function
- *   \return                  A handle that can be passed to mir_wait_for
- */
-MirWaitHandle *mir_surface_swap_buffers(
-    MirSurface *surface,
-    mir_surface_callback callback,
-    void *context);
-
-/**
- * Advance a surface's buffer as in mir_surface_swap_buffers(), but also wait
- * for the operation to complete.
- *   \param [in] surface  The surface whose buffer to advance
- */
-void mir_surface_swap_buffers_sync(MirSurface *surface);
-
-/**
- * Release the supplied surface and any associated buffer. The returned wait
- * handle remains valid until the connection to the server is released.
- *   \warning callback could be called from another thread. You must do any
- *            locking appropriate to protect your data accessed in the
- *            callback.
- *   \param [in] surface      The surface
- *   \param [in] callback     Callback function to be invoked when the request
- *                            completes
- *   \param [in,out] context  User data passed to the callback function
- *   \return                  A handle that can be passed to mir_wait_for
- */
-MirWaitHandle *mir_surface_release(
-    MirSurface *surface,
-    mir_surface_callback callback,
-    void *context);
-
-/**
- * Release the specified surface like in mir_surface_release(), but also wait
- * for the operation to complete.
- *   \param [in] surface  The surface to be released
- */
-void mir_surface_release_sync(MirSurface *surface);
-
-/**
- * Wait on the supplied handle until all instances of the associated request
- * have completed.
- *   \param [in] wait_handle  Handle returned by an asynchronous request
- */
-void mir_wait_for(MirWaitHandle *wait_handle);
-
-/**
- * Wait on the supplied handle until one instance of the associated request
- * has completed. Use this instead of mir_wait_for in a threaded environment
- * to ensure that the act of waiting does not clear all results associated
- * with the wait handle; only one.
- *   \param [in] wait_handle  Handle returned by an asynchronous request
- */
-void mir_wait_for_one(MirWaitHandle *wait_handle);
-
-/**
- * \deprecated Use mir_debug_surface_id()
- */
-__attribute__((__deprecated__("Use mir_debug_surface_id()")))
-int mir_surface_get_id(MirSurface *surface);
-
-/**
- * Set the type (purpose) of a surface. This is not guaranteed to always work
- * with some shell types (e.g. phone/tablet UIs). As such, you may have to
- * wait on the function and check the result using mir_surface_get_type.
- *   \param [in] surface  The surface to operate on
- *   \param [in] type     The new type of the surface
- *   \return              A wait handle that can be passed to mir_wait_for
- */
-MirWaitHandle* mir_surface_set_type(MirSurface *surface, MirSurfaceType type);
-
-/**
- * Get the type (purpose) of a surface.
- *   \param [in] surface  The surface to query
- *   \return              The type of the surface
- */
-MirSurfaceType mir_surface_get_type(MirSurface *surface);
-
-/**
- * Change the state of a surface.
- *   \param [in] surface  The surface to operate on
- *   \param [in] state    The new state of the surface
- *   \return              A wait handle that can be passed to mir_wait_for
- */
-MirWaitHandle* mir_surface_set_state(MirSurface *surface,
-                                     MirSurfaceState state);
-
-/**
- * Get the current state of a surface.
- *   \param [in] surface  The surface to query
- *   \return              The state of the surface
- */
-MirSurfaceState mir_surface_get_state(MirSurface *surface);
-
-/**
- * Set the swapinterval for mir_surface_swap_buffers. EGL users should use
- * eglSwapInterval directly.
- * At the time being, only swapinterval of 0 or 1 is supported.
- *   \param [in] surface  The surface to operate on
- *   \param [in] interval The number of vblank signals that
- *                        mir_surface_swap_buffers will wait for
- *   \return              A wait handle that can be passed to mir_wait_for,
- *                        or NULL if the interval could not be supported
- */
-MirWaitHandle* mir_surface_set_swapinterval(MirSurface* surface, int interval);
-
-/**
- * Query the swapinterval that the surface is operating with.
- * The default interval is 1.
- *   \param [in] surface  The surface to operate on
- *   \return              The swapinterval value that the client is operating with.
- *                        Returns -1 if surface is invalid.
- */
-int mir_surface_get_swapinterval(MirSurface* surface);
-
-#ifdef __cplusplus
-}
-/**@}*/
-#endif
+#include <mir_toolkit/mir_connection.h>
+#include <mir_toolkit/mir_surface.h>
+#include <mir_toolkit/mir_wait.h>
 
 #endif /* MIR_CLIENT_LIBRARY_H */

=== added file 'include/client/mir_toolkit/mir_connection.h'
--- include/client/mir_toolkit/mir_connection.h	1970-01-01 00:00:00 +0000
+++ include/client/mir_toolkit/mir_connection.h	2014-04-30 13:15:30 +0000
@@ -0,0 +1,178 @@
+/*
+ * Copyright © 2012-2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MIR_TOOLKIT_MIR_CONNECTION_H_
+#define MIR_TOOLKIT_MIR_CONNECTION_H_
+
+#include <mir_toolkit/client_types.h>
+#include <mir_toolkit/common.h>
+
+#ifdef __cplusplus
+/**
+ * \addtogroup mir_toolkit
+ * @{
+ */
+extern "C" {
+#endif
+
+/**
+ * Request a connection to the Mir server. The supplied callback is called when
+ * the connection is established, or fails. The returned wait handle remains
+ * valid until the connection has been released.
+ *   \warning callback could be called from another thread. You must do any
+ *            locking appropriate to protect your data accessed in the
+ *            callback.
+ *   \param [in] server       File path of the server socket to connect to, or
+ *                            NULL to choose the default server (can be set by
+ *                            the $MIR_SOCKET environment variable)
+ *   \param [in] app_name     A name referring to the application
+ *   \param [in] callback     Callback function to be invoked when request
+ *                            completes
+ *   \param [in,out] context  User data passed to the callback function
+ *   \return                  A handle that can be passed to mir_wait_for
+ */
+MirWaitHandle *mir_connect(
+    char const *server,
+    char const *app_name,
+    mir_connected_callback callback,
+    void *context);
+
+/**
+ * Perform a mir_connect() but also wait for and return the result.
+ *   \param [in] server    File path of the server socket to connect to, or
+ *                         NULL to choose the default server
+ *   \param [in] app_name  A name referring to the application
+ *   \return               The resulting MirConnection
+ */
+MirConnection *mir_connect_sync(char const *server, char const *app_name);
+
+/**
+ * Test for a valid connection
+ * \param [in] connection  The connection
+ * \return                 True if the supplied connection is valid, or
+ *                         false otherwise.
+ */
+MirBool mir_connection_is_valid(MirConnection *connection);
+
+/**
+ * Retrieve a text description of the last error. The returned string is owned
+ * by the library and remains valid until the connection has been released.
+ *   \param [in] connection  The connection
+ *   \return                 A text description of any error resulting in an
+ *                           invalid connection, or the empty string "" if the
+ *                           connection is valid.
+ */
+char const *mir_connection_get_error_message(MirConnection *connection);
+
+/**
+ * Release a connection to the Mir server
+ *   \param [in] connection  The connection
+ */
+void mir_connection_release(MirConnection *connection);
+
+/**
+ * Query platform-specific data and/or file descriptors that are required to
+ * initialize GL/EGL features.
+ *   \param [in]  connection        The connection
+ *   \param [out] platform_package  Structure to be populated
+ */
+void mir_connection_get_platform(MirConnection *connection, MirPlatformPackage *platform_package);
+
+/**
+ * Register a callback to be called when a Lifecycle state change occurs.
+ *   \param [in] connection     The connection
+ *   \param [in] callback       The function to be called when the state change occurs
+ *   \param [in,out] context    User data passed to the callback function
+ */
+void mir_connection_set_lifecycle_event_callback(MirConnection* connection,
+    mir_lifecycle_event_callback callback, void* context);
+
+/**
+ * \deprecated Use mir_connection_create_display_config
+ */
+__attribute__((__deprecated__("Use mir_connection_create_display_config()")))
+void mir_connection_get_display_info(MirConnection *connection, MirDisplayInfo *display_info);
+
+/**
+ * Query the display
+ *   \warning return value must be destroyed via mir_display_config_destroy()
+ *   \warning may return null if connection is invalid
+ *   \param [in]  connection        The connection
+ *   \return                        structure that describes the display configuration
+ */
+MirDisplayConfiguration* mir_connection_create_display_config(MirConnection *connection);
+
+/**
+ * Register a callback to be called when the hardware display configuration changes
+ *
+ * Once a change has occurred, you can use mir_connection_create_display_config to see
+ * the new configuration.
+ *
+ *   \param [in] connection  The connection
+ *   \param [in] callback     The function to be called when a display change occurs
+ *   \param [in,out] context  User data passed to the callback function
+ */
+void mir_connection_set_display_config_change_callback(
+    MirConnection* connection,
+    mir_display_config_callback callback, void* context);
+
+/**
+ * Destroy the DisplayConfiguration resource acquired from mir_connection_create_display_config
+ *   \param [in] display_configuration  The display_configuration information resource to be destroyed
+ */
+void mir_display_config_destroy(MirDisplayConfiguration* display_configuration);
+
+/**
+ * Apply the display configuration
+ *
+ * The display configuration is applied to this connection only (per-connection
+ * configuration) and is invalidated when a hardware change occurs. Clients should
+ * register a callback with mir_connection_set_display_config_change_callback()
+ * to get notified about hardware changes, so that the can apply a new configuration.
+ *
+ *   \warning This request may be denied. Check that the request succeeded with mir_connection_get_error_message.
+ *   \param [in] connection             The connection
+ *   \param [in] display_configuration  The display_configuration to apply
+ *   \return                            A handle that can be passed to mir_wait_for
+ */
+MirWaitHandle* mir_connection_apply_display_config(MirConnection *connection, MirDisplayConfiguration* display_configuration);
+
+/**
+ * Get a display type that can be used for OpenGL ES 2.0 acceleration.
+ *   \param [in] connection  The connection
+ *   \return                 An EGLNativeDisplayType that the client can use
+ */
+MirEGLNativeDisplayType mir_connection_get_egl_native_display(MirConnection *connection);
+
+/**
+ * Get the list of possible formats that a surface can be created with.
+ *   \param [in] connection         The connection
+ *   \param [out] formats           List of valid formats to create surfaces with
+ *   \param [in]  formats_size      size of formats list
+ *   \param [out] num_valid_formats number of valid formats returned in formats
+ */
+void mir_connection_get_available_surface_formats(
+    MirConnection* connection, MirPixelFormat* formats,
+    unsigned const int format_size, unsigned int *num_valid_formats);
+
+
+#ifdef __cplusplus
+}
+/**@}*/
+#endif
+
+#endif /* MIR_TOOLKIT_MIR_CONNECTION_H_ */

=== added file 'include/client/mir_toolkit/mir_surface.h'
--- include/client/mir_toolkit/mir_surface.h	1970-01-01 00:00:00 +0000
+++ include/client/mir_toolkit/mir_surface.h	2014-04-30 13:15:30 +0000
@@ -0,0 +1,254 @@
+/*
+ * Copyright © 2012-2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MIR_TOOLKIT_MIR_SURFACE_H_
+#define MIR_TOOLKIT_MIR_SURFACE_H_
+
+#include <mir_toolkit/mir_native_buffer.h>
+#include <mir_toolkit/client_types.h>
+#include <mir_toolkit/common.h>
+
+#ifdef __cplusplus
+/**
+ * \addtogroup mir_toolkit
+ * @{
+ */
+extern "C" {
+#endif
+
+/**
+ * Request a new Mir surface on the supplied connection with the supplied
+ * parameters. The returned handle remains valid until the surface has been
+ * released.
+ *   \warning callback could be called from another thread. You must do any
+ *            locking appropriate to protect your data accessed in the
+ *            callback.
+ *   \param [in] connection          The connection
+ *   \param [in] surface_parameters  Request surface parameters
+ *   \param [in] callback            Callback function to be invoked when
+ *                                   request completes
+ *   \param [in,out] context         User data passed to the callback function
+ *   \return                         A handle that can be passed to
+ *                                   mir_wait_for
+ */
+MirWaitHandle *mir_connection_create_surface(
+    MirConnection *connection,
+    MirSurfaceParameters const *surface_parameters,
+    mir_surface_callback callback,
+    void *context);
+
+/**
+ * Create a surface like in mir_connection_create_surface(), but also wait for
+ * creation to complete and return the resulting surface.
+ *   \param [in] connection  The connection
+ *   \param [in] params      Parameters describing the desired surface
+ *   \return                 The resulting surface
+ */
+MirSurface *mir_connection_create_surface_sync(
+    MirConnection *connection,
+    MirSurfaceParameters const *params);
+
+/**
+ * Set the event handler to be called when events arrive for a surface.
+ *   \warning event_handler could be called from another thread. You must do
+ *            any locking appropriate to protect your data accessed in the
+ *            callback. There is also a chance that different events will be
+ *            called back in different threads, for the same surface,
+ *            simultaneously.
+ *   \param [in] surface        The surface
+ *   \param [in] event_handler  The event handler to call
+ */
+void mir_surface_set_event_handler(MirSurface *surface,
+                                   MirEventDelegate const *event_handler);
+
+/**
+ * Get a window type that can be used for OpenGL ES 2.0 acceleration.
+ *   \param [in] surface  The surface
+ *   \return              An EGLNativeWindowType that the client can use
+ */
+MirEGLNativeWindowType mir_surface_get_egl_native_window(MirSurface *surface);
+
+/**
+ * Test for a valid surface
+ *   \param [in] surface  The surface
+ *   \return              True if the supplied surface is valid, or
+ *                        false otherwise.
+ */
+MirBool mir_surface_is_valid(MirSurface *surface);
+
+/**
+ * Retrieve a text description of the error. The returned string is owned by
+ * the library and remains valid until the surface or the associated
+ * connection has been released.
+ *   \param [in] surface  The surface
+ *   \return              A text description of any error resulting in an
+ *                        invalid surface, or the empty string "" if the
+ *                        connection is valid.
+ */
+char const *mir_surface_get_error_message(MirSurface *surface);
+
+/**
+ * Get a surface's parameters.
+ *   \pre                     The surface is valid
+ *   \param [in] surface      The surface
+ *   \param [out] parameters  Structure to be populated
+ */
+void mir_surface_get_parameters(MirSurface *surface, MirSurfaceParameters *parameters);
+
+/**
+ * Get the underlying platform type so the buffer obtained in "raw" representation
+ * in mir_surface_get_current_buffer() can be understood
+ *   \pre                     The surface is valid
+ *   \param [in] surface      The surface
+ *   \return                  One of mir_platform_type_android or mir_platform_type_gbm
+ */
+MirPlatformType mir_surface_get_platform_type(MirSurface *surface);
+
+/**
+ * Get a surface's buffer in "raw" representation.
+ *   \pre                         The surface is valid
+ *   \param [in] surface          The surface
+ *   \param [out] buffer_package  Structure to be populated
+ */
+void mir_surface_get_current_buffer(MirSurface *surface, MirNativeBuffer **buffer_package);
+
+/**
+ * Get a surface's graphics_region, i.e., map the graphics buffer to main
+ * memory.
+ *   \pre                          The surface is valid
+ *   \param [in] surface           The surface
+ *   \param [out] graphics_region  Structure to be populated
+ */
+void mir_surface_get_graphics_region(
+    MirSurface *surface,
+    MirGraphicsRegion *graphics_region);
+
+/**
+ * Advance a surface's buffer. The returned handle remains valid until the next
+ * call to mir_surface_swap_buffers, until the surface has been released or the
+ * connection to the server has been released.
+ *   \warning callback could be called from another thread. You must do any
+ *            locking appropriate to protect your data accessed in the
+ *            callback.
+ *   \param [in] surface      The surface
+ *   \param [in] callback     Callback function to be invoked when the request
+ *                            completes
+ *   \param [in,out] context  User data passed to the callback function
+ *   \return                  A handle that can be passed to mir_wait_for
+ */
+MirWaitHandle *mir_surface_swap_buffers(
+    MirSurface *surface,
+    mir_surface_callback callback,
+    void *context);
+
+/**
+ * Advance a surface's buffer as in mir_surface_swap_buffers(), but also wait
+ * for the operation to complete.
+ *   \param [in] surface  The surface whose buffer to advance
+ */
+void mir_surface_swap_buffers_sync(MirSurface *surface);
+
+/**
+ * Release the supplied surface and any associated buffer. The returned wait
+ * handle remains valid until the connection to the server is released.
+ *   \warning callback could be called from another thread. You must do any
+ *            locking appropriate to protect your data accessed in the
+ *            callback.
+ *   \param [in] surface      The surface
+ *   \param [in] callback     Callback function to be invoked when the request
+ *                            completes
+ *   \param [in,out] context  User data passed to the callback function
+ *   \return                  A handle that can be passed to mir_wait_for
+ */
+MirWaitHandle *mir_surface_release(
+    MirSurface *surface,
+    mir_surface_callback callback,
+    void *context);
+
+/**
+ * Release the specified surface like in mir_surface_release(), but also wait
+ * for the operation to complete.
+ *   \param [in] surface  The surface to be released
+ */
+void mir_surface_release_sync(MirSurface *surface);
+
+/**
+ * \deprecated Use mir_debug_surface_id()
+ */
+__attribute__((__deprecated__("Use mir_debug_surface_id()")))
+int mir_surface_get_id(MirSurface *surface);
+
+/**
+ * Set the type (purpose) of a surface. This is not guaranteed to always work
+ * with some shell types (e.g. phone/tablet UIs). As such, you may have to
+ * wait on the function and check the result using mir_surface_get_type.
+ *   \param [in] surface  The surface to operate on
+ *   \param [in] type     The new type of the surface
+ *   \return              A wait handle that can be passed to mir_wait_for
+ */
+MirWaitHandle* mir_surface_set_type(MirSurface *surface, MirSurfaceType type);
+
+/**
+ * Get the type (purpose) of a surface.
+ *   \param [in] surface  The surface to query
+ *   \return              The type of the surface
+ */
+MirSurfaceType mir_surface_get_type(MirSurface *surface);
+
+/**
+ * Change the state of a surface.
+ *   \param [in] surface  The surface to operate on
+ *   \param [in] state    The new state of the surface
+ *   \return              A wait handle that can be passed to mir_wait_for
+ */
+MirWaitHandle* mir_surface_set_state(MirSurface *surface,
+                                     MirSurfaceState state);
+
+/**
+ * Get the current state of a surface.
+ *   \param [in] surface  The surface to query
+ *   \return              The state of the surface
+ */
+MirSurfaceState mir_surface_get_state(MirSurface *surface);
+
+/**
+ * Set the swapinterval for mir_surface_swap_buffers. EGL users should use
+ * eglSwapInterval directly.
+ * At the time being, only swapinterval of 0 or 1 is supported.
+ *   \param [in] surface  The surface to operate on
+ *   \param [in] interval The number of vblank signals that
+ *                        mir_surface_swap_buffers will wait for
+ *   \return              A wait handle that can be passed to mir_wait_for,
+ *                        or NULL if the interval could not be supported
+ */
+MirWaitHandle* mir_surface_set_swapinterval(MirSurface* surface, int interval);
+
+/**
+ * Query the swapinterval that the surface is operating with.
+ * The default interval is 1.
+ *   \param [in] surface  The surface to operate on
+ *   \return              The swapinterval value that the client is operating with.
+ *                        Returns -1 if surface is invalid.
+ */
+int mir_surface_get_swapinterval(MirSurface* surface);
+
+#ifdef __cplusplus
+}
+/**@}*/
+#endif
+
+#endif /* MIR_TOOLKIT_MIR_SURFACE_H_ */

=== added file 'include/client/mir_toolkit/mir_wait.h'
--- include/client/mir_toolkit/mir_wait.h	1970-01-01 00:00:00 +0000
+++ include/client/mir_toolkit/mir_wait.h	2014-04-30 13:15:30 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2012-2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MIR_TOOLKIT_MIR_WAIT_H_
+#define MIR_TOOLKIT_MIR_WAIT_H_
+
+#include <mir_toolkit/client_types.h>
+
+#ifdef __cplusplus
+/**
+ * \addtogroup mir_toolkit
+ * @{
+ */
+extern "C" {
+#endif
+
+struct MirWaitHandle;
+
+/**
+ * Wait on the supplied handle until all instances of the associated request
+ * have completed.
+ *   \param [in] wait_handle  Handle returned by an asynchronous request
+ */
+void mir_wait_for(MirWaitHandle *wait_handle);
+
+/**
+ * Wait on the supplied handle until one instance of the associated request
+ * has completed. Use this instead of mir_wait_for in a threaded environment
+ * to ensure that the act of waiting does not clear all results associated
+ * with the wait handle; only one.
+ *   \param [in] wait_handle  Handle returned by an asynchronous request
+ */
+void mir_wait_for_one(MirWaitHandle *wait_handle);
+
+
+#ifdef __cplusplus
+}
+/**@}*/
+#endif
+
+#endif /* MIR_TOOLKIT_MIR_WAIT_H_ */

=== added file 'include/platform/mir/graphics/gl_program_factory.h'
--- include/platform/mir/graphics/gl_program_factory.h	1970-01-01 00:00:00 +0000
+++ include/platform/mir/graphics/gl_program_factory.h	2014-04-30 13:15:30 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_COMPOSITOR_GL_PROGRAM_FACTORY_H_
+#define MIR_COMPOSITOR_GL_PROGRAM_FACTORY_H_
+
+#include "mir/graphics/gl_program.h"
+#include <memory>
+
+namespace mir
+{
+namespace graphics
+{
+
+class GLProgramFactory
+{
+public:
+    virtual ~GLProgramFactory() = default;
+
+    virtual std::unique_ptr<GLProgram>
+        create_gl_program(std::string const&, std::string const&) const = 0;
+
+protected:
+    GLProgramFactory() = default;
+
+private:
+    GLProgramFactory(GLProgramFactory const&) = delete;
+    GLProgramFactory& operator=(GLProgramFactory const&) = delete;
+
+};
+
+}
+}
+
+#endif /* MIR_COMPOSITOR_GL_PROGRAM_FACTORY_H_ */

=== modified file 'include/platform/mir/graphics/renderable.h'
--- include/platform/mir/graphics/renderable.h	2014-03-28 22:40:30 +0000
+++ include/platform/mir/graphics/renderable.h	2014-04-30 13:15:30 +0000
@@ -33,6 +33,14 @@
 class Renderable
 {
 public:
+    typedef void const* ID; // Mostly opaque, but zero is reserved as "invalid"
+
+    /**
+     * Return a unique ID for the renderable, which may or may not be based
+     * on the underlying surface ID. You should not assume they are related.
+     */
+    virtual ID id() const = 0;
+
     /**
      * Return the next buffer that should be composited/rendered.
      *

=== modified file 'include/server/mir/compositor/gl_renderer.h'
--- include/server/mir/compositor/gl_renderer.h	2014-03-26 05:48:59 +0000
+++ include/server/mir/compositor/gl_renderer.h	2014-04-30 13:15:30 +0000
@@ -20,10 +20,14 @@
 #define MIR_COMPOSITOR_GL_RENDERER_H_
 
 #include <mir/compositor/renderer.h>
+#include <mir/graphics/gl_program.h>
 #include <mir/geometry/rectangle.h>
 #include <mir/graphics/buffer_id.h>
+#include <mir/graphics/renderable.h>
+#include <mir/graphics/gl_program_factory.h>
 #include <GLES2/gl2.h>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 namespace mir
@@ -34,15 +38,16 @@
 class GLRenderer : public Renderer
 {
 public:
-    GLRenderer(geometry::Rectangle const& display_area);
+    GLRenderer(
+        graphics::GLProgramFactory const& program_factory,
+        geometry::Rectangle const& display_area);
     virtual ~GLRenderer() noexcept;
 
     // These are called with a valid GL context:
     void set_viewport(geometry::Rectangle const& rect) override;
     void set_rotation(float degrees) override;
     void begin() const override;
-    void render(graphics::Renderable const& renderable,
-                graphics::Buffer& buffer) const override;
+    void render(graphics::Renderable const& renderable) const override;
     void end() const override;
 
     // This is called _without_ a GL context:
@@ -96,9 +101,7 @@
                                 graphics::Buffer& buffer) const;
 
 private:
-    GLuint vertex_shader;
-    GLuint fragment_shader;
-    GLuint program;
+    std::unique_ptr<graphics::GLProgram> program;
     GLuint position_attr_loc;
     GLuint texcoord_attr_loc;
     GLuint centre_uniform_loc;
@@ -109,14 +112,14 @@
 
     geometry::Rectangle viewport;
 
-    typedef graphics::Renderable const* SurfaceID;
     struct Texture
     {
         GLuint id = 0;
         graphics::BufferID origin;
         bool used;
     };
-    mutable std::unordered_map<SurfaceID, Texture> textures;
+    mutable std::unordered_map<graphics::Renderable::ID, Texture> textures;
+    mutable std::unordered_set<std::shared_ptr<graphics::Buffer>> saved_resources;
     mutable bool skipped = false;
 
 };

=== modified file 'include/server/mir/compositor/renderer.h'
--- include/server/mir/compositor/renderer.h	2014-03-26 05:48:59 +0000
+++ include/server/mir/compositor/renderer.h	2014-04-30 13:15:30 +0000
@@ -39,11 +39,7 @@
     virtual void set_viewport(geometry::Rectangle const& rect) = 0;
     virtual void set_rotation(float degrees) = 0;
     virtual void begin() const = 0;
-
-    // XXX The buffer parameter here could now be replaced with
-    //     renderable::buffer().
-    virtual void render(graphics::Renderable const& renderable,
-                        graphics::Buffer& buffer) const = 0;
+    virtual void render(graphics::Renderable const& renderable) const = 0;
     virtual void end() const = 0;
 
     virtual void suspend() = 0; // called when begin/render/end skipped

=== modified file 'include/server/mir/compositor/scene.h'
--- include/server/mir/compositor/scene.h	2014-03-31 17:06:37 +0000
+++ include/server/mir/compositor/scene.h	2014-04-30 13:15:30 +0000
@@ -27,37 +27,9 @@
 
 namespace mir
 {
-namespace graphics { class Renderable; }
 namespace compositor
 {
 
-class FilterForScene
-{
-public:
-    virtual ~FilterForScene() {}
-
-    virtual bool operator()(graphics::Renderable const&) = 0;
-
-protected:
-    FilterForScene() = default;
-    FilterForScene(const FilterForScene&) = delete;
-    FilterForScene& operator=(const FilterForScene&) = delete;
-};
-
-class OperatorForScene
-{
-public:
-    virtual ~OperatorForScene() {}
-
-    virtual void operator()(graphics::Renderable const&) = 0;
-
-protected:
-    OperatorForScene() = default;
-    OperatorForScene(const OperatorForScene&) = delete;
-    OperatorForScene& operator=(const OperatorForScene&) = delete;
-
-};
-
 class Scene
 {
 public:
@@ -69,9 +41,6 @@
      */
     virtual graphics::RenderableList generate_renderable_list() const = 0;
 
-    // Back to front; normal rendering order
-    virtual void for_each_if(FilterForScene& filter, OperatorForScene& op) = 0;
-
     /**
      * Sets a callback to be called whenever the state of the
      * Scene changes.
@@ -82,10 +51,6 @@
      */
     virtual void set_change_callback(std::function<void()> const& f) = 0;
 
-    // Implement BasicLockable, to temporarily lock scene state:
-    virtual void lock() = 0;
-    virtual void unlock() = 0;
-
 protected:
     Scene() = default;
 

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2014-03-31 10:59:59 +0000
+++ include/server/mir/default_server_configuration.h	2014-04-30 13:15:30 +0000
@@ -54,11 +54,8 @@
 
 namespace shell
 {
-class SurfaceFactory;
 class InputTargeter;
 class FocusSetter;
-class PlacementStrategy;
-class SessionListener;
 class FocusController;
 class DisplayLayout;
 }
@@ -73,17 +70,17 @@
 class BufferStreamFactory;
 class MediatingDisplayChanger;
 class PixelBuffer;
+class PlacementStrategy;
 class SessionContainer;
 class SessionEventSink;
 class SessionEventHandlerRegister;
+class SessionListener;
 class SessionManager;
 class SnapshotStrategy;
 class SurfaceCoordinator;
 class SurfaceConfigurator;
 class SurfaceStackModel;
 class SurfaceStack;
-class SurfaceRanker;
-class SurfaceController;
 class InputRegistrar;
 class SceneReport;
 }
@@ -95,6 +92,7 @@
 class DisplayReport;
 class GraphicBufferAllocator;
 class GLConfig;
+class GLProgramFactory;
 namespace nested { class HostConnection; }
 }
 namespace input
@@ -200,10 +198,9 @@
     /** @name shell configuration - customization
      * configurable interfaces for modifying shell
      *  @{ */
-    virtual std::shared_ptr<shell::SurfaceFactory>      the_shell_surface_factory();
     virtual std::shared_ptr<shell::FocusSetter>         the_shell_focus_setter();
-    virtual std::shared_ptr<shell::PlacementStrategy>   the_shell_placement_strategy();
-    virtual std::shared_ptr<shell::SessionListener>     the_shell_session_listener();
+    virtual std::shared_ptr<scene::PlacementStrategy>   the_placement_strategy();
+    virtual std::shared_ptr<scene::SessionListener>     the_session_listener();
     virtual std::shared_ptr<shell::DisplayLayout>       the_shell_display_layout();
     /** @} */
 
@@ -217,7 +214,6 @@
     virtual std::shared_ptr<scene::SessionEventSink>  the_session_event_sink();
     virtual std::shared_ptr<scene::SessionEventHandlerRegister> the_session_event_handler_register();
     virtual std::shared_ptr<scene::SurfaceStackModel> the_surface_stack_model();
-    virtual std::shared_ptr<scene::SurfaceRanker>     the_surface_ranker();
     virtual std::shared_ptr<scene::SurfaceFactory>    the_surface_factory();
     virtual std::shared_ptr<scene::SurfaceCoordinator>the_surface_coordinator();
     virtual std::shared_ptr<scene::SurfaceConfigurator> the_surface_configurator();
@@ -252,6 +248,7 @@
 protected:
     std::shared_ptr<options::Option> the_options() const;
 
+    virtual std::shared_ptr<graphics::GLProgramFactory> the_gl_program_factory();
     virtual std::shared_ptr<input::InputChannelFactory> the_input_channel_factory();
     virtual std::shared_ptr<scene::MediatingDisplayChanger> the_mediating_display_changer();
     virtual std::shared_ptr<frontend::ProtobufIpcFactory> the_ipc_factory(
@@ -287,12 +284,12 @@
     CachedPtr<scene::SurfaceStack> surface_stack;
     CachedPtr<scene::SceneReport> scene_report;
 
-    CachedPtr<shell::SurfaceFactory> shell_surface_factory;
     CachedPtr<scene::SurfaceFactory> surface_factory;
     CachedPtr<scene::SessionContainer>  session_container;
+    CachedPtr<scene::SurfaceCoordinator> surface_coordinator;
     CachedPtr<shell::FocusSetter>       shell_focus_setter;
-    CachedPtr<shell::PlacementStrategy> shell_placement_strategy;
-    CachedPtr<shell::SessionListener> shell_session_listener;
+    CachedPtr<scene::PlacementStrategy> shell_placement_strategy;
+    CachedPtr<scene::SessionListener> session_listener;
     CachedPtr<scene::PixelBuffer>       pixel_buffer;
     CachedPtr<scene::SnapshotStrategy>  snapshot_strategy;
     CachedPtr<shell::DisplayLayout>     shell_display_layout;
@@ -308,6 +305,7 @@
     CachedPtr<graphics::DisplayConfigurationPolicy> display_configuration_policy;
     CachedPtr<graphics::nested::HostConnection> host_connection;
     CachedPtr<scene::MediatingDisplayChanger> mediating_display_changer;
+    CachedPtr<graphics::GLProgramFactory> gl_program_factory;
     CachedPtr<graphics::GLConfig> gl_config;
 
 private:
@@ -320,13 +318,11 @@
     // default implementations of corresponding the Mir components
     CachedPtr<scene::BroadcastingSessionEventSink> broadcasting_session_event_sink;
     CachedPtr<input::NestedInputRelay> nested_input_relay;
-    CachedPtr<scene::SurfaceController> surface_controller;
     CachedPtr<scene::SessionManager> session_manager;
 
     std::shared_ptr<scene::BroadcastingSessionEventSink> the_broadcasting_session_event_sink();
     std::shared_ptr<input::NestedInputRelay>        the_nested_input_relay();
     std::shared_ptr<scene::SessionManager>       the_session_manager();
-    std::shared_ptr<scene::SurfaceController>    the_surface_controller();
 
     auto report_factory(char const* report_opt) -> std::unique_ptr<report::ReportFactory>;
 };

=== modified file 'include/server/mir/frontend/session.h'
--- include/server/mir/frontend/session.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/frontend/session.h	2014-04-30 13:15:30 +0000
@@ -29,7 +29,7 @@
 
 namespace mir
 {
-namespace shell
+namespace scene
 {
 struct SurfaceCreationParameters;
 }
@@ -48,7 +48,7 @@
 public:
     virtual ~Session() {}
 
-    virtual SurfaceId create_surface(shell::SurfaceCreationParameters const& params) = 0;
+    virtual SurfaceId create_surface(scene::SurfaceCreationParameters const& params) = 0;
     virtual void destroy_surface(SurfaceId surface) = 0;
     virtual std::shared_ptr<Surface> get_surface(SurfaceId surface) const = 0;
 
@@ -57,9 +57,6 @@
     virtual void hide() = 0;
     virtual void show() = 0;
 
-    virtual void send_display_config(graphics::DisplayConfiguration const&) = 0;
-    virtual int configure_surface(SurfaceId id, MirSurfaceAttrib attrib, int value) = 0;
-
 protected:
     Session() = default;
     Session(Session const&) = delete;

=== modified file 'include/server/mir/frontend/shell.h'
--- include/server/mir/frontend/shell.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/frontend/shell.h	2014-04-30 13:15:30 +0000
@@ -27,7 +27,7 @@
 
 namespace mir
 {
-namespace shell
+namespace scene
 {
 struct SurfaceCreationParameters;
 }
@@ -48,8 +48,9 @@
 
     virtual void close_session(std::shared_ptr<Session> const& session)  = 0;
 
-    virtual SurfaceId create_surface_for(std::shared_ptr<Session> const& session,
-                                         shell::SurfaceCreationParameters const& params) = 0;
+    virtual SurfaceId create_surface_for(
+        std::shared_ptr<Session> const& session,
+        scene::SurfaceCreationParameters const& params) = 0;
 
     virtual void handle_surface_created(std::shared_ptr<Session> const& session) = 0;
 

=== modified file 'include/server/mir/frontend/surface.h'
--- include/server/mir/frontend/surface.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/frontend/surface.h	2014-04-30 13:15:30 +0000
@@ -51,8 +51,6 @@
 
     virtual ~Surface() {}
 
-    virtual void force_requests_to_complete() = 0;
-
     virtual geometry::Size size() const = 0;
     virtual MirPixelFormat pixel_format() const = 0;
 

=== added file 'include/server/mir/graphics/gl_program.h'
--- include/server/mir/graphics/gl_program.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/graphics/gl_program.h	2014-04-30 13:15:30 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright © 2013-2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_GL_PROGRAM_H_
+#define MIR_GRAPHICS_GL_PROGRAM_H_
+
+#include <GLES2/gl2.h>
+
+namespace mir
+{
+namespace graphics
+{
+
+class GLShader
+{
+public:
+    GLShader(GLchar const* shader_src, GLuint type);
+    ~GLShader();
+    operator GLuint() const;
+
+private:
+    GLShader(GLShader const&) = delete;
+    GLShader& operator=(GLShader const&) = delete;
+
+    GLuint const shader;
+};
+
+class GLProgram
+{
+public:
+    GLProgram(
+        GLchar const* vertex_shader_src,
+        GLchar const* fragment_shader_src);
+    ~GLProgram();
+
+    operator GLuint() const;
+
+private:
+    GLProgram(GLProgram const&) = delete;
+    GLProgram& operator=(GLProgram const&) = delete;
+
+    GLShader const vertex_shader; 
+    GLShader const fragment_shader;
+    GLuint const program;
+};
+
+}
+}
+
+#endif /* MIR_GRAPHICS_GL_PROGRAM_H_ */

=== modified file 'include/server/mir/input/input_targets.h'
--- include/server/mir/input/input_targets.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/input/input_targets.h	2014-04-30 13:15:30 +0000
@@ -28,14 +28,14 @@
 {
 namespace input
 {
-class InputChannel;
+class Surface;
 
 class InputTargets
 {
 public:
     virtual ~InputTargets() = default;
 
-    virtual void for_each(std::function<void(std::shared_ptr<input::InputChannel> const&)> const& callback) = 0;
+    virtual void for_each(std::function<void(std::shared_ptr<input::Surface> const&)> const& callback) = 0;
 
 protected:
     InputTargets() = default;

=== modified file 'include/server/mir/input/surface.h'
--- include/server/mir/input/surface.h	2014-03-26 05:48:59 +0000
+++ include/server/mir/input/surface.h	2014-04-30 13:15:30 +0000
@@ -21,12 +21,16 @@
 
 #include "mir/geometry/size.h"
 #include "mir/geometry/point.h"
+
 #include <string>
+#include <memory>
 
 namespace mir
 {
 namespace input
 {
+class InputChannel;
+
 class Surface
 {
 public:
@@ -35,6 +39,8 @@
     virtual geometry::Size size() const = 0;
     virtual bool contains(geometry::Point const& point) const = 0;
 
+    virtual std::shared_ptr<input::InputChannel> input_channel() const = 0;
+
 protected:
     Surface() = default;
     virtual ~Surface() = default;

=== renamed file 'include/server/mir/shell/null_session_listener.h' => 'include/server/mir/scene/null_session_listener.h'
--- include/server/mir/shell/null_session_listener.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/scene/null_session_listener.h	2014-04-30 13:15:30 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -16,17 +16,15 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
-#ifndef MIR_SHELL_NULL_SESSION_LISTENER_H_
-#define MIR_SHELL_NULL_SESSION_LISTENER_H_
+#ifndef MIR_SCENE_NULL_SESSION_LISTENER_H_
+#define MIR_SCENE_NULL_SESSION_LISTENER_H_
 
-#include "mir/shell/session_listener.h"
+#include "mir/scene/session_listener.h"
 
 namespace mir
 {
-namespace shell
+namespace scene
 {
-class Session;
-
 class NullSessionListener : public SessionListener
 {
 public:
@@ -49,5 +47,4 @@
 }
 }
 
-
-#endif // MIR_SHELL_NULL_SESSION_LISTENER_H_
+#endif // MIR_SCENE_NULL_SESSION_LISTENER_H_

=== renamed file 'include/server/mir/shell/placement_strategy.h' => 'include/server/mir/scene/placement_strategy.h'
--- include/server/mir/shell/placement_strategy.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/scene/placement_strategy.h	2014-04-30 13:15:30 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -16,13 +16,12 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
-#ifndef MIR_SHELL_PLACEMENT_STRATEGY_H_
-#define MIR_SHELL_PLACEMENT_STRATEGY_H_
+#ifndef MIR_SCENE_PLACEMENT_STRATEGY_H_
+#define MIR_SCENE_PLACEMENT_STRATEGY_H_
 
 namespace mir
 {
-
-namespace shell
+namespace scene
 {
 class Session;
 struct SurfaceCreationParameters;
@@ -30,19 +29,16 @@
 class PlacementStrategy
 {
 public:
-    virtual ~PlacementStrategy() {}
-    // TODO: It is strange to work in terms of SurfaceCreationParameters here,
-    // perhaps a new interface is needed.
-    virtual SurfaceCreationParameters place(shell::Session const& session, SurfaceCreationParameters const& request_parameters) = 0;
+    virtual ~PlacementStrategy() = default;
 
+    virtual SurfaceCreationParameters place(Session const& session, SurfaceCreationParameters const& request_parameters) = 0;
 
 protected:
     PlacementStrategy() = default;
     PlacementStrategy(PlacementStrategy const&) = delete;
     PlacementStrategy& operator=(PlacementStrategy const&) = delete;
 };
-
 }
 } // namespace mir
 
-#endif // MIR_SHELL_PLACEMENT_STRATEGY_H_
+#endif // MIR_SCENE_PLACEMENT_STRATEGY_H_

=== renamed file 'include/server/mir/shell/session.h' => 'include/server/mir/scene/session.h'
--- include/server/mir/shell/session.h	2014-03-26 05:48:59 +0000
+++ include/server/mir/scene/session.h	2014-04-30 13:15:30 +0000
@@ -16,17 +16,17 @@
  * Authored By: Robert Carr <[e-mail]>
  */
 
-#ifndef MIR_SHELL_SESSION_H_
-#define MIR_SHELL_SESSION_H_
+#ifndef MIR_SCENE_SESSION_H_
+#define MIR_SCENE_SESSION_H_
 
 #include "mir/frontend/session.h"
-#include "mir/shell/snapshot.h"
+#include "mir/scene/snapshot.h"
 
 #include <sys/types.h>
 
 namespace mir
 {
-namespace shell
+namespace scene
 {
 class Surface;
 
@@ -39,8 +39,9 @@
     virtual void take_snapshot(SnapshotCallback const& snapshot_taken) = 0;
     virtual std::shared_ptr<Surface> default_surface() const = 0;
     virtual void set_lifecycle_state(MirLifecycleState state) = 0;
+    virtual void send_display_config(graphics::DisplayConfiguration const&) = 0;
 };
 }
 }
 
-#endif // MIR_SHELL_SESSION_H_
+#endif // MIR_SCENE_SESSION_H_

=== renamed file 'include/server/mir/shell/session_listener.h' => 'include/server/mir/scene/session_listener.h'
--- include/server/mir/shell/session_listener.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/scene/session_listener.h	2014-04-30 13:15:30 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -16,17 +16,17 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
-#ifndef MIR_SHELL_SESSION_LISTENER_H_
-#define MIR_SHELL_SESSION_LISTENER_H_
+#ifndef MIR_SCENE_SESSION_LISTENER_H_
+#define MIR_SCENE_SESSION_LISTENER_H_
 
 #include <memory>
 
 namespace mir
 {
-namespace shell
+namespace scene
 {
+class Surface;
 class Session;
-class Surface;
 
 class SessionListener
 {
@@ -51,4 +51,4 @@
 }
 
 
-#endif // MIR_SHELL_SESSION_LISTENER_H_
+#endif // MIR_SCENE_SESSION_LISTENER_H_

=== renamed file 'include/server/mir/shell/snapshot.h' => 'include/server/mir/scene/snapshot.h'
--- include/server/mir/shell/snapshot.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/scene/snapshot.h	2014-04-30 13:15:30 +0000
@@ -26,7 +26,7 @@
 
 namespace mir
 {
-namespace shell
+namespace scene
 {
 
 struct Snapshot

=== modified file 'include/server/mir/scene/surface.h'
--- include/server/mir/scene/surface.h	2014-03-31 09:27:58 +0000
+++ include/server/mir/scene/surface.h	2014-04-30 13:15:30 +0000
@@ -21,11 +21,16 @@
 
 #include "mir/graphics/renderable.h"
 #include "mir/input/surface.h"
-#include "mir/shell/surface.h"
+#include "mir/scene/surface_buffer_access.h"
+#include "mir/frontend/surface.h"
+
+#include <vector>
 
 namespace mir
 {
 namespace input { class InputChannel; }
+namespace shell { class InputTargeter; }
+namespace geometry { class Rectangle; }
 
 namespace scene
 {
@@ -34,24 +39,36 @@
 class Surface :
     public graphics::Renderable,
     public input::Surface,
-    public shell::Surface
+    public frontend::Surface,
+    public SurfaceBufferAccess
 {
 public:
     // resolve ambiguous member function names
-    std::string name() const = 0;
-    geometry::Size size() const = 0;
-    geometry::Point top_left() const = 0;
-    float alpha() const = 0;
+    std::string name() const override = 0;
+    geometry::Size size() const override = 0;
+    geometry::Point top_left() const override = 0;
+    float alpha() const override = 0;
 
     // member functions that don't exist in base classes
-    // TODO input_channel() and on_change() relate to
-    // TODO adding and removing the surface from the scene and are probably not
-    // TODO cleanest interface for this.
-    virtual std::shared_ptr<input::InputChannel> input_channel() const = 0;
-    virtual void on_change(std::function<void()> change_notification) = 0;
+    virtual MirSurfaceType type() const = 0;
+    virtual MirSurfaceState state() const = 0;
+    virtual void hide() = 0;
+    virtual void show() = 0;
+    virtual void move_to(geometry::Point const& top_left) = 0;
+    virtual void take_input_focus(std::shared_ptr<shell::InputTargeter> const& targeter) = 0;
+    virtual void set_input_region(std::vector<geometry::Rectangle> const& region) = 0;
+    virtual void allow_framedropping(bool) = 0;
+    virtual void resize(geometry::Size const& size) = 0;
+    virtual void set_transformation(glm::mat4 const& t) = 0;
+    virtual void set_alpha(float alpha) = 0;
+    virtual void force_requests_to_complete() = 0;
 
     virtual void add_observer(std::shared_ptr<SurfaceObserver> const& observer) = 0;
     virtual void remove_observer(std::shared_ptr<SurfaceObserver> const& observer) = 0;
+
+    // TODO input_channel() relates to adding and removing the surface
+    // TODO from the scene and is probably not cleanest interface for this.
+    virtual std::shared_ptr<input::InputChannel> input_channel() const = 0;
 };
 }
 }

=== renamed file 'include/server/mir/shell/surface_buffer_access.h' => 'include/server/mir/scene/surface_buffer_access.h'
--- include/server/mir/shell/surface_buffer_access.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/scene/surface_buffer_access.h	2014-04-30 13:15:30 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -16,8 +16,8 @@
  * Authored by: Alexandros Frantzis <[e-mail]>
  */
 
-#ifndef MIR_SHELL_SURFACE_BUFFER_ACCESS_H_
-#define MIR_SHELL_SURFACE_BUFFER_ACCESS_H_
+#ifndef MIR_SCENE_SURFACE_BUFFER_ACCESS_H_
+#define MIR_SCENE_SURFACE_BUFFER_ACCESS_H_
 
 #include <functional>
 
@@ -27,7 +27,7 @@
 {
 class Buffer;
 }
-namespace shell
+namespace scene
 {
 
 class SurfaceBufferAccess
@@ -47,4 +47,4 @@
 }
 }
 
-#endif /* MIR_SHELL_SURFACE_BUFFER_ACCESS_H_ */
+#endif /* MIR_SCENE_SURFACE_BUFFER_ACCESS_H_ */

=== modified file 'include/server/mir/scene/surface_coordinator.h'
--- include/server/mir/scene/surface_coordinator.h	2014-03-28 17:47:07 +0000
+++ include/server/mir/scene/surface_coordinator.h	2014-04-30 13:15:30 +0000
@@ -20,28 +20,25 @@
 #ifndef MIR_SCENE_SURFACE_COORDINATOR_H_
 #define MIR_SCENE_SURFACE_COORDINATOR_H_
 
-#include "mir/scene/surface_ranker.h"
-
 #include <memory>
 
 namespace mir
 {
-namespace shell
-{
-struct SurfaceCreationParameters;
-}
-
 namespace scene
 {
 class Surface;
+struct SurfaceCreationParameters;
 class SurfaceObserver;
+class Session;
 
-class SurfaceCoordinator : public SurfaceRanker
+class SurfaceCoordinator
 {
 public:
     virtual std::shared_ptr<Surface> add_surface(
-        shell::SurfaceCreationParameters const& params,
-        std::shared_ptr<SurfaceObserver> const& observer) = 0;
+        SurfaceCreationParameters const& params,
+        Session* session) = 0;
+
+    virtual void raise(std::weak_ptr<Surface> const& surface) = 0;
 
     virtual void remove_surface(std::weak_ptr<Surface> const& surface) = 0;
 protected:

=== renamed file 'include/server/mir/shell/surface_creation_parameters.h' => 'include/server/mir/scene/surface_creation_parameters.h'
--- include/server/mir/shell/surface_creation_parameters.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/scene/surface_creation_parameters.h	2014-04-30 13:15:30 +0000
@@ -16,8 +16,8 @@
  * Authored by: Alan Griffiths <[e-mail]>
  */
 
-#ifndef MIR_SHELL_SURFACE_CREATION_PARAMETERS_H_
-#define MIR_SHELL_SURFACE_CREATION_PARAMETERS_H_
+#ifndef MIR_SCENE_SURFACE_CREATION_PARAMETERS_H_
+#define MIR_SCENE_SURFACE_CREATION_PARAMETERS_H_
 
 #include "mir_toolkit/common.h"
 #include "mir/geometry/point.h"
@@ -32,7 +32,7 @@
 
 namespace mir
 {
-namespace shell
+namespace scene
 {
 
 struct SurfaceCreationParameters
@@ -74,4 +74,4 @@
 }
 }
 
-#endif /* MIR_SHELL_SURFACE_CREATION_PARAMETERS_H_ */
+#endif /* MIR_SCENE_SURFACE_CREATION_PARAMETERS_H_ */

=== modified file 'include/server/mir/scene/surface_event_source.h'
--- include/server/mir/scene/surface_event_source.h	2014-03-31 09:02:16 +0000
+++ include/server/mir/scene/surface_event_source.h	2014-04-30 13:15:30 +0000
@@ -36,8 +36,8 @@
         frontend::SurfaceId id,
         std::shared_ptr<frontend::EventSink> const& event_sink);
 
-    void attrib_change(MirSurfaceAttrib attrib, int value);
-    void resize(geometry::Size const& size);
+    void attrib_changed(MirSurfaceAttrib attrib, int value);
+    void resized_to(geometry::Size const& size);
 
 private:
     frontend::SurfaceId const id;

=== modified file 'include/server/mir/scene/surface_factory.h'
--- include/server/mir/scene/surface_factory.h	2014-03-31 10:18:49 +0000
+++ include/server/mir/scene/surface_factory.h	2014-04-30 13:15:30 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_SCENE_SURFACE_FACTORY_H_
 #define MIR_SCENE_SURFACE_FACTORY_H_
 
-#include "mir/shell/surface_creation_parameters.h"
+#include "mir/scene/surface_creation_parameters.h"
 #include <memory>
 
 namespace mir
@@ -34,8 +34,7 @@
     SurfaceFactory() = default;
     virtual ~SurfaceFactory() = default;
 
-    virtual std::shared_ptr<Surface> create_surface(
-        shell::SurfaceCreationParameters const& params) = 0;
+    virtual std::shared_ptr<Surface> create_surface(SurfaceCreationParameters const& params) = 0;
 
 private:
     SurfaceFactory(const SurfaceFactory&) = delete;

=== modified file 'include/server/mir/scene/surface_observer.h'
--- include/server/mir/scene/surface_observer.h	2014-03-31 09:02:16 +0000
+++ include/server/mir/scene/surface_observer.h	2014-04-30 13:15:30 +0000
@@ -19,19 +19,30 @@
 #ifndef MIR_SCENE_SURFACE_OBSERVER_H_
 #define MIR_SCENE_SURFACE_OBSERVER_H_
 
-#include "mir/geometry/size.h"
 #include "mir_toolkit/common.h"
 
+#include <glm/glm.hpp>
+
 namespace mir
 {
+namespace geometry
+{
+struct Size;
+struct Point;
+}
+
 namespace scene
 {
-// Initial cut - supporting the frontend requirement, more will follow
 class SurfaceObserver
 {
 public:
-    virtual void attrib_change(MirSurfaceAttrib attrib, int value) = 0;
-    virtual void resize(geometry::Size const& size) = 0;
+    virtual void attrib_changed(MirSurfaceAttrib attrib, int value);
+    virtual void resized_to(geometry::Size const& size);
+    virtual void moved_to(geometry::Point const& top_left);
+    virtual void hidden_set_to(bool hide);
+    virtual void frame_posted();
+    virtual void alpha_set_to(float alpha);
+    virtual void transformation_set_to(glm::mat4 const& t);
 
 protected:
     SurfaceObserver() = default;

=== removed file 'include/server/mir/scene/surface_ranker.h'
--- include/server/mir/scene/surface_ranker.h	2014-03-26 14:20:14 +0000
+++ include/server/mir/scene/surface_ranker.h	1970-01-01 00:00:00 +0000
@@ -1,46 +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_SHELL_SURFACE_RANKER_H_
-#define MIR_SHELL_SURFACE_RANKER_H_
-
-#include <memory>
-
-namespace mir
-{
-namespace scene
-{
-class Surface;
-
-class SurfaceRanker
-{
-public:
-    virtual void raise(std::weak_ptr<Surface> const& surface) = 0;
-
-protected:
-    SurfaceRanker() = default;
-    virtual ~SurfaceRanker() = default;
-    SurfaceRanker(SurfaceRanker const&) = delete;
-    SurfaceRanker& operator=(SurfaceRanker const&) = delete;
-};
-}
-}
-
-
-#endif /* MIR_SHELL_SURFACE_RANKER_H_ */

=== modified file 'include/server/mir/shell/focus_controller.h'
--- include/server/mir/shell/focus_controller.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/shell/focus_controller.h	2014-04-30 13:15:30 +0000
@@ -23,9 +23,10 @@
 
 namespace mir
 {
+namespace scene { class Session; }
+
 namespace shell
 {
-class Session;
 
 class FocusController
 {
@@ -33,8 +34,8 @@
     virtual ~FocusController() = default;
 
     virtual void focus_next() = 0;
-    virtual std::weak_ptr<Session> focussed_application() const = 0;
-    virtual void set_focus_to(std::shared_ptr<Session> const& focus) = 0;
+    virtual std::weak_ptr<scene::Session> focussed_application() const = 0;
+    virtual void set_focus_to(std::shared_ptr<scene::Session> const& focus) = 0;
 
 protected:
     FocusController() = default;

=== modified file 'include/server/mir/shell/focus_setter.h'
--- include/server/mir/shell/focus_setter.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/shell/focus_setter.h	2014-04-30 13:15:30 +0000
@@ -23,11 +23,11 @@
 
 namespace mir
 {
+namespace scene { class Session; }
+
 
 namespace shell
 {
-class Session;
-
 /// Interface used by the Shell to propagate changes in the focus model to interested views
 /// e.g. Input, or Surfaces.
 class FocusSetter
@@ -35,7 +35,7 @@
 public:
     virtual ~FocusSetter() {}
 
-    virtual void set_focus_to(std::shared_ptr<shell::Session> const& new_focus) = 0;
+    virtual void set_focus_to(std::shared_ptr<scene::Session> const& new_focus) = 0;
 
 protected:
     FocusSetter() = default;

=== removed file 'include/server/mir/shell/surface.h'
--- include/server/mir/shell/surface.h	2014-03-26 14:20:14 +0000
+++ include/server/mir/shell/surface.h	1970-01-01 00:00:00 +0000
@@ -1,62 +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: Alan Griffiths <[e-mail]>
- */
-
-
-#ifndef MIR_SHELL_SURFACE_H_
-#define MIR_SHELL_SURFACE_H_
-
-#include "mir/shell/surface_buffer_access.h"
-#include "mir/geometry/rectangle.h"
-#include "mir/frontend/surface.h"
-
-#include <string>
-#include <vector>
-
-namespace mir
-{
-namespace scene { class SurfaceRanker; }
-namespace shell
-{
-class InputTargeter;
-
-class Surface : public frontend::Surface, public shell::SurfaceBufferAccess
-{
-public:
-    virtual std::string name() const = 0;
-    virtual MirSurfaceType type() const = 0;
-    virtual MirSurfaceState state() const = 0;
-    virtual void hide() = 0;
-    virtual void show() = 0;
-    virtual void move_to(geometry::Point const& top_left) = 0;
-    virtual geometry::Point top_left() const = 0;
-
-    virtual void take_input_focus(std::shared_ptr<InputTargeter> const& targeter) = 0;
-    virtual void set_input_region(std::vector<geometry::Rectangle> const& region) = 0;
-
-    virtual void allow_framedropping(bool) = 0;
-
-    virtual void resize(geometry::Size const& size) = 0;
-    virtual void set_transformation(glm::mat4 const& t) = 0;
-
-    virtual float alpha() const = 0;
-    virtual void set_alpha(float alpha) = 0;
-};
-}
-}
-
-#endif /* MIR_SHELL_SURFACE_H_ */

=== removed file 'include/server/mir/shell/surface_factory.h'
--- include/server/mir/shell/surface_factory.h	2014-03-28 17:47:07 +0000
+++ include/server/mir/shell/surface_factory.h	1970-01-01 00:00:00 +0000
@@ -1,53 +0,0 @@
-/*
- * Copyright © 2012-2014 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Thomas Voss <[e-mail]>
- */
-
-#ifndef MIR_SHELL_SURFACE_FACTORY_H_
-#define MIR_SHELL_SURFACE_FACTORY_H_
-
-#include <memory>
-
-namespace mir
-{
-namespace scene { class SurfaceObserver; }
-
-namespace shell
-{
-class Session;
-class Surface;
-struct SurfaceCreationParameters;
-
-class SurfaceFactory
-{
-public:
-    virtual std::shared_ptr<Surface> create_surface(
-        Session* session,
-        SurfaceCreationParameters const& params,
-        std::shared_ptr<scene::SurfaceObserver> const& observer) = 0;
-
-    virtual void destroy_surface(std::shared_ptr<Surface> const& surface) = 0;
-
-protected:
-    virtual ~SurfaceFactory() {}
-    SurfaceFactory() = default;
-    SurfaceFactory(const SurfaceFactory&) = delete;
-    SurfaceFactory& operator=(const SurfaceFactory&) = delete;
-};
-}
-}
-
-#endif // MIR_SHELL_SURFACE_FACTORY_H_

=== added file 'include/test/mir_test/spin_wait.h'
--- include/test/mir_test/spin_wait.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test/spin_wait.h	2014-04-30 13:15:30 +0000
@@ -0,0 +1,38 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_TEST_SPIN_WAIT_H_
+#define MIR_TEST_SPIN_WAIT_H_
+
+#include <functional>
+#include <chrono>
+
+namespace mir
+{
+namespace test
+{
+
+bool spin_wait_for_condition_or_timeout(
+    std::function<bool()> const& condition,
+    std::chrono::milliseconds timeout,
+    std::chrono::milliseconds spin_period = std::chrono::milliseconds{10});
+
+}
+}
+
+#endif /* MIR_TEST_SPIN_WAIT_H_ */

=== modified file 'include/test/mir_test/wait_condition.h'
--- include/test/mir_test/wait_condition.h	2013-04-24 05:22:20 +0000
+++ include/test/mir_test/wait_condition.h	2014-04-30 13:15:30 +0000
@@ -31,24 +31,31 @@
 {
 struct WaitCondition
 {
-    WaitCondition() : woken(false) {}
+    WaitCondition() : woken_(false) {}
 
     void wait_for_at_most_seconds(int seconds)
     {
         std::unique_lock<std::mutex> ul(guard);
-        if (!woken) condition.wait_for(ul, std::chrono::seconds(seconds));
+        condition.wait_for(ul, std::chrono::seconds(seconds),
+                           [this] { return woken_; });
     }
 
     void wake_up_everyone()
     {
         std::unique_lock<std::mutex> ul(guard);
-        woken = true;
+        woken_ = true;
         condition.notify_all();
     }
 
+    bool woken()
+    {
+        std::unique_lock<std::mutex> ul(guard);
+        return woken_;
+    }
+
     std::mutex guard;
     std::condition_variable condition;
-    bool woken;
+    bool woken_;
 };
 
 ACTION_P(ReturnFalseAndWakeUp, wait_condition)

=== modified file 'include/test/mir_test_doubles/fake_renderable.h'
--- include/test/mir_test_doubles/fake_renderable.h	2014-03-28 22:40:30 +0000
+++ include/test/mir_test_doubles/fake_renderable.h	2014-04-30 13:15:30 +0000
@@ -47,6 +47,11 @@
     {
     }
 
+    ID id() const override
+    {
+        return this;
+    }
+
     float alpha() const override
     {
         return opacity;

=== modified file 'include/test/mir_test_doubles/mock_buffer_stream.h'
--- include/test/mir_test_doubles/mock_buffer_stream.h	2014-03-26 05:48:59 +0000
+++ include/test/mir_test_doubles/mock_buffer_stream.h	2014-04-30 13:15:30 +0000
@@ -31,6 +31,19 @@
 {
 struct MockBufferStream : public compositor::BufferStream
 {
+    int buffers_ready_{0};
+    int buffers_ready()
+    {
+        if (buffers_ready_)
+            return buffers_ready_--;
+        return 0;
+    }
+
+    MockBufferStream()
+    {
+        ON_CALL(*this, buffers_ready_for_compositor())
+            .WillByDefault(testing::Invoke(this, &MockBufferStream::buffers_ready));
+    }
     MOCK_METHOD2(swap_client_buffers, void(graphics::Buffer*, std::function<void(graphics::Buffer*)> completee));
     MOCK_METHOD1(lock_compositor_buffer,
                  std::shared_ptr<graphics::Buffer>(void const*));
@@ -42,7 +55,7 @@
     MOCK_METHOD0(force_client_completion, void());
     MOCK_METHOD1(allow_framedropping, void(bool));
     MOCK_METHOD0(force_requests_to_complete, void());
-    int buffers_ready_for_compositor() const override { return 1; }
+    MOCK_CONST_METHOD0(buffers_ready_for_compositor, int());
 };
 }
 }

=== modified file 'include/test/mir_test_doubles/mock_focus_setter.h'
--- include/test/mir_test_doubles/mock_focus_setter.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/mock_focus_setter.h	2014-04-30 13:15:30 +0000
@@ -32,7 +32,7 @@
 
 struct MockFocusSetter : public shell::FocusSetter
 {
-    MOCK_METHOD1(set_focus_to, void(std::shared_ptr<shell::Session> const&));
+    MOCK_METHOD1(set_focus_to, void(std::shared_ptr<scene::Session> const&));
 };
 
 }

=== modified file 'include/test/mir_test_doubles/mock_framebuffer_bundle.h'
--- include/test/mir_test_doubles/mock_framebuffer_bundle.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/mock_framebuffer_bundle.h	2014-04-30 13:15:30 +0000
@@ -40,6 +40,7 @@
     }
     MOCK_METHOD0(fb_format, MirPixelFormat());
     MOCK_METHOD0(fb_size, geometry::Size());
+    MOCK_METHOD0(fb_refresh_rate, double());
     MOCK_METHOD0(buffer_for_render, std::shared_ptr<graphics::Buffer>());
     MOCK_METHOD0(last_rendered_buffer, std::shared_ptr<graphics::Buffer>());
     MOCK_METHOD1(wait_for_consumed_buffer, void(bool));

=== modified file 'include/test/mir_test_doubles/mock_input_surface.h'
--- include/test/mir_test_doubles/mock_input_surface.h	2014-03-26 05:48:59 +0000
+++ include/test/mir_test_doubles/mock_input_surface.h	2014-04-30 13:15:30 +0000
@@ -34,7 +34,7 @@
 public:
     MockInputSurface()
     {
-        using namespace testing;
+        using namespace ::testing;
         ON_CALL(*this, top_left())
             .WillByDefault(
                 Return(geometry::Point{}));
@@ -43,13 +43,17 @@
                 Return(geometry::Size{}));
         static std::string n;
         ON_CALL(*this, name())
-            .WillByDefault(testing::Return(n));
+            .WillByDefault(Return(n));
+        static std::shared_ptr<input::InputChannel> c{nullptr};
+        ON_CALL(*this, input_channel())
+            .WillByDefault(Return(c));
     }
     ~MockInputSurface() noexcept {}
     MOCK_CONST_METHOD0(top_left, geometry::Point());
     MOCK_CONST_METHOD0(size, geometry::Size());
     MOCK_CONST_METHOD0(name, std::string());
     MOCK_CONST_METHOD1(contains, bool(geometry::Point const&));
+    MOCK_CONST_METHOD0(input_channel, std::shared_ptr<input::InputChannel>());
 };
 
 typedef ::testing::NiceMock<MockInputSurface> StubInputSurface;

=== removed file 'include/test/mir_test_doubles/mock_render_function.h.moved'
--- include/test/mir_test_doubles/mock_render_function.h.moved	2014-02-25 22:02:56 +0000
+++ include/test/mir_test_doubles/mock_render_function.h.moved	1970-01-01 00:00:00 +0000
@@ -1,40 +0,0 @@
-/*
- * Copyright © 2014 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Kevin DuBois <[e-mail]>
- */
-
-#ifndef MIR_TEST_DOUBLES_MOCK_RENDER_FUNCTION_H_
-#define MIR_TEST_DOUBLES_MOCK_RENDER_FUNCTION_H_
-
-#include <mir/graphics/renderable.h>
-
-namespace mir
-{
-namespace test
-{
-namespace doubles
-{
-
-struct MockRenderFunction
-{
-    MOCK_METHOD1(called, void(graphics::Renderable const&));
-};
-
-}
-}
-}
-
-#endif /* MIR_TEST_DOUBLES_MOCK_RENDER_FUNCTION_H_ */

=== modified file 'include/test/mir_test_doubles/mock_renderable.h'
--- include/test/mir_test_doubles/mock_renderable.h	2014-04-01 20:39:59 +0000
+++ include/test/mir_test_doubles/mock_renderable.h	2014-04-30 13:15:30 +0000
@@ -47,6 +47,7 @@
             .WillByDefault(testing::Return(true));
     }
 
+    MOCK_CONST_METHOD0(id, ID());
     MOCK_CONST_METHOD1(buffer, std::shared_ptr<graphics::Buffer>(void const*));
     MOCK_CONST_METHOD0(alpha_enabled, bool());
     MOCK_CONST_METHOD0(screen_position, geometry::Rectangle());

=== modified file 'include/test/mir_test_doubles/mock_renderer.h'
--- include/test/mir_test_doubles/mock_renderer.h	2014-03-26 05:48:59 +0000
+++ include/test/mir_test_doubles/mock_renderer.h	2014-04-30 13:15:30 +0000
@@ -34,7 +34,7 @@
     MOCK_METHOD1(set_viewport, void(geometry::Rectangle const&));
     MOCK_METHOD1(set_rotation, void(float));
     MOCK_CONST_METHOD0(begin, void());
-    MOCK_CONST_METHOD2(render, void(graphics::Renderable const&, graphics::Buffer&));
+    MOCK_CONST_METHOD1(render, void(graphics::Renderable const&));
     MOCK_CONST_METHOD0(end, void());
     MOCK_METHOD0(suspend, void());
 

=== modified file 'include/test/mir_test_doubles/mock_scene.h'
--- include/test/mir_test_doubles/mock_scene.h	2014-03-24 22:06:43 +0000
+++ include/test/mir_test_doubles/mock_scene.h	2014-04-30 13:15:30 +0000
@@ -38,8 +38,6 @@
             .WillByDefault(testing::Return(graphics::RenderableList{}));
     }
     MOCK_CONST_METHOD0(generate_renderable_list, graphics::RenderableList());
-    MOCK_METHOD2(for_each_if, void(compositor::FilterForScene&,
-                                   compositor::OperatorForScene&));
     MOCK_METHOD1(set_change_callback, void(std::function<void()> const&));
     MOCK_METHOD0(lock, void());
     MOCK_METHOD0(unlock, void());

=== renamed file 'include/test/mir_test_doubles/mock_shell_session.h' => 'include/test/mir_test_doubles/mock_scene_session.h'
--- include/test/mir_test_doubles/mock_shell_session.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/mock_scene_session.h	2014-04-30 13:15:30 +0000
@@ -16,11 +16,11 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#ifndef MIR_TEST_DOUBLES_MOCK_SHELL_SESSION_H_
-#define MIR_TEST_DOUBLES_MOCK_SHELL_SESSION_H_
+#ifndef MIR_TEST_DOUBLES_MOCK_SCENE_SESSION_H_
+#define MIR_TEST_DOUBLES_MOCK_SCENE_SESSION_H_
 
-#include "mir/shell/session.h"
-#include "mir/shell/surface_creation_parameters.h"
+#include "mir/scene/session.h"
+#include "mir/scene/surface_creation_parameters.h"
 #include "mir/graphics/display_configuration.h"
 
 #include <gmock/gmock.h>
@@ -32,14 +32,14 @@
 namespace doubles
 {
 
-struct MockShellSession : public shell::Session
+struct MockSceneSession : public scene::Session
 {
-    MOCK_METHOD1(create_surface, frontend::SurfaceId(shell::SurfaceCreationParameters const&));
+    MOCK_METHOD1(create_surface, frontend::SurfaceId(scene::SurfaceCreationParameters const&));
     MOCK_METHOD1(destroy_surface, void(frontend::SurfaceId));
     MOCK_CONST_METHOD1(get_surface, std::shared_ptr<frontend::Surface>(frontend::SurfaceId));
 
-    MOCK_METHOD1(take_snapshot, void(shell::SnapshotCallback const&));
-    MOCK_CONST_METHOD0(default_surface, std::shared_ptr<shell::Surface>());
+    MOCK_METHOD1(take_snapshot, void(scene::SnapshotCallback const&));
+    MOCK_CONST_METHOD0(default_surface, std::shared_ptr<scene::Surface>());
 
     MOCK_CONST_METHOD0(name, std::string());
     MOCK_CONST_METHOD0(process_id, pid_t());

=== modified file 'include/test/mir_test_doubles/mock_session.h'
--- include/test/mir_test_doubles/mock_session.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/mock_session.h	2014-04-30 13:15:30 +0000
@@ -20,7 +20,7 @@
 #define MIR_TEST_DOUBLES_MOCK_SESSION_H_
 
 #include "mir/frontend/session.h"
-#include "mir/shell/surface_creation_parameters.h"
+#include "mir/scene/surface_creation_parameters.h"
 
 #include <gmock/gmock.h>
 
@@ -33,7 +33,7 @@
 
 struct MockSession : public frontend::Session
 {
-    MOCK_METHOD1(create_surface, frontend::SurfaceId(shell::SurfaceCreationParameters const&));
+    MOCK_METHOD1(create_surface, frontend::SurfaceId(scene::SurfaceCreationParameters const&));
     MOCK_METHOD1(destroy_surface, void(frontend::SurfaceId));
     MOCK_CONST_METHOD1(get_surface, std::shared_ptr<frontend::Surface>(frontend::SurfaceId));
 

=== modified file 'include/test/mir_test_doubles/mock_session_listener.h'
--- include/test/mir_test_doubles/mock_session_listener.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/mock_session_listener.h	2014-04-30 13:15:30 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_TEST_DOUBLES_MOCK_SESSION_LISTENER_H_
 #define MIR_TEST_DOUBLES_MOCK_SESSION_LISTENER_H_
 
-#include "mir/shell/session_listener.h"
+#include "mir/scene/session_listener.h"
 
 #include <gmock/gmock.h>
 
@@ -30,17 +30,17 @@
 namespace doubles
 {
 
-struct MockSessionListener : public shell::SessionListener
+struct MockSessionListener : public scene::SessionListener
 {
     virtual ~MockSessionListener() noexcept(true) {}
 
-    MOCK_METHOD1(starting, void(std::shared_ptr<shell::Session> const&));
-    MOCK_METHOD1(stopping, void(std::shared_ptr<shell::Session> const&));
-    MOCK_METHOD1(focused, void(std::shared_ptr<shell::Session> const&));
+    MOCK_METHOD1(starting, void(std::shared_ptr<scene::Session> const&));
+    MOCK_METHOD1(stopping, void(std::shared_ptr<scene::Session> const&));
+    MOCK_METHOD1(focused, void(std::shared_ptr<scene::Session> const&));
     MOCK_METHOD0(unfocused, void());
 
-    MOCK_METHOD2(surface_created, void(shell::Session&, std::shared_ptr<shell::Surface> const&));
-    MOCK_METHOD2(destroying_surface, void(shell::Session&, std::shared_ptr<shell::Surface> const&));
+    MOCK_METHOD2(surface_created, void(scene::Session&, std::shared_ptr<scene::Surface> const&));
+    MOCK_METHOD2(destroying_surface, void(scene::Session&, std::shared_ptr<scene::Surface> const&));
 };
 
 }

=== modified file 'include/test/mir_test_doubles/mock_shell.h'
--- include/test/mir_test_doubles/mock_shell.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/mock_shell.h	2014-04-30 13:15:30 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_TEST_DOUBLES_SHELL_H_
 #define MIR_TEST_DOUBLES_SHELL_H_
 
-#include "mir/shell/surface_creation_parameters.h"
+#include "mir/scene/surface_creation_parameters.h"
 #include "mir/frontend/shell.h"
 #include "mir/frontend/surface_id.h"
 
@@ -41,7 +41,7 @@
 
     MOCK_METHOD1(close_session, void(std::shared_ptr<frontend::Session> const&));
 
-    MOCK_METHOD2(create_surface_for, frontend::SurfaceId(std::shared_ptr<frontend::Session> const&, shell::SurfaceCreationParameters const&));
+    MOCK_METHOD2(create_surface_for, frontend::SurfaceId(std::shared_ptr<frontend::Session> const&, scene::SurfaceCreationParameters const&));
     MOCK_METHOD1(handle_surface_created, void(std::shared_ptr<frontend::Session> const&));
 };
 

=== modified file 'include/test/mir_test_doubles/mock_surface.h'
--- include/test/mir_test_doubles/mock_surface.h	2014-03-31 10:18:49 +0000
+++ include/test/mir_test_doubles/mock_surface.h	2014-04-30 13:15:30 +0000
@@ -49,8 +49,7 @@
 
     MOCK_METHOD0(hide, void());
     MOCK_METHOD0(show, void());
-    MOCK_METHOD0(visible, bool());
-    MOCK_METHOD1(raise, void(std::shared_ptr<scene::SurfaceRanker> const&));
+    MOCK_CONST_METHOD0(visible, bool());
 
     MOCK_METHOD0(force_requests_to_complete, void());
     MOCK_METHOD0(advance_client_buffer, std::shared_ptr<graphics::Buffer>());

=== renamed file 'include/test/mir_test_doubles/mock_surface_ranker.h' => 'include/test/mir_test_doubles/mock_surface_coordinator.h'
--- include/test/mir_test_doubles/mock_surface_ranker.h	2014-03-26 14:20:14 +0000
+++ include/test/mir_test_doubles/mock_surface_coordinator.h	2014-04-30 13:15:30 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -17,10 +17,10 @@
  */
 
 
-#ifndef MIR_TEST_DOUBLES_MOCK_SURFACE_RANKER_H_
-#define MIR_TEST_DOUBLES_MOCK_SURFACE_RANKER_H_
+#ifndef MIR_TEST_DOUBLES_MOCK_SURFACE_COORDINATOR_H_
+#define MIR_TEST_DOUBLES_MOCK_SURFACE_COORDINATOR_H_
 
-#include "mir/scene/surface_ranker.h"
+#include "mir/scene/surface_coordinator.h"
 
 #include <gmock/gmock.h>
 
@@ -31,9 +31,15 @@
 namespace doubles
 {
 
-struct MockSurfaceRanker : public scene::SurfaceRanker
+struct MockSurfaceCoordinator : public scene::SurfaceCoordinator
 {
     MOCK_METHOD1(raise, void(std::weak_ptr<scene::Surface> const&));
+
+    MOCK_METHOD2(add_surface, std::shared_ptr<scene::Surface>(
+        scene::SurfaceCreationParameters const& params,
+        scene::Session* session));
+
+    MOCK_METHOD1(remove_surface, void(std::weak_ptr<scene::Surface> const& surface));
 };
 
 }
@@ -41,4 +47,4 @@
 }
 
 
-#endif /* MIR_TEST_DOUBLES_MOCK_SURFACE_RANKER_H_ */
+#endif /* MIR_TEST_DOUBLES_MOCK_SURFACE_COORDINATOR_H_ */

=== removed file 'include/test/mir_test_doubles/mock_surface_factory.h'
--- include/test/mir_test_doubles/mock_surface_factory.h	2014-03-28 17:47:07 +0000
+++ include/test/mir_test_doubles/mock_surface_factory.h	1970-01-01 00:00:00 +0000
@@ -1,48 +0,0 @@
-/*
- * Copyright © 2012 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_TEST_DOUBLES_MOCK_SURFACE_FACTORY_H_
-#define MIR_TEST_DOUBLES_MOCK_SURFACE_FACTORY_H_
-
-#include "mir/shell/surface_factory.h"
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-namespace mir
-{
-namespace test
-{
-namespace doubles
-{
-
-struct MockSurfaceFactory : public shell::SurfaceFactory
-{
-    MOCK_METHOD3(create_surface, std::shared_ptr<shell::Surface>(
-        shell::Session*,
-        const shell::SurfaceCreationParameters&,
-        std::shared_ptr<scene::SurfaceObserver> const&));
-
-    void destroy_surface(std::shared_ptr<shell::Surface> const& /*surface*/) override {}
-};
-
-}
-}
-}
-
-#endif // MIR_TEST_DOUBLES_MOCK_SURFACE_FACTORY_H_

=== added file 'include/test/mir_test_doubles/null_display_buffer_compositor_factory.h'
--- include/test/mir_test_doubles/null_display_buffer_compositor_factory.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/null_display_buffer_compositor_factory.h	2014-04-30 13:15:30 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_NULL_DISPLAY_BUFFER_COMPOSITOR_FACTORY_H_
+#define MIR_TEST_DOUBLES_NULL_DISPLAY_BUFFER_COMPOSITOR_FACTORY_H_
+
+#include "mir/compositor/display_buffer_compositor_factory.h"
+#include "mir/compositor/display_buffer_compositor.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class NullDisplayBufferCompositorFactory : public compositor::DisplayBufferCompositorFactory
+{
+public:
+    auto create_compositor_for(graphics::DisplayBuffer&)
+        -> std::unique_ptr<compositor::DisplayBufferCompositor> override
+    {
+        struct NullDisplayBufferCompositor : compositor::DisplayBufferCompositor
+        {
+            bool composite() { return false; }
+        };
+
+        auto raw = new NullDisplayBufferCompositor{};
+        return std::unique_ptr<NullDisplayBufferCompositor>(raw);
+    }
+};
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_NULL_DISPLAY_BUFFER_COMPOSITOR_FACTORY_H_ */

=== added file 'include/test/mir_test_doubles/null_event_filter.h'
--- include/test/mir_test_doubles/null_event_filter.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/null_event_filter.h	2014-04-30 13:15:30 +0000
@@ -0,0 +1,40 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_NULL_EVENT_FILTER_H_
+#define MIR_TEST_DOUBLES_NULL_EVENT_FILTER_H_
+
+#include "mir/input/event_filter.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct NullEventFilter : public mir::input::EventFilter
+{
+    bool handle(MirEvent const&) override { return true; }
+};
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_NULL_EVENT_FILTER_H_ */

=== modified file 'include/test/mir_test_doubles/null_session_event_sink.h'
--- include/test/mir_test_doubles/null_session_event_sink.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/null_session_event_sink.h	2014-04-30 13:15:30 +0000
@@ -31,9 +31,9 @@
 class NullSessionEventSink : public scene::SessionEventSink
 {
 public:
-    void handle_focus_change(std::shared_ptr<shell::Session> const&) {}
+    void handle_focus_change(std::shared_ptr<scene::Session> const&) {}
     void handle_no_focus() {}
-    void handle_session_stopping(std::shared_ptr<shell::Session> const&) {}
+    void handle_session_stopping(std::shared_ptr<scene::Session> const&) {}
 };
 
 }

=== modified file 'include/test/mir_test_doubles/null_snapshot_strategy.h'
--- include/test/mir_test_doubles/null_snapshot_strategy.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/null_snapshot_strategy.h	2014-04-30 13:15:30 +0000
@@ -30,8 +30,9 @@
 
 struct NullSnapshotStrategy : public scene::SnapshotStrategy
 {
-    void take_snapshot_of(std::shared_ptr<shell::SurfaceBufferAccess> const&,
-                          shell::SnapshotCallback const&)
+    void take_snapshot_of(
+        std::shared_ptr<scene::SurfaceBufferAccess> const&,
+        scene::SnapshotCallback const&)
     {
     }
 };

=== added file 'include/test/mir_test_doubles/stub_host_connection.h'
--- include/test/mir_test_doubles/stub_host_connection.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_host_connection.h	2014-04-30 13:15:30 +0000
@@ -0,0 +1,72 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_HOST_CONNECTION_H_
+#define MIR_TEST_DOUBLES_STUB_HOST_CONNECTION_H_
+
+#include "src/server/graphics/nested/host_connection.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class StubHostConnection : public graphics::nested::HostConnection
+{
+public:
+    std::vector<int> platform_fd_items() override { return {}; }
+
+    EGLNativeDisplayType egl_native_display() override { return {}; }
+
+    std::shared_ptr<MirDisplayConfiguration> create_display_config() override
+    {
+        return std::shared_ptr<MirDisplayConfiguration>{
+            new MirDisplayConfiguration{0, nullptr, 0, nullptr}};
+    }
+
+    void set_display_config_change_callback(std::function<void()> const&) override
+    {
+    }
+
+    void apply_display_config(MirDisplayConfiguration&) override {}
+
+    std::shared_ptr<graphics::nested::HostSurface>
+        create_surface(MirSurfaceParameters const&) override
+    {
+        class NullHostSurface : public graphics::nested::HostSurface
+        {
+        public:
+            EGLNativeWindowType egl_native_window() override { return {}; }
+            void set_event_handler(MirEventDelegate const*) override {}
+        };
+
+        return std::make_shared<NullHostSurface>();
+    }
+
+    void drm_auth_magic(int) override {}
+    void drm_set_gbm_device(struct gbm_device*) override {}
+};
+
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_STUB_HOST_CONNECTION_H_ */

=== added file 'include/test/mir_test_doubles/stub_input_targets.h'
--- include/test/mir_test_doubles/stub_input_targets.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_input_targets.h	2014-04-30 13:15:30 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_INPUT_TARGETS_H_
+#define MIR_TEST_DOUBLES_STUB_INPUT_TARGETS_H_
+
+#include "mir/input/input_targets.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class StubInputTargets : public input::InputTargets
+{
+    void for_each(std::function<void(std::shared_ptr<input::Surface> const&)> const& ) override
+    {
+    }
+};
+
+}
+}
+} // namespace mir
+
+#endif /* MIR_TEST_DOUBLES_STUB_INPUT_TARGETS_H_ */

=== modified file 'include/test/mir_test_doubles/stub_renderable.h'
--- include/test/mir_test_doubles/stub_renderable.h	2014-03-28 22:40:30 +0000
+++ include/test/mir_test_doubles/stub_renderable.h	2014-04-30 13:15:30 +0000
@@ -33,6 +33,10 @@
 class StubRenderable : public graphics::Renderable
 {
 public:
+    ID id() const override
+    {
+        return this;
+    }
     std::shared_ptr<graphics::Buffer> buffer(void const*) const override
     {
         return std::make_shared<StubBuffer>();

=== modified file 'include/test/mir_test_doubles/stub_renderer.h'
--- include/test/mir_test_doubles/stub_renderer.h	2014-03-26 05:48:59 +0000
+++ include/test/mir_test_doubles/stub_renderer.h	2014-04-30 13:15:30 +0000
@@ -20,6 +20,7 @@
 #define MIR_TEST_DOUBLES_STUB_RENDERER_H_
 
 #include "mir/compositor/renderer.h"
+#include "mir/graphics/renderable.h"
 
 namespace mir
 {
@@ -43,9 +44,10 @@
     {
     }
 
-    void render(graphics::Renderable const&,
-                graphics::Buffer&) const override
+    void render(graphics::Renderable const& r) const override
     {
+        auto buffer = r.buffer(this);  // We need to consume a buffer to
+                                       // unblock tests with clients.
     }
 
     void end() const override

=== renamed file 'include/test/mir_test_doubles/stub_shell_session.h' => 'include/test/mir_test_doubles/stub_scene_session.h'
--- include/test/mir_test_doubles/stub_shell_session.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/stub_scene_session.h	2014-04-30 13:15:30 +0000
@@ -16,10 +16,10 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
-#ifndef MIR_TEST_DOUBLES_STUB_SHELL_SESSION_H_
-#define MIR_TEST_DOUBLES_STUB_SHELL_SESSION_H_
+#ifndef MIR_TEST_DOUBLES_STUB_SCENE_SESSION_H_
+#define MIR_TEST_DOUBLES_STUB_SCENE_SESSION_H_
 
-#include "mir/shell/session.h"
+#include "mir/scene/session.h"
 
 namespace mir
 {
@@ -28,9 +28,9 @@
 namespace doubles
 {
 
-struct StubShellSession : public shell::Session
+struct StubSceneSession : public scene::Session
 {
-    frontend::SurfaceId create_surface(shell::SurfaceCreationParameters const& /* params */) override
+    frontend::SurfaceId create_surface(scene::SurfaceCreationParameters const& /* params */) override
     {
         return frontend::SurfaceId{0};
     }
@@ -59,22 +59,18 @@
     void show() override
     {
     }
-    int configure_surface(frontend::SurfaceId, MirSurfaceAttrib, int) override
-    {
-        return 0;
-    }
 
     void send_display_config(graphics::DisplayConfiguration const&) override
     {
     }
 
-    void take_snapshot(shell::SnapshotCallback const&) override
+    void take_snapshot(scene::SnapshotCallback const&) override
     {
     }
 
-    std::shared_ptr<shell::Surface> default_surface() const override
+    std::shared_ptr<scene::Surface> default_surface() const override
     {
-        return std::shared_ptr<shell::Surface>();
+        return std::shared_ptr<scene::Surface>();
     }
 
     void set_lifecycle_state(MirLifecycleState /*state*/)
@@ -86,5 +82,5 @@
 }
 } // namespace mir
 
-#endif // MIR_TEST_DOUBLES_STUB_SHELL_SESSION_H_
+#endif // MIR_TEST_DOUBLES_STUB_SCENE_SESSION_H_
 

=== modified file 'include/test/mir_test_doubles/stub_session.h'
--- include/test/mir_test_doubles/stub_session.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/stub_session.h	2014-04-30 13:15:30 +0000
@@ -30,39 +30,25 @@
 
 struct StubSession : public frontend::Session
 {
-    frontend::SurfaceId create_surface(shell::SurfaceCreationParameters const& /* params */)
+    frontend::SurfaceId create_surface(scene::SurfaceCreationParameters const& /* params */) override
     {
         return frontend::SurfaceId{0};
     }
-    void destroy_surface(frontend::SurfaceId /* surface */)
+    void destroy_surface(frontend::SurfaceId /* surface */) override
     {
     }
-    std::shared_ptr<frontend::Surface> get_surface(frontend::SurfaceId /* surface */) const
+    std::shared_ptr<frontend::Surface> get_surface(frontend::SurfaceId /* surface */) const override
     {
         return std::shared_ptr<frontend::Surface>();
     }
-    std::string name() const
+    std::string name() const override
     {
         return std::string();
     }
-    void force_requests_to_complete()
-    {
-    }
-    void hide()
-    {
-    }
-    void show()
-    {
-    }
-    int configure_surface(frontend::SurfaceId, MirSurfaceAttrib, int)
-    {
-        return 0;
-    }
-    void set_event_sink(std::shared_ptr<frontend::EventSink> const&)
-    {
-    }
-
-    void send_display_config(graphics::DisplayConfiguration const&)
+    void hide() override
+    {
+    }
+    void show() override
     {
     }
 };

=== modified file 'include/test/mir_test_doubles/stub_shell.h'
--- include/test/mir_test_doubles/stub_shell.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/stub_shell.h	2014-04-30 13:15:30 +0000
@@ -42,7 +42,7 @@
     {
     }
     frontend::SurfaceId create_surface_for(std::shared_ptr<frontend::Session> const& /* session */,
-                                        shell::SurfaceCreationParameters const& /* params */) override
+                                        scene::SurfaceCreationParameters const& /* params */) override
     {
         return frontend::SurfaceId{0};
     }

=== modified file 'include/test/mir_test_framework/declarative_placement_strategy.h'
--- include/test/mir_test_framework/declarative_placement_strategy.h	2014-03-20 18:41:16 +0000
+++ include/test/mir_test_framework/declarative_placement_strategy.h	2014-04-30 13:15:30 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_TEST_FRAMEWORK_DECLARATIVE_PLACEMENT_STRATEGY_H_
 #define MIR_TEST_FRAMEWORK_DECLARATIVE_PLACEMENT_STRATEGY_H_
 
-#include "mir/shell/placement_strategy.h"
+#include "mir/scene/placement_strategy.h"
 #include "mir/geometry/rectangle.h"
 #include "mir/scene/depth_id.h"
 
@@ -36,25 +36,25 @@
 /// a static list of surface geometries and relative depths. Used, for example,
 /// in input tests where it is necessary to set up scenarios depending on
 /// multiple surfaces geometry and stacking.
-class DeclarativePlacementStrategy : public mir::shell::PlacementStrategy
+class DeclarativePlacementStrategy : public mir::scene::PlacementStrategy
 {
  public:
     // Placement requests will be passed through to default strategy, and then overriden if the surface appears
     // in the geometry or depth map. This allows for the convenience of leaving some surfaces geometries unspecified
     // and receiving the default behavior.
-    DeclarativePlacementStrategy(std::shared_ptr<mir::shell::PlacementStrategy> const& default_strategy,
+    DeclarativePlacementStrategy(std::shared_ptr<mir::scene::PlacementStrategy> const& default_strategy,
         SurfaceGeometries const& positions_by_name, SurfaceDepths const& depths_by_name);
 
     virtual ~DeclarativePlacementStrategy() = default;
     
-    mir::shell::SurfaceCreationParameters place(mir::shell::Session const& session, mir::shell::SurfaceCreationParameters const& request_parameters) override;
+    mir::scene::SurfaceCreationParameters place(mir::scene::Session const& session, mir::scene::SurfaceCreationParameters const& request_parameters) override;
 
 protected:
     DeclarativePlacementStrategy(const DeclarativePlacementStrategy&) = delete;
     DeclarativePlacementStrategy& operator=(const DeclarativePlacementStrategy&) = delete;
 
 private:
-    std::shared_ptr<mir::shell::PlacementStrategy> const default_strategy;
+    std::shared_ptr<mir::scene::PlacementStrategy> const default_strategy;
 
     SurfaceGeometries surface_geometries_by_name;
     SurfaceDepths surface_depths_by_name;

=== modified file 'include/test/mir_test_framework/display_server_test_fixture.h'
--- include/test/mir_test_framework/display_server_test_fixture.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_framework/display_server_test_fixture.h	2014-04-30 13:15:30 +0000
@@ -65,6 +65,7 @@
 
     bool shutdown_server_process();
     Result  wait_for_shutdown_server_process();
+    bool kill_server_process();
     void kill_client_processes();
     void terminate_client_processes();
 

=== modified file 'include/test/mir_test_framework/testing_process_manager.h'
--- include/test/mir_test_framework/testing_process_manager.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_framework/testing_process_manager.h	2014-04-30 13:15:30 +0000
@@ -58,6 +58,7 @@
     void tear_down_server();
     void tear_down_all();
     Result shutdown_server_process();
+    Result kill_server_process();
     Result wait_for_shutdown_server_process();
     void kill_client_processes();
     void terminate_client_processes();

=== modified file 'src/client/CMakeLists.txt'
--- src/client/CMakeLists.txt	2014-03-11 16:19:27 +0000
+++ src/client/CMakeLists.txt	2014-04-30 13:15:30 +0000
@@ -32,10 +32,13 @@
   aging_buffer.cpp
   client_buffer_depository.cpp
   display_configuration.cpp
-  mir_client_library.cpp
+  error_connections.cpp
   mir_connection.cpp
+  mir_connection_api.cpp
   mir_wait_handle.cpp
+  mir_wait_api.cpp
   mir_surface.cpp
+  mir_surface_api.cpp
   logging/rpc_report.cpp
   logging/input_receiver_report.cpp
   default_connection_configuration.cpp

=== modified file 'src/client/android/client_surface_interpreter.cpp'
--- src/client/android/client_surface_interpreter.cpp	2014-03-06 06:05:17 +0000
+++ src/client/android/client_surface_interpreter.cpp	2014-04-30 13:15:30 +0000
@@ -73,6 +73,8 @@
             return 0;
         case NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS:
             return 2;
+        case NATIVE_WINDOW_CONCRETE_TYPE:
+            return NATIVE_WINDOW_SURFACE;
         default:
             throw std::runtime_error("driver requested unsupported query");
     }

=== added file 'src/client/error_connections.cpp'
--- src/client/error_connections.cpp	1970-01-01 00:00:00 +0000
+++ src/client/error_connections.cpp	2014-04-30 13:15:30 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "error_connections.h"
+
+namespace mcl = mir::client;
+
+namespace
+{
+std::once_flag error_connections_init;
+}
+
+mcl::ErrorConnections& mcl::ErrorConnections::instance()
+{
+    static ErrorConnections* error_connections = nullptr;
+
+    std::call_once(
+        error_connections_init,
+        [&] { error_connections = new ErrorConnections();});
+
+    return *error_connections;
+}
+
+void mcl::ErrorConnections::insert(MirConnection* connection)
+{
+    std::lock_guard<std::mutex> lock(connection_guard);
+    connections.insert(connection);
+}
+
+void mcl::ErrorConnections::remove(MirConnection* connection)
+{
+    std::lock_guard<std::mutex> lock(connection_guard);
+    connections.erase(connection);
+}
+
+bool mcl::ErrorConnections::contains(MirConnection* connection) const
+{
+    std::lock_guard<std::mutex> lock(connection_guard);
+    return connections.count(connection);
+}

=== added file 'src/client/error_connections.h'
--- src/client/error_connections.h	1970-01-01 00:00:00 +0000
+++ src/client/error_connections.h	2014-04-30 13:15:30 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2012-2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_CLIENT_ERROR_CONNECTIONS_H_
+#define MIR_CLIENT_ERROR_CONNECTIONS_H_
+
+#include "mir_toolkit/client_types.h"
+#include <mutex>
+#include <unordered_set>
+
+namespace mir
+{
+namespace client
+{
+
+class ErrorConnections
+{
+public:
+    static ErrorConnections& instance();
+
+    void insert(MirConnection* connection);
+    void remove(MirConnection* connection);
+    bool contains(MirConnection* connection) const;
+
+private:
+    ErrorConnections() = default;
+    ErrorConnections(ErrorConnections const&) = delete;
+    ErrorConnections& operator=(ErrorConnections const&) = delete;
+
+    mutable std::mutex connection_guard;
+    std::unordered_set<MirConnection*> connections;
+};
+
+}
+}
+
+#endif /* MIR_CLIENT_ERROR_CONNECTIONS_H_ */

=== removed file 'src/client/mir_client_library.cpp'
--- src/client/mir_client_library.cpp	2014-03-26 05:48:59 +0000
+++ src/client/mir_client_library.cpp	1970-01-01 00:00:00 +0000
@@ -1,546 +0,0 @@
-/*
- * Copyright © 2012 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Thomas Guest <[e-mail]>
- */
-
-#include "mir/default_configuration.h"
-#include "mir/raii.h"
-#include "mir_toolkit/mir_client_library.h"
-#include "mir_toolkit/mir_client_library_drm.h"
-#include "mir_toolkit/mir_client_library_debug.h"
-
-#include "mir_connection.h"
-#include "display_configuration.h"
-#include "mir_surface.h"
-#include "egl_native_display_container.h"
-#include "default_connection_configuration.h"
-#include "lifecycle_control.h"
-#include "api_impl_types.h"
-
-#include <set>
-#include <unordered_set>
-#include <cstddef>
-#include <cstring>
-
-namespace mcl = mir::client;
-
-namespace
-{
-class ConnectionList
-{
-public:
-    void insert(MirConnection* connection)
-    {
-        std::lock_guard<std::mutex> lock(connection_guard);
-        connections.insert(connection);
-    }
-
-    void remove(MirConnection* connection)
-    {
-        std::lock_guard<std::mutex> lock(connection_guard);
-        connections.erase(connection);
-    }
-
-    bool contains(MirConnection* connection)
-    {
-        std::lock_guard<std::mutex> lock(connection_guard);
-        return connections.count(connection);
-    }
-
-private:
-    std::mutex connection_guard;
-    std::unordered_set<MirConnection*> connections;
-};
-
-ConnectionList error_connections;
-
-// assign_result is compatible with all 2-parameter callbacks
-void assign_result(void *result, void **context)
-{
-    if (context)
-        *context = result;
-}
-
-size_t division_ceiling(size_t a, size_t b)
-{
-    return ((a - 1) / b) + 1;
-}
-
-}
-
-MirWaitHandle* mir_default_connect(
-    char const* socket_file, char const* name, mir_connected_callback callback, void * context)
-{
-
-    try
-    {
-        std::string sock;
-        if (socket_file)
-            sock = socket_file;
-        else
-        {
-            auto socket_env = getenv("MIR_SOCKET");
-            if (socket_env)
-                sock = socket_env;
-            else
-                sock = mir::default_server_socket;
-        }
-
-        mcl::DefaultConnectionConfiguration conf{sock};
-
-        std::unique_ptr<MirConnection> connection{new MirConnection(conf)};
-        auto const result = connection->connect(name, callback, context);
-        connection.release();
-        return result;
-    }
-    catch (std::exception const& x)
-    {
-        MirConnection* error_connection = new MirConnection(x.what());
-        error_connections.insert(error_connection);
-        callback(error_connection, context);
-        return nullptr;
-    }
-}
-
-
-void mir_default_connection_release(MirConnection * connection)
-{
-    if (!error_connections.contains(connection))
-    {
-        try
-        {
-            auto wait_handle = connection->disconnect();
-            wait_handle->wait_for_all();
-        }
-        catch (std::exception const&)
-        {
-            // We're implementing a C API so no exceptions are to be
-            // propagated. And that's OK because if disconnect() fails,
-            // we don't care why. We're finished with the connection anyway.
-        }
-    }
-    else
-    {
-        error_connections.remove(connection);
-    }
-
-    delete connection;
-}
-
-//mir_connect and mir_connection_release can be overridden by test code that sets these function
-//pointers to do things like stub out the graphics drivers or change the connection configuration.
-
-//TODO: we could have a more comprehensive solution that allows us to substitute any of the functions
-//for test purposes, not just the connect functions
-mir_connect_impl_func mir_connect_impl = mir_default_connect;
-mir_connection_release_impl_func mir_connection_release_impl = mir_default_connection_release;
-
-MirWaitHandle* mir_connect(char const* socket_file, char const* name, mir_connected_callback callback, void * context)
-{
-    try
-    {
-        return mir_connect_impl(socket_file, name, callback, context);
-    }
-    catch (std::exception const&)
-    {
-        return nullptr;
-    }
-}
-
-void mir_connection_release(MirConnection *connection)
-{
-    try
-    {
-        return mir_connection_release_impl(connection);
-    }
-    catch (std::exception const&)
-    {
-    }
-}
-
-MirConnection *mir_connect_sync(char const *server,
-                                             char const *app_name)
-{
-    MirConnection *conn = nullptr;
-    mir_wait_for(mir_connect(server, app_name,
-                             reinterpret_cast<mir_connected_callback>
-                                             (assign_result),
-                             &conn));
-    return conn;
-}
-
-MirBool mir_connection_is_valid(MirConnection * connection)
-{
-    return MirConnection::is_valid(connection) ? mir_true : mir_false;
-}
-
-char const * mir_connection_get_error_message(MirConnection * connection)
-{
-    return connection->get_error_message();
-}
-
-MirEGLNativeDisplayType mir_connection_get_egl_native_display(MirConnection *connection)
-{
-    return connection->egl_native_display();
-}
-
-void mir_connection_get_available_surface_formats(
-    MirConnection * connection, MirPixelFormat* formats,
-    unsigned const int format_size, unsigned int *num_valid_formats)
-{
-    if ((connection) && (formats) && (num_valid_formats))
-        connection->available_surface_formats(formats, format_size, *num_valid_formats);
-}
-
-MirWaitHandle* mir_connection_create_surface(
-    MirConnection* connection,
-    MirSurfaceParameters const* params,
-    mir_surface_callback callback,
-    void* context)
-{
-    if (error_connections.contains(connection)) return 0;
-
-    try
-    {
-        return connection->create_surface(*params, callback, context);
-    }
-    catch (std::exception const&)
-    {
-        // TODO callback with an error surface
-        return nullptr;
-    }
-
-}
-
-MirSurface* mir_connection_create_surface_sync(
-    MirConnection* connection,
-    MirSurfaceParameters const* params)
-{
-    MirSurface *surface = nullptr;
-
-    mir_wait_for(mir_connection_create_surface(connection, params,
-        reinterpret_cast<mir_surface_callback>(assign_result),
-        &surface));
-
-    return surface;
-}
-
-void mir_surface_set_event_handler(MirSurface *surface,
-                                   MirEventDelegate const *event_handler)
-{
-    surface->set_event_handler(event_handler);
-}
-
-MirWaitHandle* mir_surface_release(
-    MirSurface * surface,
-    mir_surface_callback callback, void * context)
-{
-    try
-    {
-        return surface->release_surface(callback, context);
-    }
-    catch (std::exception const&)
-    {
-        return nullptr;
-    }
-}
-
-void mir_surface_release_sync(MirSurface *surface)
-{
-    mir_wait_for(mir_surface_release(surface,
-        reinterpret_cast<mir_surface_callback>(assign_result),
-        nullptr));
-}
-
-int mir_surface_get_id(MirSurface * surface)
-{
-    return mir_debug_surface_id(surface);
-}
-
-int mir_debug_surface_id(MirSurface * surface)
-{
-    return surface->id();
-}
-
-MirBool mir_surface_is_valid(MirSurface* surface)
-{
-    return surface->is_valid() ? mir_true : mir_false;
-}
-
-char const * mir_surface_get_error_message(MirSurface * surface)
-{
-    return surface->get_error_message();
-}
-
-void mir_surface_get_parameters(MirSurface * surface, MirSurfaceParameters *parameters)
-{
-    *parameters = surface->get_parameters();
-}
-
-MirPlatformType mir_surface_get_platform_type(MirSurface * surface)
-{
-    return surface->platform_type();
-}
-
-void mir_surface_get_current_buffer(MirSurface * surface, MirNativeBuffer ** buffer_package_out)
-{
-    *buffer_package_out = surface->get_current_buffer_package();
-}
-
-uint32_t mir_debug_surface_current_buffer_id(MirSurface * surface)
-{
-    return surface->get_current_buffer_id();
-}
-
-void mir_connection_get_platform(MirConnection *connection, MirPlatformPackage *platform_package)
-{
-    connection->populate(*platform_package);
-}
-
-MirDisplayConfiguration* mir_connection_create_display_config(MirConnection *connection)
-{
-    if (connection)
-        return connection->create_copy_of_display_config();
-    return nullptr;
-}
-
-void mir_display_config_destroy(MirDisplayConfiguration* configuration)
-{
-    mcl::delete_config_storage(configuration);
-}
-
-//TODO: DEPRECATED: remove this function
-void mir_connection_get_display_info(MirConnection *connection, MirDisplayInfo *display_info)
-{
-    auto const config = mir::raii::deleter_for(
-        mir_connection_create_display_config(connection),
-        &mir_display_config_destroy);
-
-    if (config->num_outputs < 1)
-        return;
-
-    MirDisplayOutput* state = nullptr;
-    // We can't handle more than one display, so just populate based on the first
-    // active display we find.
-    for (unsigned int i = 0; i < config->num_outputs; ++i)
-    {
-        if (config->outputs[i].used && config->outputs[i].connected &&
-            config->outputs[i].current_mode < config->outputs[i].num_modes)
-        {
-            state = &config->outputs[i];
-            break;
-        }
-    }
-    // Oh, oh! No connected outputs?!
-    if (state == nullptr)
-    {
-        memset(display_info, 0, sizeof(*display_info));
-        return;
-    }
-
-    MirDisplayMode mode = state->modes[state->current_mode];
-
-    display_info->width = mode.horizontal_resolution;
-    display_info->height = mode.vertical_resolution;
-
-    unsigned int format_items;
-    if (state->num_output_formats > mir_supported_pixel_format_max)
-         format_items = mir_supported_pixel_format_max;
-    else
-         format_items = state->num_output_formats;
-
-    display_info->supported_pixel_format_items = format_items;
-    for(auto i=0u; i < format_items; i++)
-    {
-        display_info->supported_pixel_format[i] = state->output_formats[i];
-    }
-}
-
-void mir_surface_get_graphics_region(MirSurface * surface, MirGraphicsRegion * graphics_region)
-{
-    surface->get_cpu_region( *graphics_region);
-}
-
-MirWaitHandle* mir_surface_swap_buffers(MirSurface *surface, mir_surface_callback callback, void * context)
-try
-{
-    return surface->next_buffer(callback, context);
-}
-catch (std::exception const&)
-{
-    return nullptr;
-}
-
-void mir_surface_swap_buffers_sync(MirSurface *surface)
-{
-    mir_wait_for(mir_surface_swap_buffers(surface,
-        reinterpret_cast<mir_surface_callback>(assign_result),
-        nullptr));
-}
-
-void mir_wait_for(MirWaitHandle* wait_handle)
-{
-    if (wait_handle)
-        wait_handle->wait_for_all();
-}
-
-void mir_wait_for_one(MirWaitHandle* wait_handle)
-{
-    if (wait_handle)
-        wait_handle->wait_for_one();
-}
-
-MirEGLNativeWindowType mir_surface_get_egl_native_window(MirSurface *surface)
-{
-    return reinterpret_cast<MirEGLNativeWindowType>(surface->generate_native_window());
-}
-
-MirWaitHandle* mir_surface_set_type(MirSurface *surf,
-                                    MirSurfaceType type)
-{
-    try
-    {
-        return surf ? surf->configure(mir_surface_attrib_type, type) : nullptr;
-    }
-    catch (std::exception const&)
-    {
-        return nullptr;
-    }
-}
-
-MirSurfaceType mir_surface_get_type(MirSurface *surf)
-{
-    MirSurfaceType type = mir_surface_type_normal;
-
-    if (surf)
-    {
-        // Only the client will ever change the type of a surface so it is
-        // safe to get the type from a local cache surf->attrib().
-
-        int t = surf->attrib(mir_surface_attrib_type);
-        type = static_cast<MirSurfaceType>(t);
-    }
-
-    return type;
-}
-
-MirWaitHandle* mir_surface_set_state(MirSurface *surf, MirSurfaceState state)
-{
-    try
-    {
-        return surf ? surf->configure(mir_surface_attrib_state, state) : nullptr;
-    }
-    catch (std::exception const&)
-    {
-        return nullptr;
-    }
-}
-
-MirSurfaceState mir_surface_get_state(MirSurface *surf)
-{
-    MirSurfaceState state = mir_surface_state_unknown;
-
-    try
-    {
-        if (surf)
-        {
-            int s = surf->attrib(mir_surface_attrib_state);
-
-            if (s == mir_surface_state_unknown)
-            {
-                surf->configure(mir_surface_attrib_state,
-                                mir_surface_state_unknown)->wait_for_all();
-                s = surf->attrib(mir_surface_attrib_state);
-            }
-
-            state = static_cast<MirSurfaceState>(s);
-        }
-    }
-    catch (std::exception const&)
-    {
-    }
-
-    return state;
-}
-
-MirWaitHandle* mir_surface_set_swapinterval(MirSurface* surf, int interval)
-{
-    if ((interval < 0) || (interval > 1))
-        return nullptr;
-
-    try
-    {
-        return surf ? surf->configure(mir_surface_attrib_swapinterval, interval) : nullptr;
-    }
-    catch (std::exception const&)
-    {
-        return nullptr;
-    }
-}
-
-int mir_surface_get_swapinterval(MirSurface* surf)
-{
-    return surf ? surf->attrib(mir_surface_attrib_swapinterval) : -1;
-}
-
-void mir_connection_set_lifecycle_event_callback(MirConnection* connection,
-    mir_lifecycle_event_callback callback, void* context)
-{
-    if (!error_connections.contains(connection))
-        connection->register_lifecycle_event_callback(callback, context);
-}
-
-void mir_connection_set_display_config_change_callback(MirConnection* connection,
-    mir_display_config_callback callback, void* context)
-{
-    if (connection)
-        connection->register_display_change_callback(callback, context);
-}
-
-MirWaitHandle* mir_connection_apply_display_config(MirConnection *connection, MirDisplayConfiguration* display_configuration)
-{
-    try
-    {
-        return connection ? connection->configure_display(display_configuration) : nullptr;
-    }
-    catch (std::exception const&)
-    {
-        return nullptr;
-    }
-}
-
-/**************************
- * DRM specific functions *
- **************************/
-
-MirWaitHandle *mir_connection_drm_auth_magic(MirConnection* connection,
-                                             unsigned int magic,
-                                             mir_drm_auth_magic_callback callback,
-                                             void* context)
-{
-    return connection->drm_auth_magic(magic, callback, context);
-}
-
-int mir_connection_drm_set_gbm_device(MirConnection* connection,
-                                      struct gbm_device* gbm_dev)
-{
-    size_t const pointer_size_in_ints = division_ceiling(sizeof(gbm_dev), sizeof(int));
-    std::vector<int> extra_data(pointer_size_in_ints);
-
-    memcpy(extra_data.data(), &gbm_dev, sizeof(gbm_dev));
-
-    return connection->set_extra_platform_data(extra_data);
-}

=== added file 'src/client/mir_connection_api.cpp'
--- src/client/mir_connection_api.cpp	1970-01-01 00:00:00 +0000
+++ src/client/mir_connection_api.cpp	2014-04-30 13:15:30 +0000
@@ -0,0 +1,312 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "mir_toolkit/mir_connection.h"
+#include "mir_toolkit/mir_client_library_drm.h"
+#include "mir/default_configuration.h"
+#include "mir/raii.h"
+
+#include "mir_connection.h"
+//#include "egl_native_display_container.h"
+#include "default_connection_configuration.h"
+#include "display_configuration.h"
+#include "api_impl_types.h"
+#include "error_connections.h"
+
+
+#include <unordered_set>
+#include <cstddef>
+#include <cstring>
+
+namespace mcl = mir::client;
+
+namespace
+{
+// assign_result is compatible with all 2-parameter callbacks
+void assign_result(void* result, void** context)
+{
+    if (context)
+        *context = result;
+}
+
+size_t division_ceiling(size_t a, size_t b)
+{
+    return ((a - 1) / b) + 1;
+}
+
+
+MirWaitHandle* mir_default_connect(
+    char const* socket_file,
+    char const* name,
+    mir_connected_callback callback,
+    void* context)
+{
+
+    try
+    {
+        std::string sock;
+        if (socket_file)
+            sock = socket_file;
+        else
+        {
+            auto socket_env = getenv("MIR_SOCKET");
+            if (socket_env)
+                sock = socket_env;
+            else
+                sock = mir::default_server_socket;
+        }
+
+        mcl::DefaultConnectionConfiguration conf{sock};
+
+        std::unique_ptr<MirConnection> connection{new MirConnection(conf)};
+        auto const result = connection->connect(name, callback, context);
+        connection.release();
+        return result;
+    }
+    catch (std::exception const& x)
+    {
+        MirConnection* error_connection = new MirConnection(x.what());
+        mcl::ErrorConnections::instance().insert(error_connection);
+        callback(error_connection, context);
+        return nullptr;
+    }
+}
+
+
+void mir_default_connection_release(MirConnection* connection)
+{
+    if (!mcl::ErrorConnections::instance().contains(connection))
+    {
+        try
+        {
+            auto wait_handle = connection->disconnect();
+            wait_handle->wait_for_all();
+        }
+        catch (std::exception const&)
+        {
+            // We're implementing a C API so no exceptions are to be
+            // propagated. And that's OK because if disconnect() fails,
+            // we don't care why. We're finished with the connection anyway.
+        }
+    }
+    else
+    {
+        mcl::ErrorConnections::instance().remove(connection);
+    }
+
+    delete connection;
+}
+
+}
+
+//mir_connect and mir_connection_release can be overridden by test code that sets these function
+//pointers to do things like stub out the graphics drivers or change the connection configuration.
+
+//TODO: we could have a more comprehensive solution that allows us to substitute any of the functions
+//for test purposes, not just the connect functions
+mir_connect_impl_func mir_connect_impl = mir_default_connect;
+mir_connection_release_impl_func mir_connection_release_impl = mir_default_connection_release;
+
+MirWaitHandle* mir_connect(
+    char const* socket_file,
+    char const* name,
+    mir_connected_callback callback,
+    void* context)
+{
+    try
+    {
+        return mir_connect_impl(socket_file, name, callback, context);
+    }
+    catch (std::exception const&)
+    {
+        return nullptr;
+    }
+}
+
+MirConnection* mir_connect_sync(
+    char const* server,
+    char const* app_name)
+{
+    MirConnection* conn = nullptr;
+    mir_wait_for(mir_connect(server, app_name,
+                             reinterpret_cast<mir_connected_callback>
+                                             (assign_result),
+                             &conn));
+    return conn;
+}
+
+MirBool mir_connection_is_valid(MirConnection* connection)
+{
+    return MirConnection::is_valid(connection) ? mir_true : mir_false;
+}
+
+char const* mir_connection_get_error_message(MirConnection* connection)
+{
+    return connection->get_error_message();
+}
+
+void mir_connection_release(MirConnection* connection)
+{
+    try
+    {
+        return mir_connection_release_impl(connection);
+    }
+    catch (std::exception const&)
+    {
+    }
+}
+
+void mir_connection_get_platform(
+    MirConnection* connection,
+    MirPlatformPackage* platform_package)
+{
+    connection->populate(*platform_package);
+}
+
+void mir_connection_set_lifecycle_event_callback(
+    MirConnection* connection,
+    mir_lifecycle_event_callback callback,
+    void* context)
+{
+    if (!mcl::ErrorConnections::instance().contains(connection))
+        connection->register_lifecycle_event_callback(callback, context);
+}
+
+//TODO: DEPRECATED: remove this function
+void mir_connection_get_display_info(
+    MirConnection* connection,
+    MirDisplayInfo* display_info)
+{
+    auto const config = mir::raii::deleter_for(
+        mir_connection_create_display_config(connection),
+        &mir_display_config_destroy);
+
+    if (config->num_outputs < 1)
+        return;
+
+    MirDisplayOutput* state = nullptr;
+    // We can't handle more than one display, so just populate based on the first
+    // active display we find.
+    for (unsigned int i = 0; i < config->num_outputs; ++i)
+    {
+        if (config->outputs[i].used && config->outputs[i].connected &&
+            config->outputs[i].current_mode < config->outputs[i].num_modes)
+        {
+            state = &config->outputs[i];
+            break;
+        }
+    }
+    // Oh, oh! No connected outputs?!
+    if (state == nullptr)
+    {
+        memset(display_info, 0, sizeof(*display_info));
+        return;
+    }
+
+    MirDisplayMode mode = state->modes[state->current_mode];
+
+    display_info->width = mode.horizontal_resolution;
+    display_info->height = mode.vertical_resolution;
+
+    unsigned int format_items;
+    if (state->num_output_formats > mir_supported_pixel_format_max)
+         format_items = mir_supported_pixel_format_max;
+    else
+         format_items = state->num_output_formats;
+
+    display_info->supported_pixel_format_items = format_items;
+    for(auto i=0u; i < format_items; i++)
+    {
+        display_info->supported_pixel_format[i] = state->output_formats[i];
+    }
+}
+
+MirDisplayConfiguration* mir_connection_create_display_config(