Merge lp:~mir-team/mir/trunk-0.1.7 into lp:mir/0.1

[kevin gunn]

Merge latest upstream release 0.1.7 (development-branch r1473)

[kevin gunn (kgunn72)]

Did you test your feature/code change/bug fix ? what device(s) ?
- code has been run through CI testing on lp:mir/devel, running on desktop, n10, n4 & n7

Did you break mir server API or ABI and have the relevant bumps to .so and debian docs been made ?
- ABI for server, so name bumped

Did you break mir client API or ABI and have you followed up with the known clients & announced on mir-devel mailing list ?
- ABI for server broke, relevant MP's are in place

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1475
http://jenkins.qa.ubuntu.com/job/mir-ci/1648/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/1241/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/1239/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-trusty-amd64-ci/46/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-trusty-armhf-ci/46/console

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

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

Verified the diff to release 0.1.7 is now only debian/changelog. And the conflicts no longer reappear when merging between distro/development.

review: Approve

[kevin gunn (kgunn72)]

daniel - in the future, if you update the branch especially with updates from devel, make sure to disable the arm integration tests, as those tests will fail on the silo builders

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp	2014-01-22 10:03:11 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp	2014-03-17 15:02:33 +0000
@@ -432,6 +432,7 @@
 sp<InputWindowHandle> InputDispatcher::findTouchedWindowAtLocked(int32_t x, int32_t y) {
     sp<InputWindowHandle> foundHandle = NULL;
     mEnumerator->for_each([&](sp<InputWindowHandle> windowHandle) {
+        windowHandle->updateInfo();
         const InputWindowInfo* windowInfo = windowHandle->getInfo();
         int32_t flags = windowInfo->layoutParamsFlags;
 
@@ -1151,6 +1152,7 @@
 
         // Traverse windows from front to back to find touched window and outside targets.
         mEnumerator->for_each([&](sp<InputWindowHandle> const& windowHandle){
+            windowHandle->updateInfo();
             const InputWindowInfo* windowInfo = windowHandle->getInfo();
             int32_t flags = windowInfo->layoutParamsFlags;
 
@@ -2742,6 +2744,12 @@
                   c_str(newFocusedWindowHandle->getName()));
 #endif
         }
+
+        if (mInputTargetWaitCause != INPUT_TARGET_WAIT_CAUSE_NONE) {
+            releasePendingEventLocked();
+            drainInboundQueueLocked();
+        }
+
         mFocusedWindowHandle = newFocusedWindowHandle;
     }
 }
 
=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-02-28 13:51:43 +0000
+++ CMakeLists.txt	2014-03-17 15:02:33 +0000
@@ -28,7 +28,7 @@
 
 set(MIR_VERSION_MAJOR 0)
 set(MIR_VERSION_MINOR 1)
-set(MIR_VERSION_PATCH 6)
+set(MIR_VERSION_PATCH 7)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 execute_process(
 
=== modified file 'debian/changelog'
--- debian/changelog	2014-03-10 19:28:46 +0000
+++ debian/changelog	2014-03-17 15:02:33 +0000
@@ -1,3 +1,59 @@
+mir (0.1.7-0ubuntu1) UNRELEASED; urgency=medium
+
+  * New upstream release 0.1.7 (https://launchpad.net/mir/+milestone/0.1.7)
+    - mirserver ABI bumped to 17
+    - mirclient ABI unchanged, still at 7. Clients do not need rebuilding.
+    - Server API changes (AKA why doesn't my code build any more?):
+      . Class "CompositingCriteria" has been removed. It's replaced by the more
+        flexible "Renderable" interface. This also resulted in parameter
+        changes for the Renderer and scene filtering classes.
+      . The function "DisplayConfiguration::configure_output()" has been
+        removed. Instead, please use the new mutable version of
+        "DisplayConfiguration::for_each_output()" with which you can modify
+        the output structure passed in on each iteration.
+      . Exposed formerly private class "GLRenderer" and demonstrated how
+        to override its behaviour in demo-shell. This area is under
+        construction and may experience further major changes.
+    - Added initial support for hardware (HWC) overlays to accelerate
+      rendering and reduce power consumption. Not complete yet.
+    - Screen rotation: Added mouse cursor rotation support, so you can now
+      still control things on a rotated screen. Still missing rotation of
+      the cursor bitmap itself.
+    - Lots of fixes to support nested Mir servers (see below).
+    - Major simplification to how surface size/position/transformation
+      interact, making transformations much easier to manage and work with.
+    - Bugs fixed:
+      . ./cross-compile-chroot.sh: line 83: popd: build-android-arm: invalid
+        argument popd: usage: popd [-n] [+N | -N] (LP: #1287600)
+      . Key events sent to the wrong client (and delayed) (LP: #1213804)
+      . Nested servers never receive input events (in their filters)
+        (LP: #1260612)
+      . Software clients crash immediately on nested servers - what(): Failed
+        to mmap buffer (LP: #1261286)
+      . MirMotionEvent lacks local coordinates. Reports only screen
+        coordinates. (LP: #1268819)
+      . Nested Mir crashes with - what():
+        MesaNativePlatform::create_internal_client is not implemented yet!
+        (LP: #1279092)
+      . clients fail to find some libraries if mir installed via "make install"
+        (LP: #1285566)
+      . Nested server hangs with multimonitor and internal clients.
+        (LP: #1287282)
+      . [regression] Multi-monitor frame sync no longer works (not
+        synchronized), and frames skip/jump/stutter (LP: #1288570)
+      . Mir FTBFS: /usr/bin/ld: cannot find -lmirtestdraw (when cmake ..
+        -DMIR_ENABLE_TESTS=OFF) (LP: #1283951)
+      . nested Mir library calls next_buffer() during startup (LP: #1284739)
+      . Building Mir produces lots of warnings from GLM headers about
+        deprecated degrees values vs radians (LP: #1286010)
+      . [enhancement] screencast of a single window (LP: #1288478)
+      . Nexus4 + mir_demo_client_eglplasma starts to stutter after a while
+        (LP: #1189753)
+      . --host-socket documented default argument isn't used as default
+        (LP: #1262091)
+
+ -- Daniel van Vugt <[e-mail]>  Wed, 12 Mar 2014 11:05:20 +0800
+
 mir (0.1.6+14.04.20140310-0ubuntu1) trusty; urgency=medium
 
   [ Kevin Gunn ]
 
=== modified file 'debian/control'
--- debian/control	2014-03-06 14:18:50 +0000
+++ debian/control	2014-03-17 15:02:33 +0000
@@ -70,7 +70,7 @@
  .
  Contains the protocol's definition files.
 
-Package: libmirserver16
+Package: libmirserver17
 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: libmirserver16 (= ${binary:Version}),
+Depends: libmirserver17 (= ${binary:Version}),
          libmirprotobuf-dev (= ${binary:Version}),
          mircommon-dev (= ${binary:Version}),
          libglm-dev,
 
=== renamed file 'debian/libmirserver16.install' => 'debian/libmirserver17.install'
--- debian/libmirserver16.install	2014-02-21 03:57:16 +0000
+++ debian/libmirserver17.install	2014-03-17 15:02:33 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirserver.so.16
+usr/lib/*/libmirserver.so.17
 
=== modified file 'debian/rules'
--- debian/rules	2014-03-06 14:18:50 +0000
+++ debian/rules	2014-03-17 15:02:33 +0000
@@ -22,8 +22,8 @@
 	dh_auto_configure -- \
 	  $(COMMON_CONFIGURE_OPTIONS) \
 	  -DMIR_RUN_ACCEPTANCE_TESTS=OFF \
-          -DMIR_RUN_INTEGRATION_TESTS=OFF \
-          -DMIR_PLATFORM=android\;mesa
+	  -DMIR_RUN_INTEGRATION_TESTS=OFF \
+	  -DMIR_PLATFORM=android\;mesa
 else
 ifeq ($(DEB_HOST_ARCH),arm64)
 	dh_auto_configure -- \
@@ -41,7 +41,9 @@
 	dh_makeshlibs -V
 
 override_dh_install:
-	dh_install --fail-missing
+	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)
 
 override_dh_installdeb:
 
=== modified file 'examples/CMakeLists.txt'
--- examples/CMakeLists.txt	2014-03-04 04:19:26 +0000
+++ examples/CMakeLists.txt	2014-03-17 15:02:33 +0000
@@ -93,7 +93,6 @@
   ${PROJECT_SOURCE_DIR}/include/server
   ${PROJECT_SOURCE_DIR}/include/client
   ${PROJECT_SOURCE_DIR}/include/platform
-  ${PROJECT_SOURCE_DIR}/include/test/mir_test/draw
   ${GLESv2_INCLUDE_DIRS}
 )
 
 
=== modified file 'examples/demo-shell/CMakeLists.txt'
--- examples/demo-shell/CMakeLists.txt	2013-08-28 03:41:48 +0000
+++ examples/demo-shell/CMakeLists.txt	2014-03-17 15:02:33 +0000
@@ -1,5 +1,6 @@
 add_executable(mir_demo_server_shell
   demo_shell.cpp
+  demo_renderer.cpp
   fullscreen_placement_strategy.cpp
   window_manager.cpp
   ../server_configuration.cpp
 
=== added file 'examples/demo-shell/demo_renderer.cpp'
--- examples/demo-shell/demo_renderer.cpp	1970-01-01 00:00:00 +0000
+++ examples/demo-shell/demo_renderer.cpp	2014-03-17 15:02:33 +0000
@@ -0,0 +1,33 @@
+/*
+ * 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: Daniel van Vugt <[e-mail]>
+ */
+
+#include "demo_renderer.h"
+
+using namespace mir;
+using namespace mir::examples;
+
+DemoRenderer::DemoRenderer(geometry::Rectangle const& display_area)
+    : GLRenderer(display_area)
+{
+}
+
+void DemoRenderer::begin() const
+{
+    glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+}
 
=== added file 'examples/demo-shell/demo_renderer.h'
--- examples/demo-shell/demo_renderer.h	1970-01-01 00:00:00 +0000
+++ examples/demo-shell/demo_renderer.h	2014-03-17 15:02:33 +0000
@@ -0,0 +1,39 @@
+/*
+ * 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: Daniel van Vugt <[e-mail]>
+ */
+
+#ifndef MIR_EXAMPLES_DEMO_RENDERER_H_
+#define MIR_EXAMPLES_DEMO_RENDERER_H_
+
+#include "mir/compositor/gl_renderer.h"
+
+namespace mir
+{
+namespace examples
+{
+
+class DemoRenderer : public compositor::GLRenderer
+{
+public:
+    DemoRenderer(geometry::Rectangle const& display_area);
+    void begin() const override;
+};
+
+} // namespace examples
+} // namespace mir
+
+#endif // MIR_EXAMPLES_DEMO_RENDERER_H_
 
=== modified file 'examples/demo-shell/demo_shell.cpp'
--- examples/demo-shell/demo_shell.cpp	2014-02-28 13:51:43 +0000
+++ examples/demo-shell/demo_shell.cpp	2014-03-17 15:02:33 +0000
@@ -18,6 +18,7 @@
 
 /// \example demo_shell.cpp A simple mir shell
 
+#include "demo_renderer.h"
 #include "window_manager.h"
 #include "fullscreen_placement_strategy.h"
 #include "../server_configuration.h"
@@ -27,6 +28,7 @@
 #include "mir/report_exception.h"
 #include "mir/graphics/display.h"
 #include "mir/input/composite_event_filter.h"
+#include "mir/compositor/renderer_factory.h"
 
 #include <iostream>
 
@@ -42,8 +44,19 @@
 namespace examples
 {
 
-struct DemoServerConfiguration : mir::examples::ServerConfiguration
-{
+class DemoRendererFactory : public compositor::RendererFactory
+{
+public:
+    std::unique_ptr<compositor::Renderer> create_renderer_for(
+        geometry::Rectangle const& rect) override
+    {
+        return std::unique_ptr<compositor::Renderer>(new DemoRenderer(rect));
+    }
+};
+
+class DemoServerConfiguration : public mir::examples::ServerConfiguration
+{
+public:
     DemoServerConfiguration(int argc, char const* argv[],
                             std::initializer_list<std::shared_ptr<mi::EventFilter>> const& filter_list)
       : ServerConfiguration([argc, argv]
@@ -82,6 +95,12 @@
         return composite_filter;
     }
 
+    std::shared_ptr<compositor::RendererFactory> the_renderer_factory() override
+    {
+        return std::make_shared<DemoRendererFactory>();
+    }
+
+private:
     std::vector<std::shared_ptr<mi::EventFilter>> const filter_list;
 };
 
 
=== modified file 'examples/demo-shell/window_manager.cpp'
--- examples/demo-shell/window_manager.cpp	2014-03-05 02:30:30 +0000
+++ examples/demo-shell/window_manager.cpp	2014-03-17 15:02:33 +0000
@@ -140,23 +140,14 @@
         {
             compositor->stop();
             auto conf = display->configuration();
-            conf->for_each_output([&](mg::DisplayConfigurationOutput const& output) -> void
-            {
-                MirPowerMode power_mode;
-                if (!output.used) return;
-
-                if (display_off == true)
-                    power_mode = mir_power_mode_on;
-                else
-                    power_mode = mir_power_mode_off;
-
-                conf->configure_output(output.id, output.used,
-                                       output.top_left,
-                                       output.current_mode_index,
-                                       output.current_format,
-                                       power_mode,
-                                       output.orientation);
-            });
+            MirPowerMode new_power_mode = display_off ?
+                mir_power_mode_on : mir_power_mode_off;
+            conf->for_each_output(
+                [&](mg::UserDisplayConfigurationOutput& output) -> void
+                {
+                    output.power_mode = new_power_mode;
+                }
+            );
             display_off = !display_off;
 
             display->configure(*conf.get());
@@ -184,14 +175,9 @@
                 compositor->stop();
                 auto conf = display->configuration();
                 conf->for_each_output(
-                    [&](mg::DisplayConfigurationOutput const& output) -> void
+                    [&](mg::UserDisplayConfigurationOutput& output) -> void
                     {
-                        conf->configure_output(output.id, output.used,
-                                               output.top_left,
-                                               output.current_mode_index,
-                                               output.current_format,
-                                               output.power_mode,
-                                               orientation);
+                        output.orientation = orientation;
                     }
                 );
                 display->configure(*conf);
 
=== modified file 'examples/eglplasma.c'
--- examples/eglplasma.c	2013-09-19 13:24:22 +0000
+++ examples/eglplasma.c	2014-03-17 15:02:33 +0000
@@ -85,14 +85,13 @@
         "    const float pi2 = 6.283185308;                      \n"
         "    float u = texcoord.x * pi2;                         \n"
         "    float v = texcoord.y * pi2;                         \n"
-        "    float t = mod(theta, pi2);                          \n"
-        "    float us = (cos(1.1 * u + 7.0 * t) +                \n"
-        "                cos(2.3 * v * cos(1.0 * t)) +           \n"
-        "                cos(0.3 * u * cos(3.0 * t))             \n"
+        "    float us = (cos(1.1 * u + 7.0 * theta) +            \n"
+        "                cos(2.3 * v * cos(1.0 * theta)) +       \n"
+        "                cos(0.3 * u * cos(3.0 * theta))         \n"
         "               ) / 3.0;                                 \n"
-        "    float vs = (cos(2.3 * v + 8.0 * t) +                \n"
-        "                cos(1.3 * u * cos(3.0 * t)) +           \n"
-        "                cos(1.7 * v * cos(2.0 * t))             \n"
+        "    float vs = (cos(2.3 * v + 8.0 * theta) +            \n"
+        "                cos(1.3 * u * cos(3.0 * theta)) +       \n"
+        "                cos(1.7 * v * cos(2.0 * theta))         \n"
         "               ) / 3.0;                                 \n"
         "    float x = (us * vs + 1.0) / 2.0;                    \n"
         "    gl_FragColor = vec4(gradient(x), 1.0);              \n"
@@ -105,6 +104,7 @@
         1.0f,-1.0f,
        -1.0f,-1.0f,
     };
+    const float pi2 = 6.283185308f;
     GLuint vshader, fshader, prog;
     GLint linked, low_color, high_color, vpos, theta;
     unsigned int width = 0, height = 0;
@@ -151,6 +151,8 @@
     {
         glUniform1f(theta, angle);
         angle += 0.005f;
+        if (angle > pi2)
+            angle -= pi2;
         glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
         mir_eglapp_swap_buffers();
     }
 
=== modified file 'examples/image_renderer.cpp'
--- examples/image_renderer.cpp	2014-01-22 10:03:11 +0000
+++ examples/image_renderer.cpp	2014-03-17 15:02:33 +0000
@@ -23,6 +23,7 @@
 #pragma GCC diagnostic warning "-Wall"
 #include <glm/glm.hpp>
 #pragma GCC diagnostic pop
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_ptr.hpp>
 
 #include <memory>
 
=== modified file 'examples/pixel_format_selector.cpp'
--- examples/pixel_format_selector.cpp	2014-03-05 02:30:30 +0000
+++ examples/pixel_format_selector.cpp	2014-03-17 15:02:33 +0000
@@ -40,7 +40,7 @@
 {
     base_policy->apply_to(conf);
     conf.for_each_output(
-        [&](graphics::DisplayConfigurationOutput const& conf_output)
+        [&](graphics::UserDisplayConfigurationOutput& conf_output)
         {
             if (!conf_output.connected || !conf_output.used) return;
 
@@ -56,12 +56,7 @@
             if (pos == conf_output.pixel_formats.end())
                 return;
 
-            conf.configure_output(conf_output.id, true, conf_output.top_left,
-                                  conf_output.current_mode_index,
-                                  *pos,
-                                  conf_output.power_mode,
-                                  conf_output.orientation
-                                 );
+            conf_output.current_format = *pos;
         });
 }
 
 
=== modified file 'examples/render_overlays.cpp'
--- examples/render_overlays.cpp	2014-03-04 04:19:26 +0000
+++ examples/render_overlays.cpp	2014-03-17 15:02:33 +0000
@@ -25,9 +25,10 @@
 #include "mir/graphics/buffer_properties.h"
 #include "mir/report_exception.h"
 
-#include "graphics_region_factory.h"
-#include "patterns.h"
+#include "testdraw/graphics_region_factory.h"
+#include "testdraw/patterns.h"
 
+#include <chrono>
 #include <csignal>
 #include <iostream>
 
@@ -44,20 +45,69 @@
 {
     running = false;
 }
-}
+
+class DemoOverlayClient
+{
+public:
+    DemoOverlayClient(
+        mg::GraphicBufferAllocator& buffer_allocator,
+        mg::BufferProperties const& buffer_properties, uint32_t color)
+         : front_buffer(buffer_allocator.alloc_buffer(buffer_properties)),
+           back_buffer(buffer_allocator.alloc_buffer(buffer_properties)),
+           region_factory(mir::test::draw::create_graphics_region_factory()),
+           color{color},
+           last_tick{std::chrono::high_resolution_clock::now()}
+    {
+    }
+
+    void update_green_channel()
+    {
+        char green_value = (color >> 8) & 0xFF;
+        green_value += compute_update_value();
+        color &= 0xFFFF00FF;
+        color |= (green_value << 8);
+
+        mir::test::draw::DrawPatternSolid fill{color};
+        fill.draw(*region_factory->graphic_region_from_handle(*back_buffer->native_buffer_handle()));
+        std::swap(front_buffer, back_buffer);
+    }
+
+    std::shared_ptr<mg::Buffer> last_rendered()
+    {
+        return front_buffer;
+    }
+
+private:
+    int compute_update_value()
+    {
+        float const update_ratio{3.90625}; //this will give an update of 256 in 1s  
+        auto current_tick = std::chrono::high_resolution_clock::now();
+        auto elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+            current_tick - last_tick).count();
+        float update_value = elapsed_ms / update_ratio;
+        last_tick = current_tick;
+        return static_cast<int>(update_value);
+    }
+
+    std::shared_ptr<mg::Buffer> front_buffer;
+    std::shared_ptr<mg::Buffer> back_buffer;
+    std::shared_ptr<mir::test::draw::GraphicsRegionFactory> region_factory;
+    unsigned int color;
+    std::chrono::time_point<std::chrono::high_resolution_clock> last_tick;
+};
 
 class DemoRenderable : public mg::Renderable
 {
 public:
-    DemoRenderable(std::shared_ptr<mg::Buffer> const& buffer, geom::Rectangle rect)
-        : renderable_buffer(buffer),
+    DemoRenderable(std::shared_ptr<DemoOverlayClient> const& client, geom::Rectangle rect)
+        : client(client),
           position(rect)
     {
     }
 
-    std::shared_ptr<mg::Buffer> buffer() const
+    std::shared_ptr<mg::Buffer> buffer(unsigned long) const override
     {
-        return renderable_buffer;
+        return client->last_rendered();
     }
 
     bool alpha_enabled() const
@@ -70,16 +120,41 @@
         return position;
     }
 
+    float alpha() const override
+    {
+        return 1.0f;
+    }
+
+    glm::mat4 transformation() const override
+    {
+        return trans;
+    }
+
+    bool shaped() const
+    {
+        return false;
+    }
+
+    bool should_be_rendered_in(geom::Rectangle const& rect) const override
+    {
+        return rect.overlaps(position);
+    }
+
+    int buffers_ready_for_compositor() const override
+    {
+        return 1;
+    }
+
 private:
-    std::shared_ptr<mg::Buffer> const renderable_buffer;
+    std::shared_ptr<DemoOverlayClient> const client;
     geom::Rectangle const position;
+    glm::mat4 const trans;
 };
+}
 
 int main(int argc, char const** argv)
 try
 {
-    mir::test::draw::DrawPatternSolid fill_with_green(0x00FF00FF);
-    mir::test::draw::DrawPatternSolid fill_with_blue(0x0000FFFF);
 
     /* Set up graceful exit on SIGINT and SIGTERM */
     struct sigaction sa;
@@ -95,7 +170,6 @@
     auto platform = conf.the_graphics_platform();
     auto display = platform->create_display(conf.the_display_configuration_policy());
     auto buffer_allocator = platform->create_buffer_allocator(conf.the_buffer_initializer());
-    auto region_factory = mir::test::draw::create_graphics_region_factory();
 
      mg::BufferProperties buffer_properties{
         geom::Size{512, 512},
@@ -103,18 +177,13 @@
         mg::BufferUsage::hardware
     };
 
-    auto buffer1 = buffer_allocator->alloc_buffer(buffer_properties);
-    auto buffer2 = buffer_allocator->alloc_buffer(buffer_properties);
-
-    fill_with_green.draw(*region_factory->graphic_region_from_handle(*buffer1->native_buffer_handle()));
-    fill_with_blue.draw(*region_factory->graphic_region_from_handle(*buffer2->native_buffer_handle()));
-
-    geom::Rectangle screen_pos1{{0,0} , {512, 512}};
-    geom::Rectangle screen_pos2{{80,80} , {592,592}};
+    auto client1 = std::make_shared<DemoOverlayClient>(*buffer_allocator, buffer_properties,0xFF0000FF);
+    auto client2 = std::make_shared<DemoOverlayClient>(*buffer_allocator, buffer_properties,0xFFFFFF00);
+
     std::list<std::shared_ptr<mg::Renderable>> renderlist
     {
-        std::make_shared<DemoRenderable>(buffer2, screen_pos2),
-        std::make_shared<DemoRenderable>(buffer1, screen_pos1)
+        std::make_shared<DemoRenderable>(client1, geom::Rectangle{{0,0} , {512, 512}}),
+        std::make_shared<DemoRenderable>(client2, geom::Rectangle{{80,80} , {592,592}})
     };
 
     while (running)
@@ -122,6 +191,8 @@
         display->for_each_display_buffer([&](mg::DisplayBuffer& buffer)
         {
             buffer.make_current();
+            client1->update_green_channel();
+            client2->update_green_channel();
             auto render_fn = [](mg::Renderable const&) {};
             buffer.render_and_post_update(renderlist, render_fn);
         });
 
=== modified file 'examples/render_surfaces.cpp'
--- examples/render_surfaces.cpp	2014-02-28 13:51:43 +0000
+++ examples/render_surfaces.cpp	2014-03-17 15:02:33 +0000
@@ -17,6 +17,7 @@
  */
 
 #include "mir/compositor/display_buffer_compositor_factory.h"
+#include "mir/server_status_listener.h"
 #include "mir/compositor/display_buffer_compositor.h"
 #include "mir/options/default_configuration.h"
 #include "mir/graphics/graphic_buffer_allocator.h"
@@ -48,8 +49,6 @@
 #include <sstream>
 #include <vector>
 
-#include <glm/gtc/matrix_transform.hpp>
-
 namespace mg = mir::graphics;
 namespace mc = mir::compositor;
 namespace ms = mir::scene;
@@ -86,6 +85,7 @@
 
 namespace
 {
+std::atomic<bool> created{false};
 bool input_is_on = false;
 std::weak_ptr<mg::Cursor> cursor;
 static const uint32_t bg_color = 0x00000000;
@@ -326,6 +326,31 @@
     }
     ///\internal [RenderResourcesBufferInitializer_tag]
 
+    // Unless the compositor starts before we create the surfaces it won't respond to
+    // the change notification that causes.
+    std::shared_ptr<mir::ServerStatusListener> the_server_status_listener()
+    {
+        struct ServerStatusListener : mir::ServerStatusListener
+        {
+            ServerStatusListener(std::function<void()> create_surfaces, std::shared_ptr<mir::ServerStatusListener> wrapped) :
+                create_surfaces(create_surfaces), wrapped(wrapped) {}
+
+            virtual void paused() override { wrapped->paused(); }
+            virtual void resumed() override { wrapped->resumed(); }
+            virtual void started() override { wrapped->started(); create_surfaces(); create_surfaces = []{}; }
+
+            std::function<void()> create_surfaces;
+            std::shared_ptr<mir::ServerStatusListener> const wrapped;
+        };
+
+        return server_status_listener(
+            [this]()
+            {
+                auto wrapped = ServerConfiguration::the_server_status_listener();
+                return std::make_shared<ServerStatusListener>([this] { create_surfaces(); }, wrapped);
+            });
+    }
+
     ///\internal [RenderSurfacesDisplayBufferCompositor_tag]
     // Decorate the DefaultDisplayBufferCompositor in order to move surfaces.
     std::shared_ptr<mc::DisplayBufferCompositorFactory> the_display_buffer_compositor_factory() override
@@ -342,8 +367,9 @@
             {
             }
 
-            void composite()
+            bool composite()
             {
+                while (!created) std::this_thread::yield();
                 animate_cursor();
                 stop_watch.stop();
                 if (stop_watch.elapsed_seconds_since_last_restart() >= 1)
@@ -360,6 +386,7 @@
                     m.step();
 
                 frames++;
+                return false;
             }
 
         private:
@@ -459,6 +486,8 @@
                     2.0f * M_PI * cos(i));
             ++i;
         }
+
+        created = true;
     }
 
     bool input_is_on()
@@ -492,8 +521,6 @@
 
     mir::run_mir(conf, [&](mir::DisplayServer&)
     {
-        conf.create_surfaces();
-
         cursor = conf.the_cursor();
 
         input_is_on = conf.input_is_on();
 
=== modified file 'examples/scroll.cpp'
--- examples/scroll.cpp	2014-03-04 04:19:26 +0000
+++ examples/scroll.cpp	2014-03-17 15:02:33 +0000
@@ -23,46 +23,21 @@
 #include <signal.h>
 #include <string.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <unistd.h>
 #include <getopt.h>
 #include <EGL/egl.h>
 #include <GLES2/gl2.h>
 
+#include <thread>
+
 static char const *socket_file = NULL;
-
-int main(int argc, char* argv[])
+static EGLDisplay disp;
+
+
+void create_and_run_scroll_surface(MirConnection *connection)
 {
-    MirConnection *connection = 0;
     MirSurface *surface = 0;
-    int arg;
-    opterr = 0;
-    while ((arg = getopt (argc, argv, "hm:")) != -1)
-    {
-        switch (arg)
-        {
-        case 'm':
-            socket_file = optarg;
-            break;
-
-        case '?':
-        case 'h':
-        default:
-            puts(argv[0]);
-            puts("Usage:");
-            puts("    -m <Mir server socket>");
-            puts("    -h: this help text");
-            return -1;
-        }
-    }
-
-    puts("Starting");
-
-    connection = mir_connect_sync(socket_file, __PRETTY_FUNCTION__);
-    assert(connection != NULL);
-    assert(mir_connection_is_valid(connection));
-    assert(strcmp(mir_connection_get_error_message(connection), "") == 0);
-    puts("Connected");
-
     MirPixelFormat pixel_format;
     unsigned int valid_formats;
     mir_connection_get_available_surface_formats(connection, &pixel_format, 1, &valid_formats);
@@ -79,7 +54,6 @@
 
     /* egl setup */
     int major, minor, n, rc;
-    EGLDisplay disp;
     EGLContext context;
     EGLSurface egl_surface;
     EGLConfig egl_config;
@@ -93,13 +67,9 @@
         EGL_NONE };
     EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
 
-    EGLNativeDisplayType native_display = (EGLNativeDisplayType) mir_connection_get_egl_native_display(connection);
     EGLNativeWindowType native_window = (EGLNativeWindowType) mir_surface_get_egl_native_window(surface);
     assert(native_window != (EGLNativeWindowType)NULL);
 
-    disp = eglGetDisplay(native_display);
-    assert(disp != EGL_NO_DISPLAY);
-
     rc = eglInitialize(disp, &major, &minor);
     assert(rc == EGL_TRUE);
     assert(major == 1);
@@ -131,16 +101,67 @@
 
     eglDestroySurface(disp, egl_surface);
     eglDestroyContext(disp, context);
-    eglTerminate(disp);
-
+    
     mir_surface_release_sync(surface);
     puts("Surface released");
+}
+
+int main(int argc, char* argv[])
+{
+    MirConnection *connection = 0;
+    unsigned num_windows = 1;
+    int arg;
+    opterr = 0;
+    while ((arg = getopt (argc, argv, "hm:w:")) != -1)
+    {
+        switch (arg)
+        {
+        case 'm':
+            socket_file = optarg;
+            break;
+        case 'w':
+            num_windows = atoi(optarg);
+            break;
+        case '?':
+        case 'h':
+        default:
+            puts(argv[0]);
+            puts("Usage:");
+            puts("    -m <Mir server socket>");
+            puts("    -w <Number of windows to create>:");
+            puts("    -h: this help text");
+            return -1;
+        }
+    }
+
+    puts("Starting");
+
+    connection = mir_connect_sync(socket_file, __PRETTY_FUNCTION__);
+    assert(connection != NULL);
+    assert(mir_connection_is_valid(connection));
+    assert(strcmp(mir_connection_get_error_message(connection), "") == 0);
+    puts("Connected");
+
+    EGLNativeDisplayType native_display = (EGLNativeDisplayType) mir_connection_get_egl_native_display(connection);
+    disp = eglGetDisplay(native_display);
+    assert(disp != EGL_NO_DISPLAY);
+
+    if (num_windows == 1)
+    {
+        create_and_run_scroll_surface(connection);
+    }
+    else
+    {
+        for (unsigned i = 0; i < num_windows; i++) std::thread(create_and_run_scroll_surface, connection).detach();
+        for(;;) {}
+    }
+    
+
+    eglTerminate(disp);
 
     mir_connection_release(connection);
     puts("Connection released");
 
-    (void)rc;
-
     return 0;
 }
 
 
=== modified file 'examples/server_configuration.cpp'
--- examples/server_configuration.cpp	2014-03-05 02:30:30 +0000
+++ examples/server_configuration.cpp	2014-03-17 15:02:33 +0000
@@ -56,28 +56,23 @@
             });
 
         conf.for_each_output(
-            [&](mg::DisplayConfigurationOutput const& conf_output)
+            [&](mg::UserDisplayConfigurationOutput& conf_output)
             {
                 if (conf_output.connected && conf_output.modes.size() > 0 &&
                     available_outputs_for_card[conf_output.card_id] > 0)
                 {
-                    conf.configure_output(conf_output.id, true,
-                                          geom::Point{max_x, 0},
-                                          preferred_mode_index,
-                                          conf_output.current_format,
-                                          mir_power_mode_on,
-                                          mir_orientation_normal);
+                    conf_output.used = true;
+                    conf_output.top_left = geom::Point{max_x, 0};
+                    conf_output.current_mode_index = preferred_mode_index;
+                    conf_output.power_mode = mir_power_mode_on;
+                    conf_output.orientation = mir_orientation_normal;
                     max_x += conf_output.modes[preferred_mode_index].size.width.as_int();
                     --available_outputs_for_card[conf_output.card_id];
                 }
                 else
                 {
-                    conf.configure_output(conf_output.id, false,
-                                          conf_output.top_left,
-                                          conf_output.current_mode_index,
-                                          conf_output.current_format,
-                                          mir_power_mode_on,
-                                          mir_orientation_normal);
+                    conf_output.used = false;
+                    conf_output.power_mode = mir_power_mode_off;
                 }
             });
     }
@@ -92,26 +87,20 @@
         bool done{false};
 
         conf.for_each_output(
-            [&](mg::DisplayConfigurationOutput const& conf_output)
+            [&](mg::UserDisplayConfigurationOutput& conf_output)
             {
                 if (!done && conf_output.connected && conf_output.modes.size() > 0)
                 {
-                    conf.configure_output(conf_output.id, true,
-                                          geom::Point{0, 0},
-                                          preferred_mode_index,
-                                          conf_output.current_format,
-                                          mir_power_mode_on,
-                                          mir_orientation_normal);
+                    conf_output.used = true;
+                    conf_output.top_left = geom::Point{0, 0};
+                    conf_output.current_mode_index = preferred_mode_index;
+                    conf_output.power_mode = mir_power_mode_on;
                     done = true;
                 }
                 else
                 {
-                    conf.configure_output(conf_output.id, false,
-                                          conf_output.top_left,
-                                          conf_output.current_mode_index,
-                                          conf_output.current_format,
-                                          mir_power_mode_on,
-                                          mir_orientation_normal);
+                    conf_output.used = false;
+                    conf_output.power_mode = mir_power_mode_off;
                 }
             });
     }
 
=== modified file 'include/platform/mir/graphics/display_configuration.h'
--- include/platform/mir/graphics/display_configuration.h	2014-03-05 02:30:30 +0000
+++ include/platform/mir/graphics/display_configuration.h	2014-03-17 15:02:33 +0000
@@ -114,6 +114,31 @@
     /** The logical rectangle occupied by the output, based on its position,
         current mode and orientation (rotation) */
     geometry::Rectangle extents() const;
+    bool valid() const;
+};
+
+/**
+ * Mirror of a DisplayConfigurationOutput, with some fields limited to
+ * being read-only, preventing users from changing things they shouldn't.
+ */
+struct UserDisplayConfigurationOutput
+{
+    DisplayConfigurationOutputId const& id;
+    DisplayConfigurationCardId const& card_id;
+    DisplayConfigurationOutputType const& type;
+    std::vector<MirPixelFormat> const& pixel_formats;
+    std::vector<DisplayConfigurationMode> const& modes;
+    size_t const& preferred_mode_index;
+    geometry::Size const& physical_size_mm;
+    bool const& connected;
+    bool& used;
+    geometry::Point& top_left;
+    size_t& current_mode_index;
+    MirPixelFormat& current_format;
+    MirPowerMode& power_mode;
+    MirOrientation& orientation;
+
+    UserDisplayConfigurationOutput(DisplayConfigurationOutput& master);
 };
 
 std::ostream& operator<<(std::ostream& out, DisplayConfigurationCard const& val);
@@ -140,13 +165,8 @@
     virtual void for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const = 0;
     /** Executes a function object for each output in the configuration. */
     virtual void for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const = 0;
-
-    /** Configures an output. */
-    virtual void configure_output(DisplayConfigurationOutputId id, bool used,
-                                  geometry::Point top_left, size_t mode_index,
-                                  MirPixelFormat format,
-                                  MirPowerMode power_mode,
-                                  MirOrientation orientation) = 0;
+    virtual void for_each_output(std::function<void(UserDisplayConfigurationOutput&)> f) = 0;
+    virtual bool valid() const;
 
 protected:
     DisplayConfiguration() = default;
 
=== renamed file 'src/platform/graphics/mesa/overlapping_output_grouping.h' => 'include/platform/mir/graphics/overlapping_output_grouping.h'
--- src/platform/graphics/mesa/overlapping_output_grouping.h	2014-01-22 10:03:11 +0000
+++ include/platform/mir/graphics/overlapping_output_grouping.h	2014-03-17 15:02:33 +0000
@@ -16,8 +16,8 @@
  * Authored by: Alexandros Frantzis <[e-mail]>
  */
 
-#ifndef MIR_GRAPHICS_MESA_OVERLAPPING_OUTPUT_GROUPING_H_
-#define MIR_GRAPHICS_MESA_OVERLAPPING_OUTPUT_GROUPING_H_
+#ifndef MIR_GRAPHICS_OVERLAPPING_OUTPUT_GROUPING_H_
+#define MIR_GRAPHICS_OVERLAPPING_OUTPUT_GROUPING_H_
 
 #include <vector>
 #include <functional>
@@ -34,9 +34,6 @@
 class DisplayConfiguration;
 struct DisplayConfigurationOutput;
 
-namespace mesa
-{
-
 class OverlappingOutputGroup
 {
 public:
@@ -67,6 +64,5 @@
 
 }
 }
-}
 
-#endif /* MIR_GRAPHICS_MESA_OVERLAPPING_OUTPUT_GROUPING_H_ */
+#endif /* MIR_GRAPHICS_OVERLAPPING_OUTPUT_GROUPING_H_ */
 
=== modified file 'include/platform/mir/graphics/renderable.h'
--- include/platform/mir/graphics/renderable.h	2014-03-04 04:19:26 +0000
+++ include/platform/mir/graphics/renderable.h	2014-03-17 15:02:33 +0000
@@ -20,6 +20,7 @@
 #define MIR_GRAPHICS_RENDERABLE_H_
 
 #include <mir/geometry/rectangle.h>
+#include <glm/glm.hpp>
 #include <memory>
 
 namespace mir
@@ -31,10 +32,47 @@
 class Renderable
 {
 public:
-    virtual std::shared_ptr<Buffer> buffer() const = 0;
+    /**
+     * Return the next buffer that should be composited/rendered.
+     *
+     * \param [in] frameno The frameno parameter is important for
+     *                     multi-monitor platforms. Calls with the same frameno
+     *                     will get the same buffer returned. This ensures that
+     *                     a surface visible on multiple outputs does not get
+     *                     its buffers consumed any faster than the refresh
+     *                     rate of a single monitor. Implementations may ignore
+     *                     the value of frameno on single-monitor platforms
+     *                     only. The caller should always ensure the frameno
+     *                     is different to the previous frame. The exact value
+     *                     of frameno is not important but a large range of
+     *                     values is recommended.
+     */
+    virtual std::shared_ptr<Buffer> buffer(unsigned long frameno) const = 0;
+
     virtual bool alpha_enabled() const = 0;
     virtual geometry::Rectangle screen_position() const = 0;
 
+    // These are from the old CompositingCriteria. There is a little bit
+    // of function overlap with the above functions still.
+    virtual float alpha() const = 0;
+
+    /**
+     * Transformation returns the transformation matrix that should be applied
+     * to the surface. By default when there are no transformations this will
+     * be the identity matrix.
+     *
+     * \warning As this functionality is presently only used by
+     *          mir_demo_standalone_render_surfaces for rotations it may be
+     *          deprecated in future. It is expected that real transformations
+     *          may become more transient things (e.g. applied by animation
+     *          logic externally instead of being a semi-permanent attribute of
+     *          the surface itself).
+     */
+    virtual glm::mat4 transformation() const = 0;
+    virtual bool should_be_rendered_in(geometry::Rectangle const& rect) const = 0;
+    virtual bool shaped() const = 0;  // meaning the pixel format has alpha
+    virtual int buffers_ready_for_compositor() const = 0;
+
 protected:
     Renderable() = default;
     virtual ~Renderable() = default;
 
=== modified file 'include/platform/mir/options/configuration.h'
--- include/platform/mir/options/configuration.h	2014-02-20 17:59:00 +0000
+++ include/platform/mir/options/configuration.h	2014-03-17 15:02:33 +0000
@@ -39,7 +39,6 @@
 extern char const* const scene_report_opt;
 extern char const* const input_report_opt;
 extern char const* const host_socket_opt;
-extern char const* const standalone_opt;
 extern char const* const frontend_threads_opt;
 
 extern char const* const name_opt;
 
=== modified file 'include/server/mir/compositor/buffer_stream.h'
--- include/server/mir/compositor/buffer_stream.h	2014-02-10 09:07:48 +0000
+++ include/server/mir/compositor/buffer_stream.h	2014-03-17 15:02:33 +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,
@@ -50,6 +50,7 @@
     virtual void resize(geometry::Size const& size) = 0;
     virtual void allow_framedropping(bool) = 0;
     virtual void force_requests_to_complete() = 0;
+    virtual int buffers_ready_for_compositor() const = 0;
 };
 
 }
 
=== removed file 'include/server/mir/compositor/compositing_criteria.h'
--- include/server/mir/compositor/compositing_criteria.h	2014-03-10 19:28:33 +0000
+++ include/server/mir/compositor/compositing_criteria.h	1970-01-01 00:00:00 +0000
@@ -1,52 +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: Kevin DuBois <[e-mail]>
- */
-
-#ifndef MIR_COMPOSITOR_COMPOSITING_CRITERIA_H_
-#define MIR_COMPOSITOR_COMPOSITING_CRITERIA_H_
-
-#include <glm/glm.hpp>
-
-namespace mir
-{
-namespace geometry
-{
-struct Rectangle;
-}
-namespace compositor
-{
-
-class CompositingCriteria
-{
-public:
-    virtual float alpha() const = 0;
-    virtual glm::mat4 const& transformation() const = 0;
-    virtual bool should_be_rendered_in(geometry::Rectangle const& rect) const = 0;
-    virtual bool shaped() const = 0;  // meaning the pixel format has alpha
-
-    virtual ~CompositingCriteria() = default;
-
-protected:
-    CompositingCriteria() = default;
-    CompositingCriteria(CompositingCriteria const&) = delete;
-    CompositingCriteria& operator=(CompositingCriteria const&) = delete;
-};
-
-}
-}
-
-#endif /* MIR_COMPOSITOR_COMPOSITING_CRITERIA_H_ */
 
=== modified file 'include/server/mir/compositor/display_buffer_compositor.h'
--- include/server/mir/compositor/display_buffer_compositor.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/compositor/display_buffer_compositor.h	2014-03-17 15:02:33 +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 General Public License version 3,
@@ -30,7 +30,9 @@
 public:
     virtual ~DisplayBufferCompositor() = default;
 
-    virtual void composite() = 0;
+    /// Returns true if there is additional work to do. E.g. a composited surface
+    /// has additional buffers ready to composite or during animation
+    virtual bool composite() = 0;
 
 protected:
     DisplayBufferCompositor() = default;
 
=== renamed file 'src/server/compositor/gl_renderer.h' => 'include/server/mir/compositor/gl_renderer.h'
--- src/server/compositor/gl_renderer.h	2014-03-04 04:19:26 +0000
+++ include/server/mir/compositor/gl_renderer.h	2014-03-17 15:02:33 +0000
@@ -19,11 +19,12 @@
 #ifndef MIR_COMPOSITOR_GL_RENDERER_H_
 #define MIR_COMPOSITOR_GL_RENDERER_H_
 
-#include "renderer.h"
-#include "mir/geometry/rectangle.h"
-#include "mir/graphics/buffer_id.h"
+#include <mir/compositor/renderer.h>
+#include <mir/geometry/rectangle.h>
+#include <mir/graphics/buffer_id.h>
 #include <GLES2/gl2.h>
 #include <unordered_map>
+#include <vector>
 
 namespace mir
 {
@@ -40,27 +41,52 @@
     void set_viewport(geometry::Rectangle const& rect) override;
     void set_rotation(float degrees) override;
     void begin() const override;
-    void render(CompositingCriteria const& info, graphics::Buffer& buffer) const override;
+    void render(graphics::Renderable const& renderable,
+                graphics::Buffer& buffer) const override;
     void end() const override;
 
     // This is called _without_ a GL context:
     void suspend() override;
 
+    struct Vertex
+    {
+        GLfloat position[3];
+        GLfloat texcoord[2];
+    };
+
+    /**
+     * tessellate defines the list of triangles that will be used to render
+     * the surface. By default it just returns 4 vertices for a rectangle.
+     * However you can override its behaviour to tessellate more finely and
+     * deform freely for effects like wobbly windows.
+     *
+     * \returns The mode to be passed to glDrawArrays, e.g. GL_TRIANGLE_STRIP,
+     *          GL_TRIANGLE_FAN or GL_TRIANGLES.
+     *
+     * \note The cohesion of this function to GLRenderer is quite loose and it
+     *       does not strictly need to reside here.
+     *       However it seems a good choice under GLRenderer while this remains
+     *       the only OpenGL-specific class in the display server, and
+     *       tessellation is very much OpenGL-specific.
+     */
+    virtual GLenum tessellate(graphics::Renderable const& renderable,
+                              std::vector<Vertex>& vertices) const;
+
 private:
     GLuint vertex_shader;
     GLuint fragment_shader;
     GLuint program;
     GLuint position_attr_loc;
     GLuint texcoord_attr_loc;
+    GLuint centre_uniform_loc;
     GLuint display_transform_uniform_loc;
     GLuint transform_uniform_loc;
     GLuint alpha_uniform_loc;
-    GLuint vertex_attribs_vbo;
     float rotation;
 
     geometry::Rectangle viewport;
 
-    typedef CompositingCriteria const* SurfaceID;
+    typedef graphics::Renderable const* SurfaceID;
     struct Texture
     {
         GLuint id = 0;
 
=== renamed file 'src/server/compositor/renderer.h' => 'include/server/mir/compositor/renderer.h'
--- src/server/compositor/renderer.h	2014-03-04 04:19:26 +0000
+++ include/server/mir/compositor/renderer.h	2014-03-17 15:02:33 +0000
@@ -26,10 +26,10 @@
 namespace graphics
 {
 class Buffer;
+class Renderable;
 }
 namespace compositor
 {
-class CompositingCriteria;
 
 class Renderer
 {
@@ -39,7 +39,11 @@
     virtual void set_viewport(geometry::Rectangle const& rect) = 0;
     virtual void set_rotation(float degrees) = 0;
     virtual void begin() const = 0;
-    virtual void render(CompositingCriteria const& info, graphics::Buffer& buffer) const = 0;
+
+    // XXX The buffer parameter here could now be replaced with a "frameno"
+    //     instead, and use renderable.buffer(frameno). Is that better?
+    virtual void render(graphics::Renderable const& renderable,
+                        graphics::Buffer& buffer) const = 0;
     virtual void end() const = 0;
 
     virtual void suspend() = 0; // called when begin/render/end skipped
 
=== renamed file 'src/server/compositor/renderer_factory.h' => 'include/server/mir/compositor/renderer_factory.h'
=== modified file 'include/server/mir/compositor/scene.h'
--- include/server/mir/compositor/scene.h	2014-03-04 04:19:26 +0000
+++ include/server/mir/compositor/scene.h	2014-03-17 15:02:33 +0000
@@ -26,17 +26,16 @@
 
 namespace mir
 {
+namespace graphics { class Renderable; }
 namespace compositor
 {
-class BufferStream;
-class CompositingCriteria;
 
 class FilterForScene
 {
 public:
     virtual ~FilterForScene() {}
 
-    virtual bool operator()(CompositingCriteria const&) = 0;
+    virtual bool operator()(graphics::Renderable const&) = 0;
 
 protected:
     FilterForScene() = default;
@@ -49,7 +48,7 @@
 public:
     virtual ~OperatorForScene() {}
 
-    virtual void operator()(CompositingCriteria const&, BufferStream&) = 0;
+    virtual void operator()(graphics::Renderable const&) = 0;
 
 protected:
     OperatorForScene() = default;
 
=== modified file 'include/server/mir/frontend/screencast.h'
--- include/server/mir/frontend/screencast.h	2014-01-30 13:08:32 +0000
+++ include/server/mir/frontend/screencast.h	2014-03-17 15:02:33 +0000
@@ -39,7 +39,9 @@
     virtual ~Screencast() = default;
 
     virtual ScreencastSessionId create_session(
-        graphics::DisplayConfigurationOutputId output_id) = 0;
+        mir::geometry::Rectangle const& region,
+        mir::geometry::Size const& size,
+        MirPixelFormat pixel_format) = 0;
     virtual void destroy_session(ScreencastSessionId id) = 0;
     virtual std::shared_ptr<graphics::Buffer> capture(ScreencastSessionId id) = 0;
 
 
=== modified file 'include/server/mir/shell/session.h'
--- include/server/mir/shell/session.h	2014-03-04 04:19:26 +0000
+++ include/server/mir/shell/session.h	2014-03-17 15:02:33 +0000
@@ -33,7 +33,6 @@
 class Session : public frontend::Session
 {
 public:
-    virtual std::string name() const = 0;
     virtual void force_requests_to_complete() = 0;
     virtual pid_t process_id() const = 0;
 
 
=== modified file 'include/shared/mir_toolkit/client_types.h'
--- include/shared/mir_toolkit/client_types.h	2014-02-10 09:07:48 +0000
+++ include/shared/mir_toolkit/client_types.h	2014-03-17 15:02:33 +0000
@@ -267,15 +267,35 @@
     void *context;
 } MirEventDelegate;
 
+typedef struct MirRectangle
+{
+    int left;
+    int top;
+    unsigned int width;
+    unsigned int height;
+} MirRectangle;
+
 /**
  * MirScreencastParameters is the structure of required information that
  * you must provide to Mir in order to create a MirScreencast.
+ * The width and height parameters can be used to down-scale the screencast
+ * For no scaling set them to the region width and height.
  */
 typedef struct MirScreencastParameters
 {
-    uint32_t output_id;
-    uint32_t width;
-    uint32_t height;
+    /**
+     * The rectangular region of the screen to capture -
+     * The region is specified in virtual screen space hence multiple screens can be captured simultaneously
+     */
+    MirRectangle region;
+    /** The width of the screencast which can be different than the screen region capture width */
+    unsigned int width;
+    /** The height of the screencast which can be different than the screen region capture height */
+    unsigned int height;
+    /**
+     * The pixel format of the screencast.
+     * It must be a supported format obtained from mir_connection_get_available_surface_formats.
+     */
     MirPixelFormat pixel_format;
 } MirScreencastParameters;
 
 
=== renamed directory 'include/test/mir_test/draw' => 'include/shared/testdraw'
=== modified file 'include/shared/testdraw/draw_pattern_checkered-inl.h'
--- include/test/mir_test/draw/draw_pattern_checkered-inl.h	2014-03-04 04:19:26 +0000
+++ include/shared/testdraw/draw_pattern_checkered-inl.h	2014-03-17 15:02:33 +0000
@@ -2,15 +2,15 @@
  * 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,
+ * under the terms of the GNU Lesser General Public License version 3,
  * as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
+ * 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]>
 
=== modified file 'include/shared/testdraw/graphics_region_factory.h'
--- include/test/mir_test/draw/graphics_region_factory.h	2014-03-04 04:19:26 +0000
+++ include/shared/testdraw/graphics_region_factory.h	2014-03-17 15:02:33 +0000
@@ -2,15 +2,15 @@
  * 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,
+ * under the terms of the GNU Lesser General Public License version 3,
  * as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
+ * 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]>
@@ -34,7 +34,7 @@
 public:
     virtual ~GraphicsRegionFactory() {}
     virtual std::shared_ptr<MirGraphicsRegion> graphic_region_from_handle(
-        graphics::NativeBuffer const& native_buffer) = 0;
+        graphics::NativeBuffer& native_buffer) = 0;
 
 protected:
     GraphicsRegionFactory() = default;
 
=== modified file 'include/shared/testdraw/patterns.h'
--- include/test/mir_test/draw/patterns.h	2014-03-04 04:19:26 +0000
+++ include/shared/testdraw/patterns.h	2014-03-17 15:02:33 +0000
@@ -2,15 +2,15 @@
  * 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,
+ * under the terms of the GNU Lesser General Public License version 3,
  * as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
+ * 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]>
 
=== renamed file 'include/test/mir_test_doubles/stub_compositing_criteria.h' => 'include/test/mir_test_doubles/fake_renderable.h'
--- include/test/mir_test_doubles/stub_compositing_criteria.h	2014-03-04 04:19:26 +0000
+++ include/test/mir_test_doubles/fake_renderable.h	2014-03-17 15:02:33 +0000
@@ -16,10 +16,11 @@
  * Authored by: Daniel van Vugt <[e-mail]>
  */
 
-#ifndef MIR_TEST_DOUBLES_STUB_COMPOSITING_CRITERIA_H_
-#define MIR_TEST_DOUBLES_STUB_COMPOSITING_CRITERIA_H_
+#ifndef MIR_TEST_DOUBLES_FAKE_RENDERABLE_H_
+#define MIR_TEST_DOUBLES_FAKE_RENDERABLE_H_
 
-#include "mir/compositor/compositing_criteria.h"
+#include "mir/graphics/renderable.h"
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/matrix_transform.hpp>
 #include <gmock/gmock.h>
 
@@ -30,24 +31,20 @@
 namespace doubles
 {
 
-class StubCompositingCriteria : public compositor::CompositingCriteria
+class FakeRenderable : public graphics::Renderable
 {
 public:
-    StubCompositingCriteria(int x, int y, int width, int height,
-                            float opacity=1.0f,
-                            bool rectangular=true,
-                            bool visible=true,
-                            bool posted=true)
+    FakeRenderable(int x, int y, int width, int height,
+                   float opacity=1.0f,
+                   bool rectangular=true,
+                   bool visible=true,
+                   bool posted=true)
         : rect{{x, y}, {width, height}},
           opacity(opacity),
           rectangular(rectangular),
           visible(visible),
           posted(posted)
     {
-        const glm::mat4 ident;
-        glm::vec3 size(width, height, 0.0f);
-        glm::vec3 pos(x + width / 2, y + height / 2, 0.0f);
-        trans = glm::scale( glm::translate(ident, pos), size);
     }
 
     float alpha() const override
@@ -55,9 +52,9 @@
         return opacity;
     }
 
-    glm::mat4 const& transformation() const override
+    glm::mat4 transformation() const override
     {
-        return trans;
+        return glm::mat4();
     }
 
     bool should_be_rendered_in(const mir::geometry::Rectangle &r) const override
@@ -70,9 +67,34 @@
         return !rectangular;
     }
 
+    void set_buffer(std::shared_ptr<graphics::Buffer> b)
+    {
+        buf = b;
+    }
+
+    std::shared_ptr<graphics::Buffer> buffer(unsigned long) const override
+    {
+        return buf;
+    }
+
+    bool alpha_enabled() const override
+    {
+        return shaped() || alpha() < 1.0f;
+    }
+
+    geometry::Rectangle screen_position() const override
+    {
+        return rect;
+    }
+
+    int buffers_ready_for_compositor() const override
+    {
+        return 1;
+    }
+
 private:
+    std::shared_ptr<graphics::Buffer> buf;
     mir::geometry::Rectangle rect;
-    glm::mat4 trans;
     float opacity;
     bool rectangular;
     bool visible;
@@ -82,4 +104,4 @@
 } // namespace doubles
 } // namespace test
 } // namespace mir
-#endif // MIR_TEST_DOUBLES_STUB_COMPOSITING_CRITERIA_H_
+#endif // MIR_TEST_DOUBLES_FAKE_RENDERABLE_H_
 
=== modified file 'include/test/mir_test_doubles/mock_android_native_buffer.h'
--- include/test/mir_test_doubles/mock_android_native_buffer.h	2014-02-10 09:07:48 +0000
+++ include/test/mir_test_doubles/mock_android_native_buffer.h	2014-03-17 15:02:33 +0000
@@ -20,6 +20,7 @@
 #define MIR_TEST_DOUBLES_MOCK_ANDROID_NATIVE_BUFFER_H_
 
 #include "mir/graphics/android/native_buffer.h"
+#include "mir/geometry/size.h"
 #include <gmock/gmock.h>
 
 namespace mir
@@ -41,6 +42,14 @@
         ON_CALL(*this, copy_fence())
             .WillByDefault(Return(-1));
     }
+
+    MockAndroidNativeBuffer(geometry::Size sz)
+        : MockAndroidNativeBuffer()
+    {
+        stub_anwb.width = sz.width.as_int();
+        stub_anwb.height = sz.height.as_int();
+    }
+
     MOCK_CONST_METHOD0(anwb, ANativeWindowBuffer*());
     MOCK_CONST_METHOD0(handle, buffer_handle_t());
     MOCK_CONST_METHOD0(copy_fence, graphics::android::NativeFence());
 
=== modified file 'include/test/mir_test_doubles/mock_buffer_bundle.h'
--- include/test/mir_test_doubles/mock_buffer_bundle.h	2014-02-10 09:07:48 +0000
+++ include/test/mir_test_doubles/mock_buffer_bundle.h	2014-03-17 15:02:33 +0000
@@ -48,6 +48,7 @@
     MOCK_METHOD0(force_client_abort, void());
     MOCK_METHOD0(force_requests_to_complete, void());
     MOCK_METHOD1(resize, void(const geometry::Size &));
+    int buffers_ready_for_compositor() const override { return 1; }
 };
 
 }
 
=== modified file 'include/test/mir_test_doubles/mock_buffer_stream.h'
--- include/test/mir_test_doubles/mock_buffer_stream.h	2014-02-10 09:07:48 +0000
+++ include/test/mir_test_doubles/mock_buffer_stream.h	2014-03-17 15:02:33 +0000
@@ -42,6 +42,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; }
 };
 }
 }
 
=== removed file 'include/test/mir_test_doubles/mock_compositing_criteria.h'
--- include/test/mir_test_doubles/mock_compositing_criteria.h	2014-03-10 19:28:33 +0000
+++ include/test/mir_test_doubles/mock_compositing_criteria.h	1970-01-01 00:00:00 +0000
@@ -1,45 +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: Kevin DuBois <[e-mail]>
- */
-
-#ifndef MIR_TEST_DOUBLES_MOCK_COMPOSITING_CRITERIA_H_
-#define MIR_TEST_DOUBLES_MOCK_COMPOSITING_CRITERIA_H_
-
-#include "mir/compositor/compositing_criteria.h"
-#include <gmock/gmock.h>
-
-namespace mir
-{
-namespace test
-{
-namespace doubles
-{
-
-class MockCompositingCriteria : public compositor::CompositingCriteria
-{
-public:
-    ~MockCompositingCriteria() noexcept {}
-    MOCK_CONST_METHOD0(alpha, float());
-    MOCK_CONST_METHOD0(transformation, glm::mat4 const&());
-    MOCK_CONST_METHOD1(should_be_rendered_in, bool(geometry::Rectangle const&));
-    MOCK_CONST_METHOD0(shaped, bool());
-};
-
-}
-}
-}
-#endif /* MIR_TEST_DOUBLES_MOCK_COMPOSITING_CRITERIA_H_ */
 
=== modified file 'include/test/mir_test_doubles/mock_display_device.h'
--- include/test/mir_test_doubles/mock_display_device.h	2014-02-28 13:51:43 +0000
+++ include/test/mir_test_doubles/mock_display_device.h	2014-03-17 15:02:33 +0000
@@ -21,6 +21,7 @@
 
 #include "mir/graphics/buffer.h"
 #include "src/platform/graphics/android/display_device.h"
+#include "src/platform/graphics/android/gl_context.h"
 #include <gmock/gmock.h>
 
 namespace mir
@@ -34,9 +35,11 @@
 public:
     ~MockDisplayDevice() noexcept {}
     MOCK_METHOD1(mode, void(MirPowerMode));
-    MOCK_METHOD0(prepare_gl, void());
-    MOCK_METHOD1(prepare_gl_and_overlays, void(std::list<std::shared_ptr<graphics::Renderable>> const&));
-    MOCK_METHOD2(gpu_render, void(EGLDisplay, EGLSurface));
+    MOCK_METHOD1(render_gl, void(graphics::android::SwappingGLContext const&));
+    MOCK_METHOD3(render_gl_and_overlays, void(
+        graphics::android::SwappingGLContext const&,
+        std::list<std::shared_ptr<graphics::Renderable>> const&,
+        std::function<void(graphics::Renderable const&)> const&));
     MOCK_METHOD1(post, void(graphics::Buffer const&));
     MOCK_CONST_METHOD1(apply_orientation, bool(MirOrientation));
 };
 
=== modified file 'include/test/mir_test_doubles/mock_gl.h'
--- include/test/mir_test_doubles/mock_gl.h	2014-02-10 09:07:48 +0000
+++ include/test/mir_test_doubles/mock_gl.h	2014-03-17 15:02:33 +0000
@@ -61,6 +61,7 @@
     MOCK_METHOD3(glDrawArrays, void(GLenum, GLint, GLsizei));
     MOCK_METHOD1(glEnable, void(GLenum));
     MOCK_METHOD1(glEnableVertexAttribArray, void(GLuint));
+    MOCK_METHOD0(glFinish, void());
     MOCK_METHOD4(glFramebufferRenderbuffer,
                  void(GLenum, GLenum, GLenum, GLuint));
     MOCK_METHOD5(glFramebufferTexture2D,
@@ -92,7 +93,8 @@
                  void(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum,
                       GLenum,const GLvoid*));
     MOCK_METHOD3(glTexParameteri, void(GLenum, GLenum, GLenum));
-    MOCK_METHOD2(glUniform1f, void(GLuint, GLfloat));
+    MOCK_METHOD2(glUniform1f, void(GLint, GLfloat));
+    MOCK_METHOD3(glUniform2f, void(GLint, GLfloat, GLfloat));
     MOCK_METHOD2(glUniform1i, void(GLint, GLint));
     MOCK_METHOD4(glUniformMatrix4fv,
                  void(GLuint, GLsizei, GLboolean, const GLfloat *));
@@ -101,7 +103,6 @@
                  void(GLuint, GLint, GLenum, GLboolean, GLsizei,
                       const GLvoid *));
     MOCK_METHOD4(glViewport, void(GLint, GLint, GLsizei, GLsizei));
-    MOCK_METHOD0(glFinish, void());
 };
 
 }
 
=== added file 'include/test/mir_test_doubles/mock_render_function.h'
--- include/test/mir_test_doubles/mock_render_function.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_render_function.h	2014-03-17 15:02:33 +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: 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_ */
 
=== added file 'include/test/mir_test_doubles/mock_render_function.h.moved'
--- include/test/mir_test_doubles/mock_render_function.h.moved	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_render_function.h.moved	2014-03-17 15:02:33 +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: 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-03-04 04:19:26 +0000
+++ include/test/mir_test_doubles/mock_renderable.h	2014-03-17 15:02:33 +0000
@@ -19,6 +19,7 @@
 #ifndef MIR_TEST_DOUBLES_MOCK_RENDERABLE_H_
 #define MIR_TEST_DOUBLES_MOCK_RENDERABLE_H_
 
+#include "mir_test_doubles/stub_buffer.h"
 #include <mir/graphics/renderable.h>
 #include <gmock/gmock.h>
 
@@ -30,9 +31,21 @@
 {
 struct MockRenderable : public graphics::Renderable
 {
-    MOCK_CONST_METHOD0(buffer, std::shared_ptr<graphics::Buffer>());
+    MockRenderable()
+    {
+        ON_CALL(*this, screen_position())
+            .WillByDefault(testing::Return(geometry::Rectangle{{},{}}));
+        ON_CALL(*this, buffer(testing::_))
+            .WillByDefault(testing::Return(std::make_shared<StubBuffer>()));
+    }
+    MOCK_CONST_METHOD1(buffer, std::shared_ptr<graphics::Buffer>(unsigned long));
     MOCK_CONST_METHOD0(alpha_enabled, bool());
     MOCK_CONST_METHOD0(screen_position, geometry::Rectangle());
+    MOCK_CONST_METHOD0(alpha, float());
+    MOCK_CONST_METHOD0(transformation, glm::mat4());
+    MOCK_CONST_METHOD1(should_be_rendered_in, bool(geometry::Rectangle const& rect));
+    MOCK_CONST_METHOD0(shaped, bool());
+    int buffers_ready_for_compositor() const override { return 1; }
 };
 }
 }
 
=== modified file 'include/test/mir_test_doubles/mock_renderer.h'
--- include/test/mir_test_doubles/mock_renderer.h	2014-03-04 04:19:26 +0000
+++ include/test/mir_test_doubles/mock_renderer.h	2014-03-17 15:02:33 +0000
@@ -18,7 +18,7 @@
 #ifndef MIR_TEST_DOUBLES_MOCK_RENDERER_H_
 #define MIR_TEST_DOUBLES_MOCK_RENDERER_H_
 
-#include "src/server/compositor/renderer.h"
+#include "mir/compositor/renderer.h"
 
 #include <gmock/gmock.h>
 
@@ -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(compositor::CompositingCriteria const&, graphics::Buffer&));
+    MOCK_CONST_METHOD2(render, void(graphics::Renderable const&, graphics::Buffer&));
     MOCK_CONST_METHOD0(end, void());
     MOCK_METHOD0(suspend, void());
 
 
=== added file 'include/test/mir_test_doubles/mock_scene.h'
--- include/test/mir_test_doubles/mock_scene.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_scene.h	2014-03-17 15:02:33 +0000
@@ -0,0 +1,48 @@
+/*
+ * 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: Daniel van Vugt <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_SCENE_H_
+#define MIR_TEST_DOUBLES_MOCK_SCENE_H_
+
+#include "mir/compositor/scene.h"
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class MockScene : public compositor::Scene
+{
+public:
+    MOCK_METHOD2(for_each_if, void(compositor::FilterForScene&,
+                                   compositor::OperatorForScene&));
+    MOCK_METHOD2(reverse_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());
+};
+
+} // namespace doubles
+} // namespace test
+} // namespace mir
+
+#endif /* MIR_TEST_DOUBLES_MOCK_SCENE_H_ */
 
=== modified file 'include/test/mir_test_doubles/mock_screencast.h'
--- include/test/mir_test_doubles/mock_screencast.h	2014-01-29 18:02:33 +0000
+++ include/test/mir_test_doubles/mock_screencast.h	2014-03-17 15:02:33 +0000
@@ -33,9 +33,11 @@
 class MockScreencast : public frontend::Screencast
 {
 public:
-    MOCK_METHOD1(create_session,
+    MOCK_METHOD3(create_session,
                  frontend::ScreencastSessionId(
-                     graphics::DisplayConfigurationOutputId));
+                     geometry::Rectangle const&,
+                     geometry::Size const&,
+                     MirPixelFormat));
     MOCK_METHOD1(destroy_session, void(frontend::ScreencastSessionId));
     MOCK_METHOD1(capture,
                  std::shared_ptr<graphics::Buffer>(
 
=== added file 'include/test/mir_test_doubles/mock_swapping_gl_context.h'
--- include/test/mir_test_doubles/mock_swapping_gl_context.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_swapping_gl_context.h	2014-03-17 15:02:33 +0000
@@ -0,0 +1,39 @@
+/*
+ * 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_SWAPPING_GL_CONTEXT_H_
+#define MIR_TEST_DOUBLES_MOCK_SWAPPING_GL_CONTEXT_H_
+
+#include "src/platform/graphics/android/gl_context.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct MockSwappingGLContext : public graphics::android::SwappingGLContext
+{
+    MOCK_CONST_METHOD0(swap_buffers, void());
+};
+
+}
+}
+}
+#endif // MIR_TEST_DOUBLES_MOCK_COMPOSITING_CRITERIA_H_
 
=== modified file 'include/test/mir_test_doubles/null_display_configuration.h'
--- include/test/mir_test_doubles/null_display_configuration.h	2014-03-05 02:30:30 +0000
+++ include/test/mir_test_doubles/null_display_configuration.h	2014-03-17 15:02:33 +0000
@@ -35,7 +35,7 @@
     void for_each_output(std::function<void(graphics::DisplayConfigurationOutput const&)>) const override
     {
     }
-    void configure_output(graphics::DisplayConfigurationOutputId, bool, geometry::Point, size_t, MirPixelFormat, MirPowerMode, MirOrientation) override
+    void for_each_output(std::function<void(graphics::UserDisplayConfigurationOutput&)>) override
     {
     }
 };
 
=== modified file 'include/test/mir_test_doubles/null_screencast.h'
--- include/test/mir_test_doubles/null_screencast.h	2014-01-29 18:02:33 +0000
+++ include/test/mir_test_doubles/null_screencast.h	2014-03-17 15:02:33 +0000
@@ -32,7 +32,9 @@
 {
 public:
     frontend::ScreencastSessionId create_session(
-        graphics::DisplayConfigurationOutputId)
+        geometry::Rectangle const&,
+        geometry::Size const&,
+        MirPixelFormat)
     {
         return frontend::ScreencastSessionId{1};
     }
 
=== modified file 'include/test/mir_test_doubles/stub_buffer.h'
--- include/test/mir_test_doubles/stub_buffer.h	2014-03-04 04:19:26 +0000
+++ include/test/mir_test_doubles/stub_buffer.h	2014-03-17 15:02:33 +0000
@@ -39,20 +39,31 @@
 {
 public:
     StubBuffer()
-        : buf_size{0, 0},
-          buf_pixel_format{mir_pixel_format_abgr_8888}
+        : StubBuffer{
+              graphics::BufferProperties{
+                  geometry::Size{},
+                  mir_pixel_format_abgr_8888,
+                  graphics::BufferUsage::hardware}}
+
     {
     }
 
     StubBuffer(graphics::BufferProperties const& properties)
+        : StubBuffer{properties, geometry::Stride{}}
+    {
+    }
+
+    StubBuffer(graphics::BufferProperties const& properties,
+               geometry::Stride stride)
         : buf_size{properties.size},
-          buf_pixel_format{properties.format}
+          buf_pixel_format{properties.format},
+          buf_stride{stride}
     {
     }
 
     virtual geometry::Size size() const { return buf_size; }
 
-    virtual geometry::Stride stride() const { return geometry::Stride(); }
+    virtual geometry::Stride stride() const { return buf_stride; }
 
     virtual MirPixelFormat pixel_format() const { return buf_pixel_format; }
 
@@ -70,6 +81,7 @@
 
     geometry::Size const buf_size;
     MirPixelFormat const buf_pixel_format;
+    geometry::Stride const buf_stride;
 };
 }
 }
 
=== modified file 'include/test/mir_test_doubles/stub_buffer_stream.h'
--- include/test/mir_test_doubles/stub_buffer_stream.h	2014-02-10 09:07:48 +0000
+++ include/test/mir_test_doubles/stub_buffer_stream.h	2014-03-17 15:02:33 +0000
@@ -72,6 +72,8 @@
     {
     }
 
+    int buffers_ready_for_compositor() const override { return 1; }
+
     StubBuffer stub_client_buffer;
     std::shared_ptr<graphics::Buffer> stub_compositor_buffer;
 };
 
=== modified file 'include/test/mir_test_doubles/stub_display_configuration.h'
--- include/test/mir_test_doubles/stub_display_configuration.h	2014-03-05 02:30:30 +0000
+++ include/test/mir_test_doubles/stub_display_configuration.h	2014-03-17 15:02:33 +0000
@@ -156,8 +156,13 @@
         }
     }
 
-    void configure_output(graphics::DisplayConfigurationOutputId, bool, geometry::Point, size_t, MirPixelFormat, MirPowerMode, MirOrientation) override
+    void for_each_output(std::function<void(graphics::UserDisplayConfigurationOutput&)> f) override
     {
+        for (auto& disp : outputs)
+        {
+            graphics::UserDisplayConfigurationOutput user(disp);
+            f(user);
+        }
     }
 
     std::vector<graphics::DisplayConfigurationCard> cards;
 
=== modified file 'include/test/mir_test_doubles/stub_display_device.h'
--- include/test/mir_test_doubles/stub_display_device.h	2014-02-11 03:04:50 +0000
+++ include/test/mir_test_doubles/stub_display_device.h	2014-03-17 15:02:33 +0000
@@ -38,10 +38,13 @@
     void mode(MirPowerMode)
     {
     }
-    void prepare_gl_and_overlays(std::list<std::shared_ptr<graphics::Renderable>> const&)
+    void render_gl_and_overlays(
+        graphics::android::SwappingGLContext const&,
+        std::list<std::shared_ptr<graphics::Renderable>> const&,
+        std::function<void(graphics::Renderable const&)> const&)
     {
     }
-    void prepare_gl()
+    void render_gl(graphics::android::SwappingGLContext const&)
     {
     }
     void gpu_render(EGLDisplay, EGLSurface)
 
=== modified file 'include/test/mir_test_doubles/stub_renderable.h'
--- include/test/mir_test_doubles/stub_renderable.h	2014-03-04 04:19:26 +0000
+++ include/test/mir_test_doubles/stub_renderable.h	2014-03-17 15:02:33 +0000
@@ -19,6 +19,7 @@
 #ifndef MIR_TEST_DOUBLES_STUB_RENDERABLE_H_
 #define MIR_TEST_DOUBLES_STUB_RENDERABLE_H_
 
+#include "mir_test_doubles/stub_buffer.h"
 #include <mir/graphics/renderable.h>
 #include <memory>
 
@@ -32,9 +33,9 @@
 class StubRenderable : public graphics::Renderable
 {
 public:
-    std::shared_ptr<graphics::Buffer> buffer() const
+    std::shared_ptr<graphics::Buffer> buffer(unsigned long) const override
     {
-        return {};
+        return std::make_shared<StubBuffer>();
     }
     bool alpha_enabled() const
     {
@@ -44,6 +45,30 @@
     {
         return {{},{}};
     }
+    float alpha() const override
+    {
+        return 1.0f;
+    }
+    glm::mat4 transformation() const override
+    {
+        return trans;
+    }
+    bool should_be_rendered_in(geometry::Rectangle const&) const override
+    {
+        return true;
+    }
+    bool shaped() const override
+    {
+        return false;
+    }
+
+    int buffers_ready_for_compositor() const override
+    {
+        return 1;
+    }
+
+private:
+    glm::mat4 trans;
 };
 
 }
 
=== modified file 'include/test/mir_test_doubles/stub_renderer.h'
--- include/test/mir_test_doubles/stub_renderer.h	2014-03-04 04:19:26 +0000
+++ include/test/mir_test_doubles/stub_renderer.h	2014-03-17 15:02:33 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_TEST_DOUBLES_STUB_RENDERER_H_
 #define MIR_TEST_DOUBLES_STUB_RENDERER_H_
 
-#include "src/server/compositor/renderer.h"
+#include "mir/compositor/renderer.h"
 
 namespace mir
 {
@@ -43,7 +43,7 @@
     {
     }
 
-    void render(compositor::CompositingCriteria const&,
+    void render(graphics::Renderable const&,
                 graphics::Buffer&) const override
     {
     }
 
=== added file 'include/test/mir_test_doubles/stub_swapping_gl_context.h'
--- include/test/mir_test_doubles/stub_swapping_gl_context.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_swapping_gl_context.h	2014-03-17 15:02:33 +0000
@@ -0,0 +1,39 @@
+/*
+ * 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_STUB_SWAPPING_GL_CONTEXT_H_
+#define MIR_TEST_DOUBLES_STUB_SWAPPING_GL_CONTEXT_H_
+
+#include "src/platform/graphics/android/gl_context.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct StubSwappingGLContext : public graphics::android::SwappingGLContext
+{
+    void swap_buffers() const {}
+};
+
+}
+}
+}
+#endif // MIR_TEST_DOUBLES_STUB_COMPOSITING_CRITERIA_H_
 
=== modified file 'src/client/CMakeLists.txt'
--- src/client/CMakeLists.txt	2014-02-28 13:51:43 +0000
+++ src/client/CMakeLists.txt	2014-03-17 15:02:33 +0000
@@ -72,6 +72,7 @@
   mirsharedinput
   mirsharedlogging
   mirsharedenv
+  mirsharedgeometry
   mirsharedsharedlibrary
   mirclientrpc
   mirclientlttngstatic
 
=== modified file 'src/client/android/CMakeLists.txt'
--- src/client/android/CMakeLists.txt	2014-02-28 13:51:43 +0000
+++ src/client/android/CMakeLists.txt	2014-03-17 15:02:33 +0000
@@ -26,6 +26,8 @@
   ${LIBHARDWARE_LIBRARIES}
 )
 
+install(TARGETS mirclientplatformandroid LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/mir/clientplatform/android)
+
 if (MIR_TEST_PLATFORM STREQUAL "android")
   add_custom_command(TARGET mirclientplatformandroid
     POST_BUILD
@@ -33,6 +35,11 @@
     COMMAND ${CMAKE_COMMAND} -E create_symlink android/$<TARGET_FILE_NAME:mirclientplatformandroid> libmirclientplatform.so
     WORKING_DIRECTORY ${LIBRARY_OUTPUT_PATH}
   )
+
+  install(CODE
+    "execute_process(
+       COMMAND ln -sf mir/clientplatform/android/libmirclientplatform.so
+       WORKING_DIRECTORY \$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}
+     )"
+  )
 endif()
-
-install(TARGETS mirclientplatformandroid LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/mir/clientplatform/android)
 
=== modified file 'src/client/mesa/CMakeLists.txt'
--- src/client/mesa/CMakeLists.txt	2014-02-28 13:51:43 +0000
+++ src/client/mesa/CMakeLists.txt	2014-03-17 15:02:33 +0000
@@ -27,6 +27,8 @@
   ${DRM_LDFLAGS} ${DRM_LIBRARIES}
 )
 
+install(TARGETS mirclientplatformmesa LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/mir/clientplatform/mesa)
+
 if (MIR_TEST_PLATFORM STREQUAL "mesa")
   add_custom_command(TARGET mirclientplatformmesa
     POST_BUILD
@@ -34,7 +36,12 @@
     COMMAND ${CMAKE_COMMAND} -E create_symlink mesa/$<TARGET_FILE_NAME:mirclientplatformmesa> libmirclientplatform.so
     WORKING_DIRECTORY ${LIBRARY_OUTPUT_PATH}
   )
+
+  install(CODE
+    "execute_process(
+       COMMAND ln -sf mir/clientplatform/mesa/libmirclientplatform.so
+       WORKING_DIRECTORY \$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}
+     )"
+  )
 endif()
 
-install(TARGETS mirclientplatformmesa LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/mir/clientplatform/mesa)
-
 
=== modified file 'src/client/mir_screencast.cpp'
--- src/client/mir_screencast.cpp	2014-02-10 09:07:48 +0000
+++ src/client/mir_screencast.cpp	2014-03-17 15:02:33 +0000
@@ -31,23 +31,6 @@
 
 void null_callback(MirScreencast*, void*) {}
 
-geom::Size mir_output_get_size(MirDisplayOutput const& output)
-{
-    if (output.connected && output.used &&
-        output.current_mode < output.num_modes)
-    {
-        auto& current_mode = output.modes[output.current_mode];
-        return geom::Size{current_mode.horizontal_resolution,
-                          current_mode.vertical_resolution};
-    }
-    else
-    {
-        BOOST_THROW_EXCEPTION(
-            std::runtime_error("Couldn't get size from invalid output"));
-    }
-}
-
-
 void populate_buffer_package(
     MirBufferPackage& buffer_package,
     mir::protobuf::Buffer const& protobuf_buffer)
@@ -86,24 +69,38 @@
 }
 
 MirScreencast::MirScreencast(
-    MirDisplayOutput const& output,
+    geom::Rectangle const& region,
+    geom::Size const& size,
+    MirPixelFormat pixel_format,
     mir::protobuf::DisplayServer& server,
     std::shared_ptr<mcl::EGLNativeWindowFactory> const& egl_native_window_factory,
     std::shared_ptr<mcl::ClientBufferFactory> const& factory,
     mir_screencast_callback callback, void* context)
     : server(server),
-      output_id{output.output_id},
-      output_size{mir_output_get_size(output)},
-      output_format{output.current_format},
+      output_size{size},
+      output_format{pixel_format},
       egl_native_window_factory{egl_native_window_factory},
       buffer_depository{factory, mir::frontend::client_buffer_cache_size}
 {
+    if (output_size.width.as_int()  == 0 ||
+        output_size.height.as_int() == 0 ||
+        region.size.width.as_int()  == 0 ||
+        region.size.height.as_int() == 0 ||
+        pixel_format == mir_pixel_format_invalid)
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid parameters"));
+    }
     protobuf_screencast.set_error("Not initialized");
 
     mir::protobuf::ScreencastParameters parameters;
-    parameters.set_output_id(output_id);
+
+    parameters.mutable_region()->set_left(region.top_left.x.as_int());
+    parameters.mutable_region()->set_top(region.top_left.y.as_int());
+    parameters.mutable_region()->set_width(region.size.width.as_uint32_t());
+    parameters.mutable_region()->set_height(region.size.height.as_uint32_t());
     parameters.set_width(output_size.width.as_uint32_t());
     parameters.set_height(output_size.height.as_uint32_t());
+    parameters.set_pixel_format(pixel_format);
 
     server.create_screencast(
         nullptr,
@@ -132,7 +129,7 @@
         output_size.height.as_int(),
         output_format,
         mir_buffer_usage_hardware,
-        output_id};
+        mir_display_output_id_invalid};
 }
 
 std::shared_ptr<mcl::ClientBuffer> MirScreencast::get_current_buffer()
 
=== modified file 'src/client/mir_screencast.h'
--- src/client/mir_screencast.h	2014-02-10 09:07:48 +0000
+++ src/client/mir_screencast.h	2014-03-17 15:02:33 +0000
@@ -25,6 +25,7 @@
 #include "mir_toolkit/client_types.h"
 #include "mir_protobuf.pb.h"
 #include "mir/geometry/size.h"
+#include "mir/geometry/rectangle.h"
 
 #include <EGL/eglplatform.h>
 
@@ -42,7 +43,9 @@
 {
 public:
     MirScreencast(
-        MirDisplayOutput const& output,
+        mir::geometry::Rectangle const& region,
+        mir::geometry::Size const& size,
+        MirPixelFormat pixel_format,
         mir::protobuf::DisplayServer& server,
         std::shared_ptr<mir::client::EGLNativeWindowFactory> const& egl_native_window_factory,
         std::shared_ptr<mir::client::ClientBufferFactory> const& factory,
@@ -75,7 +78,6 @@
         mir_screencast_callback callback, void* context);
 
     mir::protobuf::DisplayServer& server;
-    uint32_t const output_id;
     mir::geometry::Size const output_size;
     MirPixelFormat const output_format;
     std::shared_ptr<mir::client::EGLNativeWindowFactory> const egl_native_window_factory;
 
=== modified file 'src/client/mir_screencast_api.cpp'
--- src/client/mir_screencast_api.cpp	2014-02-18 02:12:21 +0000
+++ src/client/mir_screencast_api.cpp	2014-03-17 15:02:33 +0000
@@ -26,25 +26,7 @@
 
 namespace
 {
-
 void null_callback(MirScreencast*, void*) {}
-
-MirDisplayOutput& find_display_output(
-    MirDisplayConfiguration const& config,
-    uint32_t output_id)
-{
-    for (decltype(config.num_outputs) i = 0; i != config.num_outputs; ++i)
-    {
-        if (config.outputs[i].output_id == output_id)
-        {
-            return config.outputs[i];
-        }
-    }
-
-    BOOST_THROW_EXCEPTION(
-        std::runtime_error("Couldn't find output with supplied id"));
-}
-
 }
 
 MirScreencast* mir_connection_create_screencast_sync(
@@ -64,9 +46,17 @@
 
         auto const client_platform = connection->get_client_platform();
 
+        mir::geometry::Rectangle const region{
+            {parameters->region.left, parameters->region.top},
+            {parameters->region.width, parameters->region.height}
+        };
+        mir::geometry::Size const size{parameters->width, parameters->height};
+
         std::unique_ptr<MirScreencast> screencast_uptr{
             new MirScreencast{
-                find_display_output(*config, parameters->output_id),
+                region,
+                size,
+                parameters->pixel_format,
                 connection->display_server(),
                 client_platform,
                 client_platform->create_buffer_factory(),
 
=== modified file 'src/client/mir_surface.h'
--- src/client/mir_surface.h	2014-02-10 09:07:48 +0000
+++ src/client/mir_surface.h	2014-03-17 15:02:33 +0000
@@ -106,8 +106,6 @@
     MirPixelFormat convert_ipc_pf_to_geometry(google::protobuf::int32 pf);
     void release_cpu_region();
 
-    /* todo: race condition. protobuf does not guarantee that callbacks will be synchronized. potential
-             race in surface, last_buffer_id */
     mir::protobuf::DisplayServer::Stub & server;
     mir::protobuf::Surface surface;
     std::string error_message;
 
=== modified file 'src/platform/graphics/CMakeLists.txt'
--- src/platform/graphics/CMakeLists.txt	2014-02-28 13:51:43 +0000
+++ src/platform/graphics/CMakeLists.txt	2014-03-17 15:02:33 +0000
@@ -10,6 +10,7 @@
   display_configuration.cpp
   buffer_basic.cpp
   pixel_format_utils.cpp
+  overlapping_output_grouping.cpp
 )
 
 add_library(
 
=== modified file 'src/platform/graphics/android/CMakeLists.txt'
--- src/platform/graphics/android/CMakeLists.txt	2014-02-28 13:51:43 +0000
+++ src/platform/graphics/android/CMakeLists.txt	2014-03-17 15:02:33 +0000
@@ -32,6 +32,7 @@
   interpreter_cache.cpp
   internal_client.cpp
   gl_context.cpp
+  real_hwc_wrapper.cpp
 )
 
 set_target_properties(
@@ -51,6 +52,8 @@
   ${GLESv2_LDFLAGS} ${GLESv2_LIBRARIES}
 )
 
+install(TARGETS mirplatformgraphicsandroid LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/mir/platformgraphics/android)
+
 if (MIR_TEST_PLATFORM STREQUAL "android")
   add_custom_command(TARGET mirplatformgraphicsandroid
     POST_BUILD
@@ -58,6 +61,11 @@
     COMMAND ${CMAKE_COMMAND} -E create_symlink android/$<TARGET_FILE_NAME:mirplatformgraphicsandroid> libmirplatformgraphics.so
     WORKING_DIRECTORY ${LIBRARY_OUTPUT_PATH}
   )
+
+  install(CODE
+    "execute_process(
+       COMMAND ln -sf mir/platformgraphics/android/libmirplatformgraphics.so
+       WORKING_DIRECTORY \$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}
+     )"
+  )
 endif()
-
-install(TARGETS mirplatformgraphicsandroid LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/mir/platformgraphics/android)
 
=== modified file 'src/platform/graphics/android/android_display.cpp'
--- src/platform/graphics/android/android_display.cpp	2014-03-05 02:30:30 +0000
+++ src/platform/graphics/android/android_display.cpp	2014-03-17 15:02:33 +0000
@@ -26,6 +26,8 @@
 #include "display_builder.h"
 #include "mir/geometry/rectangle.h"
 
+#include <boost/throw_exception.hpp>
+
 namespace mga=mir::graphics::android;
 namespace mg=mir::graphics;
 namespace geom=mir::geometry;
@@ -57,6 +59,12 @@
 
 void mga::AndroidDisplay::configure(mg::DisplayConfiguration const& configuration)
 {
+    if (!configuration.valid())
+    {
+        BOOST_THROW_EXCEPTION(
+            std::logic_error("Invalid or inconsistent display configuration"));
+    }
+
     configuration.for_each_output([&](mg::DisplayConfigurationOutput const& output)
     {
         display_buffer->configure(output);
 
=== modified file 'src/platform/graphics/android/android_display_configuration.cpp'
--- src/platform/graphics/android/android_display_configuration.cpp	2014-03-05 02:30:30 +0000
+++ src/platform/graphics/android/android_display_configuration.cpp	2014-03-17 15:02:33 +0000
@@ -52,10 +52,9 @@
     f(configuration);
 }
 
-void mga::AndroidDisplayConfiguration::configure_output(
-    mg::DisplayConfigurationOutputId, bool, geom::Point, size_t,
-    MirPixelFormat, MirPowerMode power_mode, MirOrientation orientation)
+void mga::AndroidDisplayConfiguration::for_each_output(std::function<void(mg::UserDisplayConfigurationOutput&)> f)
 {
-    configuration.power_mode = power_mode;
-    configuration.orientation = orientation;
+    mg::UserDisplayConfigurationOutput user(configuration);
+    f(user);
 }
+
 
=== modified file 'src/platform/graphics/android/android_display_configuration.h'
--- src/platform/graphics/android/android_display_configuration.h	2014-03-05 02:30:30 +0000
+++ src/platform/graphics/android/android_display_configuration.h	2014-03-17 15:02:33 +0000
@@ -37,10 +37,7 @@
 
     void for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const override;
     void for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const override;
-    void configure_output(DisplayConfigurationOutputId id, bool used,
-                          geometry::Point top_left, size_t mode_index,
-                          MirPixelFormat format, MirPowerMode power_mode,
-                          MirOrientation) override;
+    void for_each_output(std::function<void(UserDisplayConfigurationOutput&)> f) override;
 
 private:
     DisplayConfigurationOutput configuration;
 
=== modified file 'src/platform/graphics/android/display_buffer.cpp'
--- src/platform/graphics/android/display_buffer.cpp	2014-02-28 13:51:43 +0000
+++ src/platform/graphics/android/display_buffer.cpp	2014-03-17 15:02:33 +0000
@@ -85,35 +85,29 @@
 }
 
 void mga::DisplayBuffer::render_and_post_update(
-        std::list<std::shared_ptr<Renderable>> const& renderlist,
-        std::function<void(Renderable const&)> const& render_fn)
+    std::list<std::shared_ptr<Renderable>> const& renderlist,
+    std::function<void(Renderable const&)> const& render_fn)
 {
     if (renderlist.empty())
     {
-        display_device->prepare_gl();
+        display_device->render_gl(gl_context);
     }
     else
     {
-        display_device->prepare_gl_and_overlays(renderlist);
-    }
-
-    for(auto& renderable : renderlist)
-    {
-        render_fn(*renderable);
-    }
-
-    render_and_post();
+        display_device->render_gl_and_overlays(gl_context, renderlist, render_fn);
+    }
+
+    post();
 }
 
 void mga::DisplayBuffer::post_update()
 {
-    display_device->prepare_gl();
-    render_and_post();
+    display_device->render_gl(gl_context);
+    post();
 }
 
-void mga::DisplayBuffer::render_and_post()
+void mga::DisplayBuffer::post()
 {
-    display_device->gpu_render(gl_context.display(), gl_context.surface());
     auto last_rendered = fb_bundle->last_rendered_buffer();
     display_device->post(*last_rendered);
 }
 
=== modified file 'src/platform/graphics/android/display_buffer.h'
--- src/platform/graphics/android/display_buffer.h	2014-02-28 13:51:43 +0000
+++ src/platform/graphics/android/display_buffer.h	2014-03-17 15:02:33 +0000
@@ -58,7 +58,7 @@
     void configure(DisplayConfigurationOutput const&);
 
 private:
-    void render_and_post();
+    void post();
 
     std::shared_ptr<FramebufferBundle> const fb_bundle;
     std::shared_ptr<DisplayDevice> const display_device;
 
=== modified file 'src/platform/graphics/android/display_device.h'
--- src/platform/graphics/android/display_device.h	2014-02-28 13:51:43 +0000
+++ src/platform/graphics/android/display_device.h	2014-03-17 15:02:33 +0000
@@ -33,6 +33,7 @@
 
 namespace android
 {
+class SwappingGLContext;
 
 class DisplayDevice
 {
@@ -40,9 +41,11 @@
     virtual ~DisplayDevice() = default;
 
     virtual void mode(MirPowerMode mode) = 0;
-    virtual void prepare_gl() = 0;
-    virtual void prepare_gl_and_overlays(std::list<std::shared_ptr<Renderable>> const& list) = 0; 
-    virtual void gpu_render(EGLDisplay dpy, EGLSurface sur) = 0;
+    virtual void render_gl(SwappingGLContext const& context) = 0;
+    virtual void render_gl_and_overlays(
+        SwappingGLContext const& context,
+        std::list<std::shared_ptr<Renderable>> const& list,
+        std::function<void(Renderable const&)> const& render_fn) = 0;
     virtual void post(Buffer const& buffer) = 0;
     virtual bool apply_orientation(MirOrientation orientation) const = 0;
 
 
=== modified file 'src/platform/graphics/android/fb_device.cpp'
--- src/platform/graphics/android/fb_device.cpp	2014-02-28 13:51:43 +0000
+++ src/platform/graphics/android/fb_device.cpp	2014-03-17 15:02:33 +0000
@@ -19,6 +19,7 @@
 #include "mir/graphics/buffer.h"
 #include "mir/graphics/android/native_buffer.h"
 #include "mir/graphics/android/sync_fence.h"
+#include "gl_context.h"
 #include "android_format_conversion-inl.h"
 #include "fb_device.h"
 #include "framebuffer_bundle.h"
@@ -43,20 +44,20 @@
     mode(mir_power_mode_on);
 }
 
-void mga::FBDevice::prepare_gl()
-{
-}
-
-void mga::FBDevice::prepare_gl_and_overlays(std::list<std::shared_ptr<Renderable>> const&)
-{
-}
-
-void mga::FBDevice::gpu_render(EGLDisplay dpy, EGLSurface sur)
-{
-    if (eglSwapBuffers(dpy, sur) == EGL_FALSE)
-    {
-        BOOST_THROW_EXCEPTION(std::runtime_error("eglSwapBuffers failure\n"));
-    }
+void mga::FBDevice::render_gl(SwappingGLContext const& context)
+{
+    context.swap_buffers();
+}
+
+void mga::FBDevice::render_gl_and_overlays(
+    SwappingGLContext const& context,
+    std::list<std::shared_ptr<Renderable>> const& renderables,
+    std::function<void(Renderable const&)> const& render_fn) 
+{
+    for(auto const& renderable : renderables)
+        render_fn(*renderable);
+
+    context.swap_buffers();
 }
 
 void mga::FBDevice::post(mg::Buffer const& buffer)
 
=== modified file 'src/platform/graphics/android/fb_device.h'
--- src/platform/graphics/android/fb_device.h	2014-02-28 13:51:43 +0000
+++ src/platform/graphics/android/fb_device.h	2014-03-17 15:02:33 +0000
@@ -37,9 +37,11 @@
 
     bool apply_orientation(MirOrientation orientation) const;
     void mode(MirPowerMode mode);
-    void prepare_gl();
-    void prepare_gl_and_overlays(std::list<std::shared_ptr<Renderable>> const& list); 
-    void gpu_render(EGLDisplay dpy, EGLSurface sur);
+    virtual void render_gl(SwappingGLContext const& context);
+    virtual void render_gl_and_overlays(
+        SwappingGLContext const& context,
+        std::list<std::shared_ptr<Renderable>> const& list,
+        std::function<void(Renderable const&)> const& render_fn);
     void post(Buffer const& buffer);
 
 private:
 
=== modified file 'src/platform/graphics/android/gl_context.cpp'
--- src/platform/graphics/android/gl_context.cpp	2014-01-22 10:03:11 +0000
+++ src/platform/graphics/android/gl_context.cpp	2014-03-17 15:02:33 +0000
@@ -23,6 +23,7 @@
 #include <algorithm>
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
+#include <sstream>
 
 namespace mg=mir::graphics;
 namespace mga=mir::graphics::android;
@@ -145,6 +146,17 @@
     eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 }
 
+void mga::GLContext::swap_buffers() const
+{
+    eglGetError();
+    if (eglSwapBuffers(egl_display, egl_surface) == EGL_FALSE)
+    {
+        std::stringstream sstream;
+        sstream << "eglSwapBuffers failure: EGL error code " << std::hex << eglGetError();
+        BOOST_THROW_EXCEPTION(std::runtime_error(sstream.str()));
+    }
+}
+
 mga::GLContext::~GLContext()
 {
     if (eglGetCurrentContext() == egl_context)
 
=== modified file 'src/platform/graphics/android/gl_context.h'
--- src/platform/graphics/android/gl_context.h	2014-01-22 10:03:11 +0000
+++ src/platform/graphics/android/gl_context.h	2014-03-17 15:02:33 +0000
@@ -36,7 +36,20 @@
 EGLSurface create_dummy_pbuffer_surface(EGLDisplay, EGLConfig);
 EGLSurface create_window_surface(EGLDisplay, EGLConfig, EGLNativeWindowType);
 
-class GLContext : public graphics::GLContext
+class SwappingGLContext
+{
+public:
+    virtual ~SwappingGLContext() = default;
+    virtual void swap_buffers() const = 0;
+
+protected:
+    SwappingGLContext() = default;
+    SwappingGLContext(SwappingGLContext const&) = delete;
+    SwappingGLContext& operator=(SwappingGLContext const&) = delete;
+};
+
+class GLContext : public SwappingGLContext,
+                  public graphics::GLContext
 {
 public:
     //For creating a gl context
@@ -49,19 +62,9 @@
     ~GLContext();
 
     void make_current() const override;
-    void swap_buffers();
+    void swap_buffers() const override;
     void release_current() const override;
 
-    /* TODO: (kdub) remove these two functions once HWC1.0 construction is sorted out. */
-    EGLDisplay display()
-    {
-        return egl_display;
-    }
-    EGLSurface surface()
-    {
-        return egl_surface;
-    }
-
 private:
     EGLDisplay const egl_display;
     bool const own_display;
 
=== modified file 'src/platform/graphics/android/hwc_device.cpp'
--- src/platform/graphics/android/hwc_device.cpp	2014-02-11 03:04:50 +0000
+++ src/platform/graphics/android/hwc_device.cpp	2014-03-17 15:02:33 +0000
@@ -17,83 +17,122 @@
  *   Kevin DuBois <[e-mail]>
  */
 
+#include "gl_context.h"
 #include "hwc_device.h"
 #include "hwc_layerlist.h"
 #include "hwc_vsync_coordinator.h"
 #include "framebuffer_bundle.h"
 #include "buffer.h"
-#include "mir/graphics/android/native_buffer.h"
 #include "mir/graphics/buffer.h"
 
-#include <EGL/eglext.h>
-#include <boost/throw_exception.hpp>
-#include <stdexcept>
-
 namespace mg = mir::graphics;
 namespace mga=mir::graphics::android;
 namespace geom = mir::geometry;
 
+namespace
+{
+static const size_t fbtarget_plus_skip_size = 2;
+static const size_t fbtarget_size = 1;
+}
+
+void mga::HwcDevice::setup_layer_types()
+{
+    auto it = hwc_list.additional_layers_begin();
+    auto const num_additional_layers = std::distance(it, hwc_list.end());
+    switch (num_additional_layers)
+    {
+        case fbtarget_plus_skip_size:
+            it->set_layer_type(mga::LayerType::skip);
+            ++it;
+        case fbtarget_size:
+            it->set_layer_type(mga::LayerType::framebuffer_target);
+        default:
+            break;
+    }
+}
+
+void mga::HwcDevice::set_list_framebuffer(mg::Buffer const& buffer)
+{
+    geom::Rectangle const disp_frame{{0,0}, {buffer.size()}};
+    for(auto it = hwc_list.additional_layers_begin(); it != hwc_list.end(); it++)
+    {
+        //TODO: the functions on mga::Layer should be consolidated
+        it->set_render_parameters(disp_frame, false);
+        it->set_buffer(buffer);
+        it->prepare_for_draw();
+    }
+}
+
 mga::HwcDevice::HwcDevice(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
+                          std::shared_ptr<HwcWrapper> const& hwc_wrapper,
                           std::shared_ptr<HWCVsyncCoordinator> const& coordinator,
                           std::shared_ptr<SyncFileOps> const& sync_ops)
     : HWCCommonDevice(hwc_device, coordinator),
+      hwc_list{{}, 2},
+      hwc_wrapper(hwc_wrapper), 
       sync_ops(sync_ops)
 {
-}
-
-void mga::HwcDevice::prepare_gl()
-{
-    auto rc = 0;
-    auto display_list = layer_list.native_list().lock();
-    if (display_list)
-    {
-        //note, although we only have a primary display right now,
-        //      set the external and virtual displays to null as some drivers check for that
-        hwc_display_contents_1_t* displays[num_displays] {display_list.get(), nullptr, nullptr};
-        rc = hwc_device->prepare(hwc_device.get(), 1, displays);
-    }
-
-    if ((rc != 0) || (!display_list))
-    {
-        BOOST_THROW_EXCEPTION(std::runtime_error("error during hwc prepare()"));
-    }
-}
-
-void mga::HwcDevice::prepare_gl_and_overlays(std::list<std::shared_ptr<Renderable>> const&)
-{
-    prepare_gl();
-}
-
-void mga::HwcDevice::gpu_render(EGLDisplay dpy, EGLSurface sur)
-{
-    if (eglSwapBuffers(dpy, sur) == EGL_FALSE)
-    {
-        BOOST_THROW_EXCEPTION(std::runtime_error("eglSwapBuffers failure\n"));
-    }
+    setup_layer_types();
+}
+
+void mga::HwcDevice::render_gl(SwappingGLContext const& context)
+{
+    hwc_list.update_list_and_check_if_changed({}, fbtarget_plus_skip_size);
+    setup_layer_types();
+
+    list_needs_commit = true;
+
+    hwc_wrapper->prepare(*hwc_list.native_list().lock());
+
+    context.swap_buffers();
+}
+
+void mga::HwcDevice::render_gl_and_overlays(
+    SwappingGLContext const& context,
+    std::list<std::shared_ptr<Renderable>> const& renderables,
+    std::function<void(Renderable const&)> const& render_fn)
+{
+    if (!(list_needs_commit = hwc_list.update_list_and_check_if_changed(renderables, fbtarget_size)))
+        return;
+    setup_layer_types();
+
+    hwc_wrapper->prepare(*hwc_list.native_list().lock());
+
+    //draw layers that the HWC did not accept for overlays here
+    bool needs_swapbuffers = false;
+    auto layers_it = hwc_list.begin();
+    for(auto const& renderable : renderables)
+    {
+        //prepare all layers for draw. 
+        layers_it->prepare_for_draw();
+
+        //trigger GL on the layers that are not overlays
+        if (layers_it->needs_gl_render())
+        {
+            render_fn(*renderable);
+            needs_swapbuffers = true;
+        }
+        layers_it++;
+    }
+
+    if (needs_swapbuffers)
+        context.swap_buffers();
 }
 
 void mga::HwcDevice::post(mg::Buffer const& buffer)
 {
+    if (!list_needs_commit)
+        return;
+
     auto lg = lock_unblanked();
-
-    layer_list.set_fb_target(buffer);
-
-    auto rc = 0;
-    auto display_list = layer_list.native_list().lock();
-    if (display_list)
-    {
-        hwc_display_contents_1_t* displays[num_displays] {display_list.get(), nullptr, nullptr};
-        rc = hwc_device->set(hwc_device.get(), 1, displays);
-
-        mga::SyncFence retire_fence(sync_ops, layer_list.retirement_fence());
-
-        int framebuffer_fence = layer_list.fb_target_fence();
-        auto native_buffer = buffer.native_buffer_handle();
-        native_buffer->update_fence(framebuffer_fence);
-    }
-
-    if ((rc != 0) || (!display_list))
-    {
-        BOOST_THROW_EXCEPTION(std::runtime_error("error during hwc set()"));
-    }
+    set_list_framebuffer(buffer);
+    hwc_wrapper->set(*hwc_list.native_list().lock());
+
+    for(auto& layer : hwc_list)
+    {
+        layer.update_fence_and_release_buffer();
+    }
+
+    mga::SyncFence retire_fence(sync_ops, hwc_list.retirement_fence());
+    list_needs_commit = false;
 }
 
=== modified file 'src/platform/graphics/android/hwc_device.h'
--- src/platform/graphics/android/hwc_device.h	2014-02-11 03:04:50 +0000
+++ src/platform/graphics/android/hwc_device.h	2014-03-17 15:02:33 +0000
@@ -36,23 +36,45 @@
 class HWCVsyncCoordinator;
 class SyncFileOps;
 
+class HwcWrapper
+{
+public:
+    virtual ~HwcWrapper() = default;
+
+    virtual void prepare(hwc_display_contents_1_t&) const = 0;
+    virtual void set(hwc_display_contents_1_t&) const = 0;
+
+protected:
+    HwcWrapper() = default;
+    HwcWrapper& operator=(HwcWrapper const&) = delete;
+    HwcWrapper(HwcWrapper const&) = delete;
+};
+
 class HwcDevice : public HWCCommonDevice
 {
 public:
+    //TODO: the first two constructor arguments are redundant. eliminate the 1st one when the 2nd
+    //      one can be used by the HWCCommonDevice 
     HwcDevice(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
+              std::shared_ptr<HwcWrapper> const& hwc_wrapper,
               std::shared_ptr<HWCVsyncCoordinator> const& coordinator,
               std::shared_ptr<SyncFileOps> const& sync_ops);
 
-    void prepare_gl();
-    void prepare_gl_and_overlays(std::list<std::shared_ptr<Renderable>> const& list); 
-    void gpu_render(EGLDisplay dpy, EGLSurface sur);
+    virtual void render_gl(SwappingGLContext const& context);
+    virtual void render_gl_and_overlays(
+        SwappingGLContext const& context,
+        std::list<std::shared_ptr<Renderable>> const& list,
+        std::function<void(Renderable const&)> const& render_fn);
     void post(Buffer const& buffer);
 
 private:
-    FBTargetLayerList layer_list;
+    LayerList hwc_list;
+    void set_list_framebuffer(Buffer const&);
+    void setup_layer_types();
 
+    std::shared_ptr<HwcWrapper> const hwc_wrapper;
     std::shared_ptr<SyncFileOps> const sync_ops;
-    static size_t const num_displays{3}; //primary, external, virtual
+    bool list_needs_commit{false};
 };
 
 }
 
=== modified file 'src/platform/graphics/android/hwc_fb_device.cpp'
--- src/platform/graphics/android/hwc_fb_device.cpp	2014-02-11 03:04:50 +0000
+++ src/platform/graphics/android/hwc_fb_device.cpp	2014-03-17 15:02:33 +0000
@@ -25,6 +25,7 @@
 #include "mir/graphics/android/native_buffer.h"
 
 #include <boost/throw_exception.hpp>
+#include <sstream>
 #include <stdexcept>
 
 namespace mg = mir::graphics;
@@ -35,39 +36,20 @@
                               std::shared_ptr<framebuffer_device_t> const& fb_device,
                               std::shared_ptr<HWCVsyncCoordinator> const& coordinator)
     : HWCCommonDevice(hwc_device, coordinator),
-      fb_device(fb_device)
-{
-}
-
-void mga::HwcFbDevice::prepare_gl()
-{
-    auto rc = 0;
-    auto display_list = layer_list.native_list().lock();
-    if (display_list)
-    {
-        hwc_display_contents_1_t* displays[num_displays] {display_list.get()};
-        rc = hwc_device->prepare(hwc_device.get(), num_displays, displays);
-    }
-
-    if ((rc != 0) || (!display_list))
-    {
-        BOOST_THROW_EXCEPTION(std::runtime_error("error during hwc prepare()"));
-    }
-}
-
-void mga::HwcFbDevice::prepare_gl_and_overlays(std::list<std::shared_ptr<Renderable>> const&)
-{
-    prepare_gl();
-}
-
-void mga::HwcFbDevice::gpu_render(EGLDisplay dpy, EGLSurface sur)
+      fb_device(fb_device),
+      layer_list{{},1}
+{
+    layer_list.additional_layers_begin()->set_layer_type(mga::LayerType::skip);
+}
+
+void mga::HwcFbDevice::gpu_render()
 {
     auto rc = 0; 
     auto display_list = layer_list.native_list().lock();
     if (display_list)
     {
-        display_list->dpy = dpy;
-        display_list->sur = sur;
+        display_list->dpy = eglGetCurrentDisplay();
+        display_list->sur = eglGetCurrentSurface(EGL_DRAW);
 
         //set() may affect EGL state by calling eglSwapBuffers.
         //HWC 1.0 is the only version of HWC that can do this.
@@ -77,8 +59,46 @@
 
     if ((rc != 0) || (!display_list))
     {
-        BOOST_THROW_EXCEPTION(std::runtime_error("error during hwc set()"));
-    }
+        std::stringstream ss;
+        ss << "error during hwc set(). rc = " << std::hex << rc;
+        BOOST_THROW_EXCEPTION(std::runtime_error(ss.str()));
+    }
+}
+
+void mga::HwcFbDevice::prepare()
+{
+    auto rc = 0;
+    auto display_list = layer_list.native_list().lock();
+    if (display_list)
+    {
+        hwc_display_contents_1_t* displays[num_displays] {display_list.get()};
+        rc = hwc_device->prepare(hwc_device.get(), num_displays, displays);
+    }
+
+    if ((rc != 0) || (!display_list))
+    {
+        std::stringstream ss;
+        ss << "error during hwc prepare(). rc = " << std::hex << rc;
+        BOOST_THROW_EXCEPTION(std::runtime_error(ss.str()));
+    }
+}
+
+void mga::HwcFbDevice::render_gl(SwappingGLContext const&)
+{
+    prepare();
+    gpu_render();
+}
+
+void mga::HwcFbDevice::render_gl_and_overlays(
+    SwappingGLContext const&,
+    std::list<std::shared_ptr<Renderable>> const& renderables,
+    std::function<void(Renderable const&)> const& render_fn)
+{
+    prepare();
+    //TODO: filter this list based on the results of the preparation
+    for(auto const& renderable : renderables)
+        render_fn(*renderable);
+    gpu_render();
 }
 
 void mga::HwcFbDevice::post(mg::Buffer const& buffer)
 
=== modified file 'src/platform/graphics/android/hwc_fb_device.h'
--- src/platform/graphics/android/hwc_fb_device.h	2014-02-11 03:04:50 +0000
+++ src/platform/graphics/android/hwc_fb_device.h	2014-03-17 15:02:33 +0000
@@ -38,12 +38,16 @@
                 std::shared_ptr<framebuffer_device_t> const& fb_device,
                 std::shared_ptr<HWCVsyncCoordinator> const& coordinator);
 
-    void prepare_gl();
-    void prepare_gl_and_overlays(std::list<std::shared_ptr<Renderable>> const& list); 
-    void gpu_render(EGLDisplay dpy, EGLSurface sur);
+    virtual void render_gl(SwappingGLContext const& context);
+    virtual void render_gl_and_overlays(
+        SwappingGLContext const& context,
+        std::list<std::shared_ptr<Renderable>> const& list,
+        std::function<void(Renderable const&)> const& render_fn);
     void post(Buffer const& buffer);
 
 private:
+    void prepare();
+    void gpu_render();
     std::shared_ptr<framebuffer_device_t> const fb_device;
     static int const num_displays{1};
     LayerList layer_list;
 
=== modified file 'src/platform/graphics/android/hwc_layerlist.cpp'
--- src/platform/graphics/android/hwc_layerlist.cpp	2014-03-04 04:19:26 +0000
+++ src/platform/graphics/android/hwc_layerlist.cpp	2014-03-17 15:02:33 +0000
@@ -51,101 +51,95 @@
 }
 }
 
-void mga::LayerListBase::update_representation(size_t needed_size)
-{
-    std::shared_ptr<hwc_display_contents_1_t> new_hwc_representation;
-    std::list<HWCLayer> new_layers;
-
-    if (hwc_representation->numHwLayers != needed_size)
-    {
-        new_hwc_representation = generate_hwc_list(needed_size);
-    }
-    else
-    {
-        new_hwc_representation = hwc_representation;
-    }
-
-    for (auto i = 0u; i < needed_size; i++)
-    {
-        new_layers.emplace_back(mga::HWCLayer(new_hwc_representation, i));
-    }
-
-    std::swap(new_layers, layers);
-    hwc_representation = new_hwc_representation;
-}
-
-std::weak_ptr<hwc_display_contents_1_t> mga::LayerListBase::native_list()
+bool mga::LayerList::update_list_and_check_if_changed(
+    std::list<std::shared_ptr<mg::Renderable>> const& renderlist,
+    size_t additional_layers)
+{
+    size_t needed_size = renderlist.size() + additional_layers; 
+
+    bool any_buffer_updated = false;
+    if ((!hwc_representation) || hwc_representation->numHwLayers != needed_size)
+    {
+        hwc_representation = generate_hwc_list(needed_size);
+    }
+
+    if (layers.size() == needed_size)
+    {
+        auto layers_it = layers.begin();
+        for(auto renderable : renderlist)
+        {
+            layers_it->set_render_parameters(
+                renderable->screen_position(), renderable->alpha_enabled());
+            layers_it->set_buffer(*renderable->buffer(1));// TODO: remove needing to know about frameno
+            any_buffer_updated |= layers_it->needs_hwc_commit(); 
+            layers_it++;
+        }
+    }
+    else
+    {
+        any_buffer_updated = true;
+        std::list<HWCLayer> new_layers;
+        auto i = 0u;
+        for(auto const& renderable : renderlist)
+        {
+            new_layers.emplace_back(
+                mga::HWCLayer(
+                    mga::LayerType::gl_rendered,
+                    renderable->screen_position(),
+                    renderable->alpha_enabled(),
+                    hwc_representation, i++));
+            new_layers.back().set_buffer(*renderable->buffer(1));// TODO: remove needing to know about frameno
+        }
+
+        for(; i < needed_size; i++)
+        {
+            new_layers.emplace_back(mga::HWCLayer(hwc_representation, i));
+        }
+        layers = std::move(new_layers);
+    }
+
+    if (additional_layers == 0)
+    {
+        first_additional_layer = layers.end();
+    }
+    else
+    {
+        first_additional_layer = layers.begin();
+        std::advance(first_additional_layer, renderlist.size());
+    }
+
+    return any_buffer_updated;
+}
+
+std::list<mga::HWCLayer>::iterator mga::LayerList::begin()
+{
+    return layers.begin(); 
+}
+
+std::list<mga::HWCLayer>::iterator mga::LayerList::additional_layers_begin()
+{
+    return first_additional_layer;
+}
+
+std::list<mga::HWCLayer>::iterator mga::LayerList::end()
+{
+    return layers.end(); 
+}
+
+std::weak_ptr<hwc_display_contents_1_t> mga::LayerList::native_list()
 {
     return hwc_representation;
 }
 
-mga::NativeFence mga::LayerListBase::retirement_fence()
+mga::NativeFence mga::LayerList::retirement_fence()
 {
     return hwc_representation->retireFenceFd;
 }
 
-mga::LayerListBase::LayerListBase(size_t initial_list_size)
-    : hwc_representation{generate_hwc_list(initial_list_size)}
-{
-    update_representation(initial_list_size);
-}
-
-mga::LayerList::LayerList()
-    : LayerListBase{1}
-{
-    layers.back().set_layer_type(mga::LayerType::skip);
-}
-
-mga::FBTargetLayerList::FBTargetLayerList()
-    : LayerListBase{2}
-{
-    layers.front().set_layer_type(mga::LayerType::skip);
-    layers.back().set_layer_type(mga::LayerType::framebuffer_target);
-}
-
-void mga::FBTargetLayerList::reset_composition_layers()
-{
-    update_representation(2);
-
-    layers.front().set_layer_type(mga::LayerType::skip);
-    layers.back().set_layer_type(mga::LayerType::framebuffer_target);
-
-    skip_layers_present = true;
-}
-
-void mga::FBTargetLayerList::set_composition_layers(std::list<std::shared_ptr<graphics::Renderable>> const& list)
-{
-    auto const needed_size = list.size() + 1;
-    update_representation(needed_size);
-
-    auto layers_it = layers.begin();
-    for(auto const& renderable : list)
-    {
-        layers_it->set_layer_type(mga::LayerType::gl_rendered);
-        layers_it->set_render_parameters(renderable->screen_position(), renderable->alpha_enabled());
-        layers_it->set_buffer(*renderable->buffer());
-        layers_it++;
-    }
-
-    layers_it->set_layer_type(mga::LayerType::framebuffer_target);
-    skip_layers_present = false;
-}
-
-
-void mga::FBTargetLayerList::set_fb_target(mg::Buffer const& buffer)
-{
-    geom::Rectangle const disp_frame{{0,0}, {buffer.size()}};
-    if (skip_layers_present)
-    {
-        layers.front().set_render_parameters(disp_frame, false);
-        layers.front().set_buffer(buffer);
-    }
-
-    layers.back().set_render_parameters(disp_frame, false);
-    layers.back().set_buffer(buffer);
-}
-
-mga::NativeFence mga::FBTargetLayerList::fb_target_fence()
-{
-   return layers.back().release_fence();
-}
+mga::LayerList::LayerList(
+    std::list<std::shared_ptr<mg::Renderable>> const& renderlist,
+    size_t additional_layers)
+{
+    update_list_and_check_if_changed(renderlist, additional_layers);
+}
+
 
=== modified file 'src/platform/graphics/android/hwc_layerlist.h'
--- src/platform/graphics/android/hwc_layerlist.h	2014-02-11 03:04:50 +0000
+++ src/platform/graphics/android/hwc_layerlist.h	2014-03-17 15:02:33 +0000
@@ -39,42 +39,33 @@
 namespace android
 {
 
-class LayerListBase
+/* this is a partitioned list. renderlist makes up the first renderlist.size() elements
+   of the list, and there are additional_layers added to the end. 
+   std::distance(begin(), additional_layers_begin()) == renderlist.size() 
+   std::distance(additional_layers_begin(), end()) == additional_layers
+   std::distance(begin(), end()) == renderlist.size() + additional_layers 
+*/ 
+class LayerList
 {
 public:
+    LayerList(std::list<std::shared_ptr<Renderable>> const& renderlist, size_t additional_layers);
+    bool update_list_and_check_if_changed(
+        std::list<std::shared_ptr<Renderable>> const& renderlist,
+        size_t additional_layers);
+
+    std::list<HWCLayer>::iterator begin();
+    std::list<HWCLayer>::iterator additional_layers_begin();
+    std::list<HWCLayer>::iterator end();
+
     std::weak_ptr<hwc_display_contents_1_t> native_list();
     NativeFence retirement_fence();
-
-protected:
-    LayerListBase(size_t initial_list_size);
-
-    void update_representation(size_t needed_size); 
+private:
+    LayerList& operator=(LayerList const&) = delete;
+    LayerList(LayerList const&) = delete;
+
     std::list<HWCLayer> layers;
-
-private:
-    LayerListBase& operator=(LayerListBase const&) = delete;
-    LayerListBase(LayerListBase const&) = delete;
-
     std::shared_ptr<hwc_display_contents_1_t> hwc_representation;
-};
-
-class LayerList : public LayerListBase
-{
-public:
-    LayerList();
-};
-
-class FBTargetLayerList : public LayerListBase
-{
-public:
-    FBTargetLayerList();
-    void set_composition_layers(std::list<std::shared_ptr<graphics::Renderable>> const& list);
-    void reset_composition_layers(); 
-    NativeFence fb_target_fence();
-    void set_fb_target(Buffer const&);
-
-private:
-    bool skip_layers_present{true};
+    std::list<HWCLayer>::iterator first_additional_layer;
 };
 
 }
 
=== modified file 'src/platform/graphics/android/hwc_layers.cpp'
--- src/platform/graphics/android/hwc_layers.cpp	2014-02-12 03:14:55 +0000
+++ src/platform/graphics/android/hwc_layers.cpp	2014-03-17 15:02:33 +0000
@@ -47,7 +47,8 @@
 
 mga::HWCLayer::HWCLayer(std::shared_ptr<hwc_display_contents_1_t> list, size_t layer_index)
     : hwc_layer(&list->hwLayers[layer_index]),
-      hwc_list(list)
+      hwc_list(list),
+      associated_buffer(nullptr) //todo: take this as a constructor param 
 {
     memset(hwc_layer, 0, sizeof(hwc_layer_1_t));
     memset(&visible_rect, 0, sizeof(hwc_rect_t));
@@ -79,9 +80,15 @@
     return ((hwc_layer->compositionType == HWC_FRAMEBUFFER) || (hwc_layer->flags == HWC_SKIP_LAYER));
 }
 
-mga::NativeFence mga::HWCLayer::release_fence() const
+void mga::HWCLayer::update_fence_and_release_buffer()
 {
-    return hwc_layer->releaseFenceFd;
+    if (hwc_layer->compositionType != HWC_FRAMEBUFFER)
+    { 
+        associated_buffer->update_fence(hwc_layer->releaseFenceFd);
+        hwc_layer->releaseFenceFd = -1;
+        hwc_layer->acquireFenceFd = -1;
+        associated_buffer.reset();
+    }
 }
 
 void mga::HWCLayer::set_layer_type(LayerType type)
@@ -129,16 +136,39 @@
 
 void mga::HWCLayer::set_buffer(Buffer const& buffer)
 {
-    auto size = buffer.size();
-    auto native_buffer = buffer.native_buffer_handle();
-    hwc_layer->handle = native_buffer->handle();
-    if (!needs_gl_render())
-        hwc_layer->acquireFenceFd = native_buffer->copy_fence();
-    hwc_layer->releaseFenceFd = -1;
+    associated_buffer.reset();
+    associated_buffer = buffer.native_buffer_handle();
+    updated = (hwc_layer->handle != associated_buffer->handle());
+
+    hwc_layer->handle = associated_buffer->handle();
     hwc_layer->sourceCrop = 
     {
         0, 0,
-        size.width.as_int(),
-        size.height.as_int()
+        associated_buffer->anwb()->width,
+        associated_buffer->anwb()->height
     };
 }
+
+void mga::HWCLayer::prepare_for_draw()
+{
+    //we shouldn't be copying the FD unless the HWC has marked this as a buffer its interested in.
+    //we disregard fences that haven't changed, as the hwc will still own the buffer
+    if (updated && (((hwc_layer->compositionType == HWC_OVERLAY) ||
+        (hwc_layer->compositionType == HWC_FRAMEBUFFER_TARGET))))
+    {
+        hwc_layer->acquireFenceFd = associated_buffer->copy_fence();
+    }
+    //the HWC is not interested in this buffer. we can release the buffer.
+    else if (hwc_layer->compositionType == HWC_FRAMEBUFFER)
+    {
+        hwc_layer->acquireFenceFd = -1;
+        associated_buffer.reset();
+    }
+
+    hwc_layer->releaseFenceFd = -1;
+}
+
+bool mga::HWCLayer::needs_hwc_commit() const
+{
+    return (updated || needs_gl_render());
+}
 
=== modified file 'src/platform/graphics/android/hwc_layers.h'
--- src/platform/graphics/android/hwc_layers.h	2014-02-12 03:14:55 +0000
+++ src/platform/graphics/android/hwc_layers.h	2014-03-17 15:02:33 +0000
@@ -35,10 +35,10 @@
 
 class Renderable;
 class Buffer;
+class NativeBuffer;
 
 namespace android
 {
-
 enum LayerType
 {
     gl_rendered,
@@ -64,15 +64,18 @@
     
     void set_layer_type(LayerType type);
     void set_render_parameters(geometry::Rectangle screen_position, bool alpha_enabled);
-    void set_buffer(Buffer const&);
+    void set_buffer(Buffer const& buffer);
 
-    NativeFence release_fence() const;
+    void update_fence_and_release_buffer();
     bool needs_gl_render() const;
-
+    bool needs_hwc_commit() const;
+    void prepare_for_draw();
 private:
     hwc_layer_1_t* hwc_layer;
     std::shared_ptr<hwc_display_contents_1_t> hwc_list;
     hwc_rect_t visible_rect;
+    std::shared_ptr<NativeBuffer> associated_buffer;
+    bool updated{false};
 };
 }
 }
 
=== added file 'src/platform/graphics/android/real_hwc_wrapper.cpp'
--- src/platform/graphics/android/real_hwc_wrapper.cpp	1970-01-01 00:00:00 +0000
+++ src/platform/graphics/android/real_hwc_wrapper.cpp	2014-03-17 15:02:33 +0000
@@ -0,0 +1,53 @@
+/*
+ * 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]>
+ */
+
+#include "real_hwc_wrapper.h"
+#include <boost/throw_exception.hpp>
+#include <stdexcept>
+#include <sstream>
+
+namespace mga=mir::graphics::android;
+
+mga::RealHwcWrapper::RealHwcWrapper(std::shared_ptr<hwc_composer_device_1> const& hwc_device)
+    : hwc_device(hwc_device)
+{
+}
+
+void mga::RealHwcWrapper::prepare(hwc_display_contents_1_t& display_list) const
+{
+    //note, although we only have a primary display right now,
+    //      set the external and virtual displays to null as some drivers check for that
+    hwc_display_contents_1_t* displays[num_displays] {&display_list, nullptr, nullptr};
+    if (auto rc = hwc_device->prepare(hwc_device.get(), 1, displays))
+    {
+        std::stringstream ss;
+        ss << "error during hwc prepare(). rc = " << std::hex << rc;
+        BOOST_THROW_EXCEPTION(std::runtime_error(ss.str()));
+    }
+}
+
+void mga::RealHwcWrapper::set(hwc_display_contents_1_t& display_list) const
+{
+    hwc_display_contents_1_t* displays[num_displays] {&display_list, nullptr, nullptr};
+    if (auto rc = hwc_device->set(hwc_device.get(), 1, displays))
+    {
+        std::stringstream ss;
+        ss << "error during hwc prepare(). rc = " << std::hex << rc;
+        BOOST_THROW_EXCEPTION(std::runtime_error(ss.str()));
+    }
+}
 
=== added file 'src/platform/graphics/android/real_hwc_wrapper.h'
--- src/platform/graphics/android/real_hwc_wrapper.h	1970-01-01 00:00:00 +0000
+++ src/platform/graphics/android/real_hwc_wrapper.h	2014-03-17 15:02:33 +0000
@@ -0,0 +1,48 @@
+/*
+ * 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_GRAPHICS_ANDROID_REAL_HWC_WRAPPER_H_
+#define MIR_GRAPHICS_ANDROID_REAL_HWC_WRAPPER_H_
+
+#include "hwc_device.h"
+#include <memory>
+#include <hardware/hwcomposer.h>
+
+namespace mir
+{
+namespace graphics
+{
+namespace android
+{
+
+class RealHwcWrapper : public HwcWrapper
+{
+public:
+    RealHwcWrapper(std::shared_ptr<hwc_composer_device_1> const& hwc_device);
+
+    void prepare(hwc_display_contents_1_t&) const override;
+    void set(hwc_display_contents_1_t&) const override;
+private:
+    static size_t const num_displays{3}; //primary, external, virtual
+    std::shared_ptr<hwc_composer_device_1> const hwc_device;
+};
+
+}
+}
+}
+#endif /* MIR_GRAPHICS_ANDROID_REAL_HWC_WRAPPER_H_ */
 
=== modified file 'src/platform/graphics/android/resource_factory.cpp'
--- src/platform/graphics/android/resource_factory.cpp	2014-02-10 09:07:48 +0000
+++ src/platform/graphics/android/resource_factory.cpp	2014-03-17 15:02:33 +0000
@@ -30,6 +30,7 @@
 #include "hwc_layerlist.h"
 #include "hwc_vsync.h"
 #include "android_display.h"
+#include "real_hwc_wrapper.h"
 
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
@@ -93,7 +94,8 @@
 {
     auto syncer = std::make_shared<mga::HWCVsync>();
     auto file_ops = std::make_shared<mga::RealSyncFileOps>();
-    return std::make_shared<mga::HwcDevice>(hwc_native_device, syncer, file_ops);
+    auto wrapper = std::make_shared<mga::RealHwcWrapper>(hwc_native_device); 
+    return std::make_shared<mga::HwcDevice>(hwc_native_device, wrapper, syncer, file_ops);
 }
 
 std::shared_ptr<mga::DisplayDevice> mga::ResourceFactory::create_hwc_fb_device(
 
=== modified file 'src/platform/graphics/display_configuration.cpp'
--- src/platform/graphics/display_configuration.cpp	2014-03-05 02:30:30 +0000
+++ src/platform/graphics/display_configuration.cpp	2014-03-17 15:02:33 +0000
@@ -19,6 +19,7 @@
 #include "mir/graphics/display_configuration.h"
 
 #include <ostream>
+#include <algorithm>
 
 namespace mg = mir::graphics;
 
@@ -196,3 +197,52 @@
         return {top_left, {size.height.as_int(), size.width.as_int()}};
     }
 }
+
+bool mg::DisplayConfigurationOutput::valid() const
+{
+    if (!connected)
+        return !used;
+
+    auto const& f = std::find(pixel_formats.begin(), pixel_formats.end(),
+                              current_format);
+    if (f == pixel_formats.end())
+        return false;
+
+    auto nmodes = modes.size();
+    if (preferred_mode_index >= nmodes || current_mode_index >= nmodes)
+        return false;
+
+    return true;
+}
+
+bool mg::DisplayConfiguration::valid() const
+{
+    bool all_valid = true;
+
+    for_each_output([&all_valid](DisplayConfigurationOutput const& out)
+        {
+            if (!out.valid())
+                all_valid = false;
+        });
+
+    return all_valid;
+}
+
+mg::UserDisplayConfigurationOutput::UserDisplayConfigurationOutput(
+    DisplayConfigurationOutput& master) :
+        id(master.id),
+        card_id(master.card_id),
+        type(master.type),
+        pixel_formats(master.pixel_formats),
+        modes(master.modes),
+        preferred_mode_index(master.preferred_mode_index),
+        physical_size_mm(master.physical_size_mm),
+        connected(master.connected),
+        used(master.used),
+        top_left(master.top_left),
+        current_mode_index(master.current_mode_index),
+        current_format(master.current_format),
+        power_mode(master.power_mode),
+        orientation(master.orientation)
+{
+}
 
=== modified file 'src/platform/graphics/mesa/CMakeLists.txt'
--- src/platform/graphics/mesa/CMakeLists.txt	2014-02-28 13:51:43 +0000
+++ src/platform/graphics/mesa/CMakeLists.txt	2014-03-17 15:02:33 +0000
@@ -32,7 +32,6 @@
   internal_native_surface.cpp
   internal_client.cpp
   drm_close_threadsafe.cpp
-  overlapping_output_grouping.cpp
   native_platform.cpp
   anonymous_shm_file.cpp
   shm_buffer.cpp
@@ -54,6 +53,8 @@
   ${GLESv2_LDFLAGS} ${GLESv2_LIBRARIES}
 )
 
+install(TARGETS mirplatformgraphicsmesa LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/mir/platformgraphics/mesa)
+
 if (MIR_TEST_PLATFORM STREQUAL "mesa")
   add_custom_command(TARGET mirplatformgraphicsmesa
     POST_BUILD
@@ -61,6 +62,11 @@
     COMMAND ${CMAKE_COMMAND} -E create_symlink mesa/$<TARGET_FILE_NAME:mirplatformgraphicsmesa> libmirplatformgraphics.so
     WORKING_DIRECTORY ${LIBRARY_OUTPUT_PATH}
   )
+
+  install(CODE
+    "execute_process(
+       COMMAND ln -sf mir/platformgraphics/mesa/libmirplatformgraphics.so
+       WORKING_DIRECTORY \$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}
+     )"
+  )
 endif()
-
-install(TARGETS mirplatformgraphicsmesa LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/mir/platformgraphics/mesa)
 
=== modified file 'src/platform/graphics/mesa/cursor.cpp'
--- src/platform/graphics/mesa/cursor.cpp	2014-01-22 10:03:11 +0000
+++ src/platform/graphics/mesa/cursor.cpp	2014-03-17 15:02:33 +0000
@@ -28,15 +28,32 @@
 #include <stdexcept>
 #include <vector>
 
+namespace mgm = mir::graphics::mesa;
+namespace geom = mir::geometry;
+
 namespace
 {
 #include "black_arrow.c"
 int const width = black_arrow.width;
 int const height = black_arrow.height;
-}
 
-namespace mgm = mir::graphics::mesa;
-namespace geom = mir::geometry;
+// Transforms a relative position within the display bounds described by \a rect which is rotated with \a orientation
+geom::Displacement transform(geom::Rectangle const& rect, geom::Displacement const& vector, MirOrientation orientation)
+{
+    switch(orientation)
+    {
+    case mir_orientation_left:
+        return {vector.dy.as_int(), rect.size.width.as_int() -vector.dx.as_int()};
+    case mir_orientation_inverted:
+        return {rect.size.width.as_int() -vector.dx.as_int(), rect.size.height.as_int() - vector.dy.as_int()};
+    case mir_orientation_right:
+        return {rect.size.height.as_int() -vector.dy.as_int(), vector.dx.as_int()};
+    default:
+    case mir_orientation_normal:
+        return vector;
+    }
+}
+}
 
 mgm::Cursor::GBMBOWrapper::GBMBOWrapper(gbm_device* gbm) :
     buffer(gbm_bo_create(
@@ -103,7 +120,7 @@
 }
 
 void mgm::Cursor::for_each_used_output(
-    std::function<void(KMSOutput&, geom::Rectangle const&)> const& f)
+    std::function<void(KMSOutput&, geom::Rectangle const&, MirOrientation orientation)> const& f)
 {
     current_configuration->with_current_configuration_do(
         [this,&f](KMSDisplayConfiguration const& kms_conf)
@@ -115,13 +132,7 @@
                     uint32_t const connector_id = kms_conf.get_kms_connector_id(conf_output.id);
                     auto output = output_container.get_kms_output_for(connector_id);
 
-                    // TODO: Cursor rotation support (conf_output.extents())
-                    geom::Rectangle output_rect
-                    {
-                        conf_output.top_left,
-                        conf_output.modes[conf_output.current_mode_index].size
-                    };
-                    f(*output, output_rect);
+                    f(*output, conf_output.extents(), conf_output.orientation);
                 }
             });
         });
@@ -131,15 +142,15 @@
     geometry::Point position,
     ForceCursorState force_state)
 {
-    for_each_used_output([&](KMSOutput& output, geom::Rectangle const& output_rect)
+    for_each_used_output([&](KMSOutput& output, geom::Rectangle const& output_rect, MirOrientation orientation)
     {
         if (output_rect.contains(position))
         {
-            auto dp = position - output_rect.top_left;
+            auto dp = transform(output_rect, position - output_rect.top_left, orientation);
             output.move_cursor({dp.dx.as_int(), dp.dy.as_int()});
-            if (force_state || !output.has_cursor())
+            if (force_state || !output.has_cursor()) // TODO - or if orientation had changed - then set buffer..
             {
-                output.set_cursor(buffer);
+                output.set_cursor(buffer);// TODO - select rotated buffer image
             }
         }
         else
 
=== modified file 'src/platform/graphics/mesa/cursor.h'
--- src/platform/graphics/mesa/cursor.h	2014-01-22 10:03:11 +0000
+++ src/platform/graphics/mesa/cursor.h	2014-03-17 15:02:33 +0000
@@ -21,6 +21,7 @@
 #define MIR_GRAPHICS_MESA_CURSOR_H_
 
 #include "mir/graphics/cursor.h"
+#include "mir_toolkit/common.h"
 
 #include <gbm.h>
 #include <memory>
@@ -73,7 +74,7 @@
 
 private:
     enum ForceCursorState { UpdateState, ForceState };
-    void for_each_used_output(std::function<void(KMSOutput&, geometry::Rectangle const&)> const& f);
+    void for_each_used_output(std::function<void(KMSOutput&, geometry::Rectangle const&, MirOrientation orientation)> const& f);
     void place_cursor_at(geometry::Point position, ForceCursorState force_state);
 
     KMSOutputContainer& output_container;
 
=== modified file 'src/platform/graphics/mesa/display.cpp'
--- src/platform/graphics/mesa/display.cpp	2014-03-05 02:30:30 +0000
+++ src/platform/graphics/mesa/display.cpp	2014-03-17 15:02:33 +0000
@@ -24,7 +24,7 @@
 #include "kms_output.h"
 #include "kms_page_flipper.h"
 #include "virtual_terminal.h"
-#include "overlapping_output_grouping.h"
+#include "mir/graphics/overlapping_output_grouping.h"
 
 #include "mir/graphics/display_report.h"
 #include "mir/graphics/gl_context.h"
@@ -128,6 +128,12 @@
 
 void mgm::Display::configure(mg::DisplayConfiguration const& conf)
 {
+    if (!conf.valid())
+    {
+        BOOST_THROW_EXCEPTION(
+            std::logic_error("Invalid or inconsistent display configuration"));
+    }
+
     {
         std::lock_guard<std::mutex> lg{configuration_mutex};
 
 
=== modified file 'src/platform/graphics/mesa/linux_virtual_terminal.cpp'
--- src/platform/graphics/mesa/linux_virtual_terminal.cpp	2014-01-22 10:03:11 +0000
+++ src/platform/graphics/mesa/linux_virtual_terminal.cpp	2014-03-17 15:02:33 +0000
@@ -36,11 +36,12 @@
 
 namespace mgm = mir::graphics::mesa;
 
-mgm::LinuxVirtualTerminal::LinuxVirtualTerminal(
-    std::shared_ptr<VTFileOperations> const& fops,
+mgm::LinuxVirtualTerminal::LinuxVirtualTerminal(std::shared_ptr<VTFileOperations> const& fops,
+    std::unique_ptr<PosixProcessOperations> pops,
     int vt_number,
     std::shared_ptr<DisplayReport> const& report)
     : fops{fops},
+      pops{std::move(pops)},
       report{report},
       vt_fd{fops, open_vt(vt_number)},
       prev_kd_mode{0},
@@ -233,9 +234,9 @@
     {
         // we should only try to create a new session in order to become the session
         // and group leader if we are not already the session leader
-        if (getpid() != getsid(0))
+        if (pops->getpid() != pops->getsid(0))
         {
-            if (getpid() == getpgid(0) && setpgid(0, getpgid(getppid())) < 0)
+            if (pops->getpid() == pops->getpgid(0) && pops->setpgid(0, pops->getpgid(pops->getppid())) < 0)
             {
                 BOOST_THROW_EXCEPTION(
                     boost::enable_error_info(
@@ -244,7 +245,7 @@
             }
 
             /* become process group leader */
-            if (setsid() < 0)
+            if (pops->setsid() < 0)
             {
                 BOOST_THROW_EXCEPTION(
                     boost::enable_error_info(
 
=== modified file 'src/platform/graphics/mesa/linux_virtual_terminal.h'
--- src/platform/graphics/mesa/linux_virtual_terminal.h	2014-01-22 10:03:11 +0000
+++ src/platform/graphics/mesa/linux_virtual_terminal.h	2014-03-17 15:02:33 +0000
@@ -55,10 +55,30 @@
     VTFileOperations& operator=(VTFileOperations const&) = delete;
 };
 
+class PosixProcessOperations
+{
+public:
+    virtual ~PosixProcessOperations() = default;
+
+    virtual pid_t getpid() const = 0;
+    virtual pid_t getppid() const = 0;
+    virtual pid_t getpgid(pid_t process) const = 0;
+    virtual pid_t getsid(pid_t process) const = 0;
+
+    virtual int setpgid(pid_t process, pid_t group) = 0;
+    virtual pid_t setsid() = 0;
+
+protected:
+    PosixProcessOperations() = default;
+    PosixProcessOperations(PosixProcessOperations const&) = delete;
+    PosixProcessOperations& operator=(PosixProcessOperations const&) = delete;
+};
+
 class LinuxVirtualTerminal : public VirtualTerminal
 {
 public:
     LinuxVirtualTerminal(std::shared_ptr<VTFileOperations> const& fops,
+                         std::unique_ptr<PosixProcessOperations> pops,
                          int vt_number,
                          std::shared_ptr<DisplayReport> const& report);
     ~LinuxVirtualTerminal() noexcept(true);
@@ -89,6 +109,7 @@
 
 
     std::shared_ptr<VTFileOperations> const fops;
+    std::unique_ptr<PosixProcessOperations> const pops;
     std::shared_ptr<DisplayReport> const report;
     FDWrapper const vt_fd;
     int prev_kd_mode;
 
=== modified file 'src/platform/graphics/mesa/native_platform.cpp'
--- src/platform/graphics/mesa/native_platform.cpp	2014-03-04 04:19:26 +0000
+++ src/platform/graphics/mesa/native_platform.cpp	2014-03-17 15:02:33 +0000
@@ -25,8 +25,13 @@
 #include "mir/graphics/platform_ipc_package.h"
 #include "mir/graphics/nested_context.h"
 
+#include "internal_client.h"
+#include "internal_native_display.h"
+
 #include <boost/exception/errinfo_errno.hpp>
 #include <boost/throw_exception.hpp>
+
+#include <mutex>
 #include <stdexcept>
 
 namespace mg = mir::graphics;
@@ -42,6 +47,11 @@
     nested_context->drm_set_gbm_device(gbm.device);
 }
 
+mgm::NativePlatform::~NativePlatform()
+{
+    finish_internal_native_display();
+}
+
 std::shared_ptr<mg::GraphicBufferAllocator> mgm::NativePlatform::create_buffer_allocator(
         std::shared_ptr<mg::BufferInitializer> const& buffer_initializer)
 {
@@ -82,7 +92,8 @@
 
 std::shared_ptr<mg::InternalClient> mgm::NativePlatform::create_internal_client()
 {
-    BOOST_THROW_EXCEPTION(std::runtime_error("MesaNativePlatform::create_internal_client is not implemented yet!"));
+    auto nd = ensure_internal_native_display(get_ipc_package());
+    return std::make_shared<mgm::InternalClient>(nd);
 }
 
 void mgm::NativePlatform::fill_ipc_package(BufferIPCPacker* packer, Buffer const* buffer) const
@@ -98,9 +109,45 @@
     }
 
     packer->pack_stride(buffer->stride());
+    packer->pack_flags(native_handle->flags);
+    packer->pack_size(buffer->size());
 }
 
 extern "C" std::shared_ptr<mg::NativePlatform> create_native_platform(std::shared_ptr<mg::DisplayReport> const& /*report*/)
 {
     return std::make_shared<mgm::NativePlatform>();
 }
+
+namespace
+{
+std::shared_ptr<mgm::InternalNativeDisplay> native_display = nullptr;
+std::mutex native_display_guard;
+}
+
+bool mgm::NativePlatform::internal_native_display_in_use()
+{
+    std::unique_lock<std::mutex> lg(native_display_guard);
+    return native_display != nullptr;
+}
+
+std::shared_ptr<mgm::InternalNativeDisplay> mgm::NativePlatform::internal_native_display()
+{
+    std::unique_lock<std::mutex> lg(native_display_guard);
+    return native_display;
+}
+
+std::shared_ptr<mgm::InternalNativeDisplay> mgm::NativePlatform::ensure_internal_native_display(
+    std::shared_ptr<mg::PlatformIPCPackage> const& package)
+{
+    std::unique_lock<std::mutex> lg(native_display_guard);
+    if (!native_display)
+        native_display = std::make_shared<mgm::InternalNativeDisplay>(package);
+    return native_display;
+}
+
+void mgm::NativePlatform::finish_internal_native_display()
+{
+    std::unique_lock<std::mutex> lg(native_display_guard);
+    native_display.reset();
+}
+
 
=== modified file 'src/platform/graphics/mesa/native_platform.h'
--- src/platform/graphics/mesa/native_platform.h	2014-01-22 10:03:11 +0000
+++ src/platform/graphics/mesa/native_platform.h	2014-03-17 15:02:33 +0000
@@ -30,20 +30,30 @@
 {
 namespace mesa
 {
+class InternalNativeDisplay; 
+
 class NativePlatform : public graphics::NativePlatform
 {
 public:
+    virtual ~NativePlatform();
+
     void initialize(std::shared_ptr<NestedContext> const& nested_context);
     std::shared_ptr<GraphicBufferAllocator> create_buffer_allocator(
         std::shared_ptr<BufferInitializer> const& buffer_initializer) override;
     std::shared_ptr<PlatformIPCPackage> get_ipc_package() override;
     std::shared_ptr<InternalClient> create_internal_client() override;
     void fill_ipc_package(BufferIPCPacker* packer, Buffer const* buffer) const override;
+    
+    static std::shared_ptr<InternalNativeDisplay> internal_native_display();
+    static bool internal_native_display_in_use();
 
 private:
     int drm_fd;
     std::shared_ptr<NestedContext> nested_context;
     helpers::GBMHelper gbm;
+
+    static std::shared_ptr<InternalNativeDisplay> ensure_internal_native_display(std::shared_ptr<PlatformIPCPackage> const& package);
+    static void finish_internal_native_display();
 };
 }
 }
 
=== modified file 'src/platform/graphics/mesa/platform.cpp'
--- src/platform/graphics/mesa/platform.cpp	2014-02-12 03:14:55 +0000
+++ src/platform/graphics/mesa/platform.cpp	2014-03-17 15:02:33 +0000
@@ -17,6 +17,7 @@
  */
 
 #include "platform.h"
+#include "native_platform.h"
 #include "buffer_allocator.h"
 #include "display.h"
 #include "internal_client.h"
@@ -89,6 +90,34 @@
     }
 };
 
+struct RealPosixProcessOperations : public mgm::PosixProcessOperations
+{
+    pid_t getpid() const override
+    {
+        return ::getpid();
+    }
+    pid_t getppid() const override
+    {
+        return ::getppid();
+    }
+    pid_t getpgid(pid_t process) const override
+    {
+        return ::getpgid(process);
+    }
+    pid_t getsid(pid_t process) const override
+    {
+        return ::getsid(process);
+    }
+    int setpgid(pid_t process, pid_t group) override
+    {
+        return ::setpgid(process, group);
+    }
+    pid_t setsid() override
+    {
+        return ::setsid();
+    }
+};
+
 }
 
 std::shared_ptr<mgm::InternalNativeDisplay> mgm::Platform::internal_native_display;
@@ -169,8 +198,10 @@
 extern "C" std::shared_ptr<mg::Platform> mg::create_platform(std::shared_ptr<mo::Option> const& options, std::shared_ptr<DisplayReport> const& report)
 {
     auto real_fops = std::make_shared<RealVTFileOperations>();
+    auto real_pops = std::unique_ptr<RealPosixProcessOperations>(new RealPosixProcessOperations{});
     auto vt = std::make_shared<mgm::LinuxVirtualTerminal>(
         real_fops,
+        std::move(real_pops),
         options->get<int>("vt"), // TODO This option is mesa specific
         report);
 
@@ -179,6 +210,12 @@
 
 extern "C" int mir_server_mesa_egl_native_display_is_valid(MirMesaEGLNativeDisplay* display)
 {
-    return ((mgm::Platform::internal_display_clients_present) &&
-            (display == mgm::Platform::internal_native_display.get()));
+    bool nested_internal_display_in_use = mgm::NativePlatform::internal_native_display_in_use();
+    bool host_internal_display_in_use = mgm::Platform::internal_display_clients_present;
+
+    if (host_internal_display_in_use)
+        return (display == mgm::Platform::internal_native_display.get());
+    else if (nested_internal_display_in_use)
+        return (display == mgm::NativePlatform::internal_native_display().get());
+    return 0;
 }
 
=== modified file 'src/platform/graphics/mesa/real_kms_display_configuration.cpp'
--- src/platform/graphics/mesa/real_kms_display_configuration.cpp	2014-03-05 02:30:30 +0000
+++ src/platform/graphics/mesa/real_kms_display_configuration.cpp	2014-03-17 15:02:33 +0000
@@ -66,11 +66,6 @@
     return static_cast<mg::DisplayConfigurationOutputType>(connector_type);
 }
 
-bool format_available_in_pixel_formats(MirPixelFormat format, mg::DisplayConfigurationOutput const& output)
-{
-    return output.pixel_formats.end() != find(output.pixel_formats.begin(), output.pixel_formats.end(), format);
-}
-
 }
 
 mgm::RealKMSDisplayConfiguration::RealKMSDisplayConfiguration(int drm_fd)
@@ -112,36 +107,13 @@
         f(output);
 }
 
-void mgm::RealKMSDisplayConfiguration::configure_output(
-    DisplayConfigurationOutputId id, bool used,
-    geometry::Point top_left, size_t mode_index,
-    MirPixelFormat format, MirPowerMode power_mode, MirOrientation orientation)
+void mgm::RealKMSDisplayConfiguration::for_each_output(
+    std::function<void(UserDisplayConfigurationOutput&)> f)
 {
-    auto iter = find_output_with_id(id);
-
-    if (iter != outputs.end())
-    {
-        auto& output = *iter;
-
-        if (used && mode_index >= output.modes.size())
-            BOOST_THROW_EXCEPTION(std::runtime_error("Invalid mode_index for used output"));
-
-        if (used && !valid_pixel_format(format))
-            BOOST_THROW_EXCEPTION(std::runtime_error("Invalid format for used output"));
-
-        if (used && !format_available_in_pixel_formats(format, output))
-            BOOST_THROW_EXCEPTION(std::runtime_error("Format not available for used output"));
-
-        output.used = used;
-        output.top_left = top_left;
-        output.current_mode_index = mode_index;
-        output.current_format = format;
-        output.power_mode = power_mode;
-        output.orientation = orientation;
-    }
-    else
-    {
-        BOOST_THROW_EXCEPTION(std::runtime_error("Trying to configure invalid output"));
+    for (auto& output : outputs)
+    {
+        UserDisplayConfigurationOutput user(output);
+        f(user);
     }
 }
 
 
=== modified file 'src/platform/graphics/mesa/real_kms_display_configuration.h'
--- src/platform/graphics/mesa/real_kms_display_configuration.h	2014-03-05 02:30:30 +0000
+++ src/platform/graphics/mesa/real_kms_display_configuration.h	2014-03-17 15:02:33 +0000
@@ -39,10 +39,7 @@
 
     void for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const override;
     void for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const override;
-    void configure_output(DisplayConfigurationOutputId id, bool used,
-                          geometry::Point top_left, size_t mode_index,
-                          MirPixelFormat format, MirPowerMode power_mode,
-                          MirOrientation orientation) override;
+    void for_each_output(std::function<void(UserDisplayConfigurationOutput&)> f) override;
 
     uint32_t get_kms_connector_id(DisplayConfigurationOutputId id) const;
     size_t get_kms_mode_index(DisplayConfigurationOutputId id, size_t conf_mode_index) const;
 
=== renamed file 'src/platform/graphics/mesa/overlapping_output_grouping.cpp' => 'src/platform/graphics/overlapping_output_grouping.cpp'
--- src/platform/graphics/mesa/overlapping_output_grouping.cpp	2014-01-22 10:03:11 +0000
+++ src/platform/graphics/overlapping_output_grouping.cpp	2014-03-17 15:02:33 +0000
@@ -16,7 +16,7 @@
  * Authored by: Alexandros Frantzis <[e-mail]>
  */
 
-#include "overlapping_output_grouping.h"
+#include "mir/graphics/overlapping_output_grouping.h"
 
 #include "mir/graphics/display_configuration.h"
 #include "mir/geometry/rectangle.h"
@@ -25,7 +25,6 @@
 #include <unordered_set>
 
 namespace mg = mir::graphics;
-namespace mgm = mir::graphics::mesa;
 namespace geom = mir::geometry;
 
 namespace
@@ -33,7 +32,7 @@
 
 struct DCOutputHash
 {
-    size_t operator()(mg::DisplayConfigurationOutput const& o) const { return o.id.as_value(); };
+    size_t operator()(mg::DisplayConfigurationOutput const& o) const { return o.id.as_value(); }
 };
 
 struct DCOutputEqual
@@ -51,7 +50,7 @@
  * OverlappingOutputGroup *
  **************************/
 
-geom::Rectangle mgm::OverlappingOutputGroup::bounding_rectangle() const
+geom::Rectangle mg::OverlappingOutputGroup::bounding_rectangle() const
 {
     geom::Rectangles rectangles;
 
@@ -61,7 +60,7 @@
     return rectangles.bounding_rectangle();
 }
 
-void mgm::OverlappingOutputGroup::for_each_output(
+void mg::OverlappingOutputGroup::for_each_output(
     std::function<void(DisplayConfigurationOutput const&)> const& f) const
 {
     for (auto const& output : outputs)
@@ -72,7 +71,7 @@
  * OverlappingOutputGrouping *
  *****************************/
 
-mgm::OverlappingOutputGrouping::OverlappingOutputGrouping(DisplayConfiguration const& conf)
+mg::OverlappingOutputGrouping::OverlappingOutputGrouping(DisplayConfiguration const& conf)
 {
     conf.for_each_output([&](DisplayConfigurationOutput const& conf_output)
     {
@@ -85,14 +84,14 @@
 
 }
 
-void mgm::OverlappingOutputGrouping::for_each_group(
+void mg::OverlappingOutputGrouping::for_each_group(
     std::function<void(OverlappingOutputGroup const& group)> const& f)
 {
     for (auto const& g : groups)
         f(g);
 }
 
-void mgm::OverlappingOutputGrouping::add_output(DisplayConfigurationOutput const& conf_output)
+void mg::OverlappingOutputGrouping::add_output(DisplayConfigurationOutput const& conf_output)
 {
     std::vector<size_t> overlapping_groups;
 
 
=== modified file 'src/platform/options/default_configuration.cpp'
--- src/platform/options/default_configuration.cpp	2014-03-04 14:19:36 +0000
+++ src/platform/options/default_configuration.cpp	2014-03-17 15:02:33 +0000
@@ -34,7 +34,6 @@
 char const* const mo::scene_report_opt            = "scene-report";
 char const* const mo::input_report_opt            = "input-report";
 char const* const mo::host_socket_opt             = "host-socket";
-char const* const mo::standalone_opt              = "standalone";
 char const* const mo::frontend_threads_opt        = "ipc-thread-pool";
 char const* const mo::name_opt                    = "name";
 char const* const mo::offscreen_opt               = "offscreen";
@@ -70,12 +69,10 @@
     namespace po = boost::program_options;
 
     add_options()
-        (standalone_opt, po::value<bool>(),
-            "Run mir in standalone mode. [bool:default=false]")
         (host_socket_opt, po::value<std::string>(),
-            "Host socket filename. [string:default={$MIR_SOCKET,$XDG_RUNTIME_DIR/mir_socket}]")
+            "Host socket filename")
         (server_socket_opt, po::value<std::string>()->default_value(::mir::default_server_socket),
-            "Socket filename.")
+            "Socket filename [string:default=$XDG_RUNTIME_DIR/mir_socket or /tmp/mir_socket]")
         (no_server_socket_opt, "Do not provide a socket filename for client connections")
         (platform_graphics_lib, po::value<std::string>()->default_value(default_platform_graphics_lib),
             "Library to use for platform graphics support")
 
=== modified file 'src/server/CMakeLists.txt'
--- src/server/CMakeLists.txt	2014-02-28 13:51:43 +0000
+++ src/server/CMakeLists.txt	2014-03-17 15:02:33 +0000
@@ -94,7 +94,7 @@
   )
 endif()
 
-set(MIRSERVER_ABI 16)
+set(MIRSERVER_ABI 17)
 
 set_target_properties(
   mirserver
 
=== modified file 'src/server/compositor/buffer_bundle.h'
--- src/server/compositor/buffer_bundle.h	2014-02-10 09:07:48 +0000
+++ src/server/compositor/buffer_bundle.h	2014-03-17 15:02:33 +0000
@@ -46,6 +46,7 @@
     virtual void allow_framedropping(bool dropping_allowed) = 0;
     virtual void force_requests_to_complete() = 0;
     virtual void resize(const geometry::Size &newsize) = 0;
+    virtual int buffers_ready_for_compositor() const = 0;
 protected:
     BufferBundle() = default;
     BufferBundle(BufferBundle const&) = delete;
 
=== modified file 'src/server/compositor/buffer_stream_surfaces.cpp'
--- src/server/compositor/buffer_stream_surfaces.cpp	2014-02-10 09:07:48 +0000
+++ src/server/compositor/buffer_stream_surfaces.cpp	2014-03-17 15:02:33 +0000
@@ -83,3 +83,8 @@
 {
     buffer_bundle->allow_framedropping(allow);
 }
+
+int mc::BufferStreamSurfaces::buffers_ready_for_compositor() const
+{
+    return buffer_bundle->buffers_ready_for_compositor();
+}
 
=== modified file 'src/server/compositor/buffer_stream_surfaces.h'
--- src/server/compositor/buffer_stream_surfaces.h	2014-02-10 09:07:48 +0000
+++ src/server/compositor/buffer_stream_surfaces.h	2014-03-17 15:02:33 +0000
@@ -50,6 +50,7 @@
     void resize(geometry::Size const& size) override;
     void allow_framedropping(bool) override;
     void force_requests_to_complete() override;
+    int buffers_ready_for_compositor() const override;
 
 protected:
     BufferStreamSurfaces(const BufferStreamSurfaces&) = delete;
 
=== modified file 'src/server/compositor/bypass.cpp'
--- src/server/compositor/bypass.cpp	2014-03-04 04:19:26 +0000
+++ src/server/compositor/bypass.cpp	2014-03-17 15:02:33 +0000
@@ -16,84 +16,46 @@
  * Authored by: Daniel van Vugt <[e-mail]>
  */
 
-#include "mir/compositor/compositing_criteria.h"
+#include "mir/graphics/renderable.h"
 #include "mir/graphics/display_buffer.h"
 #include "bypass.h"
 
 using namespace mir;
 using namespace mir::compositor;
+using namespace mir::graphics;
 
 BypassFilter::BypassFilter(const graphics::DisplayBuffer &display_buffer)
         : display_buffer(display_buffer)
 {
-    const geometry::Rectangle &rect = display_buffer.view_area();
-    int width = rect.size.width.as_int();
-    int height = rect.size.height.as_int();
-
-    /*
-     * For a surface to exactly fit the display_buffer, its transformation
-     * will look exactly like this:
-     */
-    fullscreen[0][0] = width;
-    fullscreen[0][1] = 0.0f;
-    fullscreen[0][2] = 0.0f;
-    fullscreen[0][3] = 0.0f;
-
-    fullscreen[1][0] = 0.0f;
-    fullscreen[1][1] = height;
-    fullscreen[1][2] = 0.0f;
-    fullscreen[1][3] = 0.0f;
-
-    fullscreen[2][0] = 0.0f;
-    fullscreen[2][1] = 0.0f;
-    fullscreen[2][2] = 0.0f;
-    fullscreen[2][3] = 0.0f;
-
-    fullscreen[3][0] = rect.top_left.x.as_int() + width / 2;
-    fullscreen[3][1] = rect.top_left.y.as_int() + height / 2;
-    fullscreen[3][2] = 0.0f;
-    fullscreen[3][3] = 1.0f;
 }
 
-bool BypassFilter::operator()(const CompositingCriteria &criteria)
+bool BypassFilter::operator()(const Renderable &renderable)
 {
     if (!all_orthogonal)
         return false;
 
-    const glm::mat4 &trans = criteria.transformation();
-    bool orthogonal =
-        trans[0][1] == 0.0f &&
-        trans[0][2] == 0.0f &&
-        trans[0][3] == 0.0f &&
-        trans[1][0] == 0.0f &&
-        trans[1][2] == 0.0f &&
-        trans[1][3] == 0.0f &&
-        trans[2][0] == 0.0f &&
-        trans[2][1] == 0.0f &&
-        trans[2][2] == 0.0f &&
-        trans[2][3] == 0.0f &&
-        trans[3][2] == 0.0f &&
-        trans[3][3] == 1.0f;
-
     // Any weird transformations? Then we can't risk any bypass
-    if (!orthogonal)
+    static const glm::mat4 identity;
+    if (renderable.transformation() != identity)
     {
         all_orthogonal = false;
         return false;
     }
 
+    auto const& view_area = display_buffer.view_area();
+
     // Not weirdly transformed but also not on this monitor? Don't care...
     // This will also check the surface is not hidden and has been posted.
-    if (!criteria.should_be_rendered_in(display_buffer.view_area()))
+    if (!renderable.should_be_rendered_in(view_area))
         return false;
 
     topmost_fits = false;
 
-    if (criteria.alpha() != 1.0f || criteria.shaped())
+    if (renderable.alpha() != 1.0f || renderable.shaped())
         return false;
 
     // Transformed perfectly to fit the monitor? Bypass!
-    topmost_fits = criteria.transformation() == fullscreen;
+    topmost_fits = renderable.screen_position() == view_area;
     return topmost_fits;
 }
 
@@ -102,13 +64,12 @@
     return all_orthogonal && topmost_fits;
 }
 
-void BypassMatch::operator()(const CompositingCriteria &,
-                             compositor::BufferStream &stream)
+void BypassMatch::operator()(const Renderable &r)
 {
-    latest = &stream;
+    latest = &r;
 }
 
-compositor::BufferStream *BypassMatch::topmost_fullscreen() const
+const Renderable *BypassMatch::topmost_fullscreen() const
 {
     return latest;
 }
 
=== modified file 'src/server/compositor/bypass.h'
--- src/server/compositor/bypass.h	2014-03-04 04:19:26 +0000
+++ src/server/compositor/bypass.h	2014-03-17 15:02:33 +0000
@@ -20,7 +20,6 @@
 #define MIR_COMPOSITOR_BYPASS_H_
 
 #include "mir/compositor/scene.h"
-#include "glm/glm.hpp"
 
 namespace mir
 {
@@ -30,32 +29,29 @@
 }
 namespace compositor
 {
-class CompositingCriteria;
 
 class BypassFilter : public FilterForScene
 {
 public:
     BypassFilter(const graphics::DisplayBuffer &display_buffer);
-    bool operator()(const CompositingCriteria &criteria) override;
+    bool operator()(const graphics::Renderable &) override;
     bool fullscreen_on_top() const;
 
 private:
     bool all_orthogonal = true;
     bool topmost_fits = false;
-    glm::mat4 fullscreen;
     const graphics::DisplayBuffer &display_buffer;
 };
 
 class BypassMatch : public OperatorForScene
 {
 public:
-    void operator()(const CompositingCriteria &,
-                    compositor::BufferStream &stream) override;
-    compositor::BufferStream *topmost_fullscreen() const;
+    void operator()(const graphics::Renderable &) override;
+    const graphics::Renderable *topmost_fullscreen() const;
 
 private:
-    // This has to be a pointer. We have no control over BufferStream lifetime
-    compositor::BufferStream *latest = nullptr;
+    // This has to be a pointer. We have no control over Renderable lifetime
+    const graphics::Renderable *latest = nullptr;
 };
 
 } // namespace compositor
 
=== modified file 'src/server/compositor/compositing_screencast.cpp'
--- src/server/compositor/compositing_screencast.cpp	2014-02-05 16:32:31 +0000
+++ src/server/compositor/compositing_screencast.cpp	2014-03-17 15:02:33 +0000
@@ -60,15 +60,21 @@
 }
 
 mf::ScreencastSessionId mc::CompositingScreencast::create_session(
-    graphics::DisplayConfigurationOutputId output_id)
+    geom::Rectangle const& region,
+    geom::Size const& size,
+    MirPixelFormat const pixel_format)
 {
-    geom::Rectangle extents;
-    MirPixelFormat pixel_format;
-    std::tie(extents,pixel_format) = output_info_for(output_id);
-
+    if (size.width.as_int() == 0 ||
+        size.height.as_int() == 0 ||
+        region.size.width.as_int() == 0 ||
+        region.size.height.as_int() == 0 ||
+        pixel_format == mir_pixel_format_invalid)
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid parameters"));
+    }
     std::lock_guard<decltype(session_mutex)> lock{session_mutex};
     auto const id = next_available_session_id();
-    session_contexts[id] = create_session_context(extents, pixel_format);
+    session_contexts[id] = create_session_context(region, size, pixel_format);
 
     return id;
 }
@@ -115,43 +121,14 @@
     BOOST_THROW_EXCEPTION(std::runtime_error("Too many screencast sessions!"));
 }
 
-std::pair<geom::Rectangle,MirPixelFormat>
-mc::CompositingScreencast::output_info_for(
-    graphics::DisplayConfigurationOutputId output_id)
-{
-    auto const conf = display->configuration();
-    geom::Rectangle extents;
-    MirPixelFormat pixel_format{mir_pixel_format_invalid};
-
-    conf->for_each_output(
-        [&](mg::DisplayConfigurationOutput const& output)
-        {
-            if (output.id == output_id &&
-                output.connected && output.used &&
-                output.current_mode_index < output.modes.size())
-            {
-                extents = output.extents();
-                pixel_format = output.current_format;
-            }
-        });
-
-    if (extents == geom::Rectangle() ||
-        pixel_format == mir_pixel_format_invalid)
-    {
-        BOOST_THROW_EXCEPTION(
-            std::runtime_error("Invalid output for screen capture"));
-    }
-
-    return {extents, pixel_format};
-}
-
 std::shared_ptr<mc::detail::ScreencastSessionContext>
 mc::CompositingScreencast::create_session_context(
     geometry::Rectangle const& rect,
+    geometry::Size const& size,
     MirPixelFormat pixel_format)
 {
     mg::BufferProperties buffer_properties{
-        rect.size,
+        size,
         pixel_format,
         mg::BufferUsage::hardware};
 
 
=== modified file 'src/server/compositor/compositing_screencast.h'
--- src/server/compositor/compositing_screencast.h	2014-02-05 16:32:31 +0000
+++ src/server/compositor/compositing_screencast.h	2014-03-17 15:02:33 +0000
@@ -48,16 +48,18 @@
         std::shared_ptr<DisplayBufferCompositorFactory> const& db_compositor_factory);
 
     frontend::ScreencastSessionId create_session(
-        graphics::DisplayConfigurationOutputId output_id);
+        geometry::Rectangle const& region,
+        geometry::Size const& size,
+        MirPixelFormat pixel_format);
     void destroy_session(frontend::ScreencastSessionId id);
     std::shared_ptr<graphics::Buffer> capture(frontend::ScreencastSessionId id);
 
 private:
     frontend::ScreencastSessionId next_available_session_id();
-    std::pair<geometry::Rectangle,MirPixelFormat> output_info_for(
-        graphics::DisplayConfigurationOutputId output_id);
     std::shared_ptr<detail::ScreencastSessionContext>
-        create_session_context(geometry::Rectangle const& rect, MirPixelFormat pixel_format);
+        create_session_context(geometry::Rectangle const& rect,
+            geometry::Size const& size,
+            MirPixelFormat pixel_format);
 
     std::mutex session_mutex;
     std::shared_ptr<graphics::Display> const display;
 
=== modified file 'src/server/compositor/default_configuration.cpp'
--- src/server/compositor/default_configuration.cpp	2014-02-28 13:51:43 +0000
+++ src/server/compositor/default_configuration.cpp	2014-03-17 15:02:33 +0000
@@ -25,6 +25,7 @@
 #include "compositing_screencast.h"
 
 #include "mir/frontend/screencast.h"
+#include "mir/options/configuration.h"
 
 #include <boost/throw_exception.hpp>
 
@@ -59,10 +60,12 @@
     return compositor(
         [this]()
         {
-            return std::make_shared<mc::MultiThreadedCompositor>(the_display(),
-                                                                 the_scene(),
-                                                                 the_display_buffer_compositor_factory(),
-                                                                 the_compositor_report());
+            return std::make_shared<mc::MultiThreadedCompositor>(
+                the_display(),
+                the_scene(),
+                the_display_buffer_compositor_factory(),
+                the_compositor_report(),
+                !the_options()->is_set(options::host_socket_opt));
         });
 }
 
 
=== modified file 'src/server/compositor/default_display_buffer_compositor.cpp'
--- src/server/compositor/default_display_buffer_compositor.cpp	2014-03-04 04:19:26 +0000
+++ src/server/compositor/default_display_buffer_compositor.cpp	2014-03-17 15:02:33 +0000
@@ -21,7 +21,7 @@
 
 #include "rendering_operator.h"
 #include "mir/compositor/scene.h"
-#include "mir/compositor/compositing_criteria.h"
+#include "mir/graphics/renderable.h"
 #include "mir/graphics/display_buffer.h"
 #include "mir/graphics/buffer.h"
 #include "mir/compositor/buffer_stream.h"
@@ -46,10 +46,10 @@
           occlusions(occlusions)
     {
     }
-    bool operator()(mc::CompositingCriteria const& info)
+    bool operator()(mg::Renderable const& r)
     {
-        return info.should_be_rendered_in(enclosing_region) &&
-               !occlusions.occluded(info);
+        return r.should_be_rendered_in(enclosing_region) &&
+               !occlusions.occluded(r);
     }
 
     mir::geometry::Rectangle const& enclosing_region;
@@ -80,7 +80,7 @@
 }
 
 
-void mc::DefaultDisplayBufferCompositor::composite()
+bool mc::DefaultDisplayBufferCompositor::composite()
 {
     report->began_frame(this);
 
@@ -104,9 +104,15 @@
         return !env || env[0] != '0';
     }()};
     bool bypassed = false;
+    bool uncomposited_buffers{false};
 
     if (bypass_env && display_buffer.can_bypass())
     {
+        // It would be *really* nice not to lock the scene for a composite pass.
+        // (C.f. lp:1234018)
+        // A compositor shouldn't know anything about navigating the scene,
+        // it should be passed a collection of objects to render. (And any
+        // locks managed by the scene - which can just lock what is needed.)
         std::unique_lock<Scene> lock(*scene);
 
         mc::BypassFilter filter(display_buffer);
@@ -118,11 +124,12 @@
         if (filter.fullscreen_on_top())
         {
             auto bypass_buf =
-                match.topmost_fullscreen()->lock_compositor_buffer(
-                    local_frameno);
+                match.topmost_fullscreen()->buffer(local_frameno);
 
             if (bypass_buf->can_bypass())
             {
+                uncomposited_buffers = match.topmost_fullscreen()->buffers_ready_for_compositor() > 1;
+
                 lock.unlock();
                 display_buffer.post_update(bypass_buf);
                 bypassed = true;
@@ -150,14 +157,24 @@
 
         renderer->set_rotation(display_buffer.orientation());
         renderer->begin();
-        mc::RenderingOperator applicator(*renderer, save_resource, local_frameno);
+        mc::RenderingOperator applicator(*renderer, save_resource, local_frameno, uncomposited_buffers);
         FilterForVisibleSceneInRegion selector(view_area, occlusion_match);
         scene->for_each_if(selector, applicator);
         renderer->end();
 
         display_buffer.post_update();
+
+        // This is a frig to avoid lp:1286190
+        if (size_of_last_pass)
+        {
+            uncomposited_buffers |= saved_resources.empty();
+        }
+
+        size_of_last_pass = saved_resources.size();
+        // End of frig
     }
 
     report->finished_frame(bypassed, this);
+    return uncomposited_buffers;
 }
 
 
=== modified file 'src/server/compositor/default_display_buffer_compositor.h'
--- src/server/compositor/default_display_buffer_compositor.h	2014-01-22 10:03:11 +0000
+++ src/server/compositor/default_display_buffer_compositor.h	2014-03-17 15:02:33 +0000
@@ -44,7 +44,7 @@
         std::shared_ptr<Renderer> const& renderer,
         std::shared_ptr<CompositorReport> const& report);
 
-    void composite() override;
+    bool composite() override;
 
 private:
     graphics::DisplayBuffer& display_buffer;
@@ -53,6 +53,7 @@
     std::shared_ptr<Renderer> const renderer;
     std::shared_ptr<CompositorReport> const report;
 
+    int size_of_last_pass = 0;
     unsigned long local_frameno;
 };
 
 
=== modified file 'src/server/compositor/default_display_buffer_compositor_factory.cpp'
--- src/server/compositor/default_display_buffer_compositor_factory.cpp	2014-01-31 05:10:46 +0000
+++ src/server/compositor/default_display_buffer_compositor_factory.cpp	2014-03-17 15:02:33 +0000
@@ -17,8 +17,8 @@
  */
 
 #include "default_display_buffer_compositor_factory.h"
-#include "renderer_factory.h"
-#include "renderer.h"
+#include "mir/compositor/renderer_factory.h"
+#include "mir/compositor/renderer.h"
 #include "mir/graphics/display_buffer.h"
 
 #include "default_display_buffer_compositor.h"
 
=== modified file 'src/server/compositor/gl_renderer.cpp'
--- src/server/compositor/gl_renderer.cpp	2014-03-04 04:19:26 +0000
+++ src/server/compositor/gl_renderer.cpp	2014-03-17 15:02:33 +0000
@@ -15,11 +15,12 @@
  * Authored By: Alexandros Frantzis <[e-mail]>
  */
 
-#include "gl_renderer.h"
-#include "mir/compositor/compositing_criteria.h"
+#include "mir/compositor/gl_renderer.h"
 #include "mir/compositor/buffer_stream.h"
+#include "mir/graphics/renderable.h"
 #include "mir/graphics/buffer.h"
 
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
 
@@ -42,9 +43,13 @@
     "uniform mat4 screen_to_gl_coords;\n"
     "uniform mat4 display_transform;\n"
     "uniform mat4 transform;\n"
+    "uniform vec2 centre;\n"
     "varying vec2 v_texcoord;\n"
     "void main() {\n"
-    "   gl_Position = display_transform * screen_to_gl_coords * transform * vec4(position, 1.0);\n"
+    "   vec4 mid = vec4(centre, 0.0, 0.0);\n"
+    "   vec4 transformed = (transform * (vec4(position, 1.0) - mid)) + mid;\n"
+    "   transformed.z = 0.0;\n" // avoid clipping while we lack depth/perspective
+    "   gl_Position = display_transform * screen_to_gl_coords * transformed;\n"
     "   v_texcoord = texcoord;\n"
     "}\n"
 };
@@ -61,39 +66,6 @@
     "}\n"
 };
 
-struct VertexAttributes
-{
-    glm::vec3 position;
-    glm::vec2 texcoord;
-};
-
-/*
- * The texture coordinates are y-inverted to account for the difference in the
- * texture and renderable pixel data row order. In particular, GL textures
- * expect pixel data in rows starting from the bottom and moving up the image,
- * whereas our renderables provide data in rows starting from the top and
- * moving down the image.
- */
-VertexAttributes vertex_attribs[4] =
-{
-    {
-        glm::vec3{-0.5f, -0.5f, 0.0f},
-        glm::vec2{0.0f, 0.0f}
-    },
-    {
-        glm::vec3{-0.5f, 0.5f, 0.0f},
-        glm::vec2{0.0f, 1.0f},
-    },
-    {
-        glm::vec3{0.5f, -0.5f, 0.0f},
-        glm::vec2{1.0f, 0.0f},
-    },
-    {
-        glm::vec3{0.5f, 0.5f, 0.0f},
-        glm::vec2{1.0f, 1.0f}
-    }
-};
-
 typedef void(*MirGLGetObjectInfoLog)(GLuint, GLsizei, GLsizei *, GLchar *);
 typedef void(*MirGLGetObjectiv)(GLuint, GLenum, GLint *);
 
@@ -126,9 +98,9 @@
     program(0),
     position_attr_loc(0),
     texcoord_attr_loc(0),
+    centre_uniform_loc(0),
     transform_uniform_loc(0),
     alpha_uniform_loc(0),
-    vertex_attribs_vbo(0),
     rotation(NAN) // ensure the first set_rotation succeeds
 {
     /*
@@ -189,16 +161,10 @@
     alpha_uniform_loc = glGetUniformLocation(program, "alpha");
     position_attr_loc = glGetAttribLocation(program, "position");
     texcoord_attr_loc = glGetAttribLocation(program, "texcoord");
+    centre_uniform_loc = glGetUniformLocation(program, "centre");
 
     glUniform1i(tex_loc, 0);
 
-    /* Create VBO */
-    glGenBuffers(1, &vertex_attribs_vbo);