Merge lp:mir/0.9 into lp:mir/ubuntu

[Alberto Aguirre]

mir 0.9.0 release

mir 0.9.0 release

Preparation for 0.9.0 release

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2072
http://jenkins.qa.ubuntu.com/job/mir-ubuntu-ci/16/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/197/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/197
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-armhf-ci/1/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2073
http://jenkins.qa.ubuntu.com/job/mir-ubuntu-ci/18/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/211/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/211
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-armhf-ci/3/console

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

review: Needs Fixing (continuous-integration)

[Alan Griffiths (alan-griffiths)]

I don't see this in the CI queue - triggering build manually

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2073
http://jenkins.qa.ubuntu.com/job/mir-ubuntu-ci/19/
Executed test runs:
    None: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/235/console
    None: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/235/console
    None: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/4/console
    None: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-armhf-ci/4/console

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

review: Needs Fixing (continuous-integration)

[Alan Griffiths (alan-griffiths)]

> I don't see this in the CI queue - triggering build manually

aborted that - there are still conflicts

[Alberto Aguirre (albaguirre)]

Weird, the silo builders don't see any conflicts and all tests pass.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2075
http://jenkins.qa.ubuntu.com/job/mir-ubuntu-ci/20/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/243
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/243
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-armhf-ci/5/console

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

review: Needs Fixing (continuous-integration)

[Alberto Aguirre (albaguirre)]

^-> ummm interesting...

8: [ RUN ] GLibMainLoopTest.propagates_exception_from_signal_handler
8: unknown file: Failure
8: C++ exception with description "Timeout while waiting for child to change state" thrown in the test body.
8: disInstr(thumb): unhandled instruction: 0xDEFF 0xF893
8: [ FAILED ] GLibMainLoopTest.propagates_exception_from_signal_handler (5988 ms)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2075
http://jenkins.qa.ubuntu.com/job/mir-ubuntu-ci/21/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/245
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/245
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/6
        deb: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-amd64-ci/6/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-ubuntu-vivid-armhf-ci/6/console

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

review: Needs Fixing (continuous-integration)

[Cemil Azizoglu (cemil-azizoglu)]

I guess 5 seconds isn't enough?

        auto const result = child.wait_for_termination(std::chrono::seconds{5});

[Alberto Aguirre (albaguirre)]

It's the same 6 failures:

[ FAILED ] GLibMainLoopTest.propagates_exception_from_signal_handler
[ FAILED ] GLibMainLoopTest.propagates_exception_from_fd_handler
[ FAILED ] GLibMainLoopTest.propagates_exception_from_server_action
[ FAILED ] GLibMainLoopTest.can_be_rerun_after_exception
[ FAILED ] GLibMainLoopAlarmTest.propagates_exception_from_alarm
[ FAILED ] GLibMainLoopForkTest.handles_signals_when_created_in_forked_process

And at least one of them has "8: disInstr(thumb): unhandled instruction: 0xDEFF 0xF893", I guess valgrind didn't like that in this machine?

In any case, silo builders built tests succesfully.

[Daniel van Vugt (vanvugt)]

That's weird. If we're targeting the right branch, this shouldn't be visible:

1395 +mir (0.8.0+14.10.20141010-0ubuntu2) vivid; urgency=medium
1396 +
1397 + * No change rebuild to get debug symbols on all architectures.
1398 +
1399 + -- Brian Murray <email address hidden> Wed, 19 Nov 2014 11:33:10 -0800

[Daniel van Vugt (vanvugt)]

review: Needs Information

[Alberto Aguirre (albaguirre)]

@Daniel,

A rebuild was done in archive. I merged that changelog entry to avoid conflicts when publishing the new release.

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/EventHub.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/EventHub.cpp	2014-03-26 05:48:59 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/EventHub.cpp	2014-11-25 17:45:03 +0000
@@ -24,6 +24,7 @@
 #define release_wake_lock(id) {}
 
 #include "mir/input/input_report.h"
+#include "mir/udev/wrapper.h"
 
 #include <cutils/properties.h>
 #include <std/Log.h>
@@ -212,7 +213,7 @@
 
 EventHub::EventHub(std::shared_ptr<mi::InputReport> const& input_report) :
         input_report(input_report),
-        device_listener{mir::udev::Context()},
+        device_listener{new mir::udev::Monitor{mir::udev::Context()}},
         mBuiltInKeyboardId(NO_BUILT_IN_KEYBOARD), mNextDeviceId(1),
         mOpeningDevices(0), mClosingDevices(0),
         mNeedToSendFinishedDeviceScan(false),
@@ -223,15 +224,15 @@
     mEpollFd = epoll_create(EPOLL_SIZE_HINT);
     LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance.  errno=%d", errno);
 
-    device_listener.filter_by_subsystem("input");
-    device_listener.enable();
+    device_listener->filter_by_subsystem("input");
+    device_listener->enable();
 
 
     struct epoll_event eventItem;
     memset(&eventItem, 0, sizeof(eventItem));
     eventItem.events = EPOLLIN;
     eventItem.data.u32 = EPOLL_ID_UDEV;
-    int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, device_listener.fd(), &eventItem);
+    int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, device_listener->fd(), &eventItem);
     LOG_ALWAYS_FATAL_IF(result != 0, "Could not add Udev monitor to epoll instance.  errno=%d", errno);
 
     int wakeFds[2];
@@ -935,7 +936,7 @@
 
 void EventHub::handleUdevEventsLocked()
 {
-    device_listener.process_events([this](mir::udev::Monitor::EventType type, mir::udev::Device const& dev){
+    device_listener->process_events([this](mir::udev::Monitor::EventType type, mir::udev::Device const& dev){
         if (type == mir::udev::Monitor::ADDED)
         {
             if (dev.devnode() != nullptr)

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/EventHub.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/EventHub.h	2014-09-11 05:51:44 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/EventHub.h	2014-11-25 17:45:03 +0000
@@ -18,8 +18,6 @@
 #ifndef _RUNTIME_EVENT_HUB_H
 #define _RUNTIME_EVENT_HUB_H
 
-#include "mir/udev/wrapper.h"
-
 #include <androidfw/Input.h>
 #include <androidfw/InputDevice.h>
 #include <androidfw/Keyboard.h>
@@ -41,6 +39,7 @@
 
 namespace mir
 {
+namespace udev { class Monitor; }
 namespace input
 {
 class InputReport;
@@ -407,7 +406,7 @@
     Vector<String8> mExcludedDevices;
 
     int mEpollFd;
-    mir::udev::Monitor device_listener;
+    std::unique_ptr<mir::udev::Monitor> const device_listener;
     int mWakeReadPipeFd;
     int mWakeWritePipeFd;
 

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-09-30 06:11:33 +0000
+++ CMakeLists.txt	2014-11-25 17:45:03 +0000
@@ -27,7 +27,7 @@
 set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib)
 
 set(MIR_VERSION_MAJOR 0)
-set(MIR_VERSION_MINOR 8) # This should change at least with every MIRSERVER_ABI
+set(MIR_VERSION_MINOR 9) # This should change at least with every MIRSERVER_ABI
 set(MIR_VERSION_PATCH 0)
 
 set(MIR_VERSION ${MIR_VERSION_MAJOR}.${MIR_VERSION_MINOR}.${MIR_VERSION_PATCH})
@@ -154,6 +154,7 @@
 find_package(XKBCOMMON REQUIRED)
 find_package(LTTngUST REQUIRED)
 pkg_check_modules(UDEV REQUIRED libudev)
+pkg_check_modules(GLIB REQUIRED glib-2.0)
 
 include_directories (${GLESv2_INCLUDE_DIRS})
 include_directories (${EGL_INCLUDE_DIRS})

=== modified file 'benchmarks/CMakeLists.txt'
--- benchmarks/CMakeLists.txt	2014-03-06 06:05:17 +0000
+++ benchmarks/CMakeLists.txt	2014-11-25 17:45:03 +0000
@@ -1,13 +1,12 @@
-include_directories(${MIR_3RD_PARTY_INCLUDE_DIRECTORIES})
-include_directories(${MIR_ANDROID_INCLUDE_DIRECTORIES})
-add_custom_target(
-  benchmarks
-)
+add_custom_target(benchmarks)   # XXX Is this used by anything?
+
+add_subdirectory(cpu)
+add_subdirectory(memory)
+add_dependencies(benchmarks cpu_benchmarks memory_benchmarks)
 
 if (MIR_ENABLE_TESTS)
+  # Shouldn't tests dependent things be in tests/?
   add_subdirectory(android-input)
+  add_subdirectory(frame-uniformity)
+  add_dependencies(benchmarks frame_uniformity_test_client)
 endif ()
-add_subdirectory(cpu)
-add_subdirectory(memory)
-
-add_dependencies(benchmarks cpu_benchmarks memory_benchmarks)

=== modified file 'benchmarks/android-input/CMakeLists.txt'
--- benchmarks/android-input/CMakeLists.txt	2014-09-30 06:11:33 +0000
+++ benchmarks/android-input/CMakeLists.txt	2014-11-25 17:45:03 +0000
@@ -7,6 +7,8 @@
 include_directories(
   ${Mir_SOURCE_DIR}/tests/include
   ${Mir_SOURCE_DIR}/include/platform
+  ${MIR_ANDROID_INCLUDE_DIRECTORIES}
+  ${MIR_3RD_PARTY_INCLUDE_DIRECTORIES}
 )
 
 add_executable(input-reader-perf ${SOURCES})

=== modified file 'benchmarks/android-input/input_reader_perf.cpp'
--- benchmarks/android-input/input_reader_perf.cpp	2014-09-11 05:51:44 +0000
+++ benchmarks/android-input/input_reader_perf.cpp	2014-11-25 17:45:03 +0000
@@ -62,13 +62,13 @@
     }
 
     void getAssociatedDisplayInfo(InputDeviceIdentifier const& /* identifier */,
-        int& out_associated_display_id, bool& out_associated_display_is_external) {
+        int& out_associated_display_id, bool& out_associated_display_is_external) override {
         out_associated_display_id = 0;
         out_associated_display_is_external = false;
     }
 
 private:
-    virtual void getReaderConfiguration(InputReaderConfiguration* outConfig) {
+    virtual void getReaderConfiguration(InputReaderConfiguration* outConfig) override {
         *outConfig = mConfig;
     }
 
@@ -77,7 +77,7 @@
         return sp<PointerControllerInterface>();
     }
 
-    virtual void notifyInputDevicesChanged(const Vector<InputDeviceInfo>& inputDevices) {
+    virtual void notifyInputDevicesChanged(const Vector<InputDeviceInfo>& inputDevices) override {
         mInputDevices = inputDevices;
     }
 

=== added directory 'benchmarks/frame-uniformity'
=== added file 'benchmarks/frame-uniformity/CMakeLists.txt'
--- benchmarks/frame-uniformity/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ benchmarks/frame-uniformity/CMakeLists.txt	2014-11-25 17:45:03 +0000
@@ -0,0 +1,45 @@
+include_directories(
+  ${PROJECT_SOURCE_DIR}/include/common
+  ${PROJECT_SOURCE_DIR}/include/platform
+  ${PROJECT_SOURCE_DIR}/include/server
+  ${PROJECT_SOURCE_DIR}/include/client
+  ${PROJECT_SOURCE_DIR}/tests/include/
+
+  ${PROJECT_SOURCE_DIR}/src/include/platform
+  ${PROJECT_SOURCE_DIR}
+  ${MIR_ANDROID_INCLUDE_DIRECTORIES}
+  ${MIR_3RD_PARTY_INCLUDE_DIRECTORIES}
+)
+
+add_executable(frame_uniformity_test_client
+  touch_measuring_client.cpp
+  touch_producing_server.cpp
+  frame_uniformity_test.cpp
+  vsync_simulating_graphics_platform.cpp
+  touch_samples.cpp
+  main.cpp
+)
+
+target_link_libraries(frame_uniformity_test_client
+  mirserver
+  mirclient
+  
+  mir-test
+  mir-test-framework
+  mir-test-doubles
+  mir-test-doubles-platform
+
+  # Why does this have to come after mir-test-framework here but not in tests/acceptance-tests/
+  # /CMakeLists.txt? ~racarr
+  mirplatform
+
+  3rd_party
+  ${PROTOBUF_LIBRARIES}
+  ${Boost_LIBRARIES}
+  ${GTEST_BOTH_LIBRARIES}
+  ${GMOCK_LIBRARY}
+  ${GMOCK_MAIN_LIBRARY}
+  ${CMAKE_THREAD_LIBS_INIT} # Link in pthread.
+)
+
+uses_android_input(frame_uniformity_test_client)

=== added file 'benchmarks/frame-uniformity/README.txt'
--- benchmarks/frame-uniformity/README.txt	1970-01-01 00:00:00 +0000
+++ benchmarks/frame-uniformity/README.txt	2014-11-25 17:45:03 +0000
@@ -0,0 +1,13 @@
+This benchmark uses a client server setup and simulated touch events in order to compute two metrics: Average Pixel Lag, and Frame Uniformity.
+
+Average pixel lag is measured as follows. A client is run, and put in position to receive the simulated touch events. Said client renders frames as fast as allowed (in the test, a simulated vsync timer on the server throttles rendering). At each frame time, the client records its most up to date pointer sample. Following receipt of all the events, the touch simulation parameters are used to interpolate where the touch was expected at each frame time. The average pixel lag is the average difference between this physical (simulated) touch location, and the client recording at each frame time.
+
+Frame uniformity is the standard deviation of the average pixel lag over all samples.
+
+Several test parameters are variable : TODO: Explain how to vary, currently requires code changes.
+Touch event start
+Touch event end
+Touch duration
+Vsync rate
+Input event rate
+Test repeat count (resulting in averaged results).

=== added file 'benchmarks/frame-uniformity/frame_uniformity_test.cpp'
--- benchmarks/frame-uniformity/frame_uniformity_test.cpp	1970-01-01 00:00:00 +0000
+++ benchmarks/frame-uniformity/frame_uniformity_test.cpp	2014-11-25 17:45:03 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#include "frame_uniformity_test.h"
+
+FrameUniformityTest::FrameUniformityTest(FrameUniformityTestParameters const& parameters)
+    : client_ready_fence{2},
+      server_configuration({{0, 0}, parameters.screen_size},
+          parameters.touch_start,
+          parameters.touch_end,
+          parameters.touch_duration,
+          client_ready_fence),
+      client(client_ready_fence, parameters.touch_duration)
+{
+}
+
+mir::DefaultServerConfiguration& FrameUniformityTest::server_config()
+{
+    return server_configuration;
+}
+
+void FrameUniformityTest::run_test()
+{
+    start_server();
+    client.run(new_connection());
+    stop_server();
+}
+
+std::shared_ptr<TouchSamples> FrameUniformityTest::client_results()
+{
+    return client.results();
+}
+
+TouchProducingServer::TouchTimings FrameUniformityTest::server_timings()
+{
+    return server_configuration.touch_timings();
+}

=== added file 'benchmarks/frame-uniformity/frame_uniformity_test.h'
--- benchmarks/frame-uniformity/frame_uniformity_test.h	1970-01-01 00:00:00 +0000
+++ benchmarks/frame-uniformity/frame_uniformity_test.h	2014-11-25 17:45:03 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef FRAME_UNIFORMITY_TEST_H_
+#define FRAME_UNIFORMITY_TEST_H_
+
+#include "touch_producing_server.h"
+#include "touch_measuring_client.h"
+#include "touch_samples.h"
+
+#include "mir/geometry/size.h"
+#include "mir/geometry/point.h"
+
+#include "mir_test/barrier.h"
+
+#include "mir_test_framework/server_runner.h"
+
+#include <chrono>
+
+struct FrameUniformityTestParameters
+{
+    mir::geometry::Size screen_size;
+    mir::geometry::Point touch_start;
+    mir::geometry::Point touch_end;
+
+    std::chrono::milliseconds touch_duration;
+};
+
+class FrameUniformityTest : public mir_test_framework::ServerRunner
+{
+public:
+    FrameUniformityTest(FrameUniformityTestParameters const& parameters);
+    virtual ~FrameUniformityTest() = default;
+    
+    mir::DefaultServerConfiguration& server_config() override;
+    
+    void run_test();
+    
+    std::shared_ptr<TouchSamples> client_results();
+    
+    TouchProducingServer::TouchTimings server_timings();
+
+private:
+    mir::test::Barrier client_ready_fence;
+    TouchProducingServer server_configuration;
+    TouchMeasuringClient client;
+};
+
+#endif // FRAME_UNIFORMITY_TEST_H_

=== added file 'benchmarks/frame-uniformity/main.cpp'
--- benchmarks/frame-uniformity/main.cpp	1970-01-01 00:00:00 +0000
+++ benchmarks/frame-uniformity/main.cpp	2014-11-25 17:45:03 +0000
@@ -0,0 +1,143 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#include "frame_uniformity_test.h"
+
+#include <assert.h>
+#include <cmath>
+
+#include <chrono>
+#include <iostream>
+
+#include <gtest/gtest.h>
+
+namespace geom = mir::geometry;
+
+namespace
+{
+
+geom::Point interpolated_touch_at_time(geom::Point touch_start, geom::Point touch_end,
+    std::chrono::high_resolution_clock::time_point touch_start_time,
+    std::chrono::high_resolution_clock::time_point touch_end_time,
+    std::chrono::high_resolution_clock::time_point interpolated_touch_time)
+{
+    assert(interpolated_touch_time > touch_start_time);
+
+    double elapsed_interval = interpolated_touch_time.time_since_epoch().count() - touch_start_time.time_since_epoch().count();
+    double total_interval = touch_end_time.time_since_epoch().count() -
+        touch_start_time.time_since_epoch().count();
+
+    double alpha = elapsed_interval / total_interval;
+    
+    auto ix = touch_start.x.as_int() + (touch_end.x.as_int()-touch_start.x.as_int())*alpha;
+    auto iy = touch_start.y.as_int() + (touch_end.y.as_int()-touch_start.y.as_int())*alpha;
+    return {ix, iy};
+}
+
+double pixel_lag_for_sample_at_time(geom::Point touch_start_point, geom::Point touch_end_point,
+    std::chrono::high_resolution_clock::time_point touch_start_time,
+    std::chrono::high_resolution_clock::time_point touch_end_time,
+    TouchSamples::Sample const& sample)
+{
+    auto expected_point = interpolated_touch_at_time(touch_start_point, touch_end_point, touch_start_time,
+        touch_end_time, sample.frame_time);
+    auto dx = sample.x - expected_point.x.as_int();
+    auto dy = sample.y - expected_point.y.as_int();
+    auto distance = std::sqrt(dx*dx+dy*dy);
+    return distance;
+}
+
+double compute_average_frame_offset(std::vector<TouchSamples::Sample> const& results,
+    geom::Point touch_start_point, geom::Point touch_end_point,
+    std::chrono::high_resolution_clock::time_point touch_start_time,
+    std::chrono::high_resolution_clock::time_point touch_end_time)
+{
+    double sum = 0;
+    for (auto const& sample : results)
+    {
+        auto distance = pixel_lag_for_sample_at_time(touch_start_point, touch_end_point, touch_start_time, 
+            touch_end_time, sample);
+        sum += distance;
+    }
+    return sum / results.size();
+}
+
+struct Results
+{
+    double average_pixel_offset;
+    double frame_uniformity;
+};
+
+Results compute_frame_uniformity(std::vector<TouchSamples::Sample> const& results,
+    geom::Point touch_start_point, geom::Point touch_end_point,
+    std::chrono::high_resolution_clock::time_point touch_start_time,
+    std::chrono::high_resolution_clock::time_point touch_end_time)
+{
+    auto average_pixel_offset = compute_average_frame_offset(results, touch_start_point, touch_end_point,
+        touch_start_time, touch_end_time);
+    
+    double sum = 0;
+    for (auto const& sample : results)
+    {
+        auto distance = pixel_lag_for_sample_at_time(touch_start_point, touch_end_point, touch_start_time, 
+            touch_end_time, sample);
+        sum += (distance-average_pixel_offset)*(distance-average_pixel_offset);
+    }
+    double uniformity = std::sqrt(sum/results.size());
+    return {average_pixel_offset, uniformity};
+}
+
+}
+
+// Main is inside a test to work around mir_test_framework 'issues' (e.g. mir_test_framework contains
+// a main function).
+TEST(FrameUniformity, average_frame_offset)
+{
+    geom::Size const screen_size{1024, 1024};
+    geom::Point const touch_start_point{0, 0};
+    geom::Point const touch_end_point{1024, 1024};
+    std::chrono::milliseconds touch_duration{1000};
+    
+    int const run_count = 1;
+    double average_lag = 0, average_uniformity = 0;
+
+    for (int i = 0; i < run_count; i++)
+    {
+        FrameUniformityTest t({screen_size, touch_start_point, touch_end_point, touch_duration});
+
+        t.run_test();
+  
+        auto touch_timings = t.server_timings();
+        auto touch_start_time = touch_timings.touch_start;
+        auto touch_end_time = touch_timings.touch_end;
+        auto samples = t.client_results()->get();
+
+        auto results = compute_frame_uniformity(samples, touch_start_point, touch_end_point,
+            touch_start_time, touch_end_time);
+        
+        average_lag += results.average_pixel_offset;
+        average_uniformity += results.frame_uniformity;
+    }
+    
+    average_lag /= run_count;
+    average_uniformity /= run_count;
+    
+    std::cout << "Average pixel lag: " << average_lag << "px" << std::endl;
+    std::cout << "Frame Uniformity (smaller scores are more uniform): " << average_uniformity << "px per sample\n"
+        << std::endl;
+}

=== added file 'benchmarks/frame-uniformity/touch_measuring_client.cpp'
--- benchmarks/frame-uniformity/touch_measuring_client.cpp	1970-01-01 00:00:00 +0000
+++ benchmarks/frame-uniformity/touch_measuring_client.cpp	2014-11-25 17:45:03 +0000
@@ -0,0 +1,115 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#include "touch_measuring_client.h"
+
+#include "mir/time/clock.h"
+
+#include "mir_toolkit/mir_client_library.h"
+
+#include <chrono>
+#include <memory>
+#include <vector>
+
+#include <assert.h>
+
+namespace mt = mir::test;
+
+namespace
+{
+
+MirSurface *create_surface(MirConnection *connection)
+{
+    MirPixelFormat pixel_format;
+    unsigned int valid_formats;
+    mir_connection_get_available_surface_formats(connection, &pixel_format, 1, &valid_formats);
+    MirSurfaceParameters const surface_params = { "frame-uniformity-test",
+        1024, 1024, /* TODO: Ensure fullscreen? */
+        pixel_format,
+        mir_buffer_usage_hardware, 
+        mir_display_output_id_invalid};
+    
+    auto surface = mir_connection_create_surface_sync(connection, &surface_params);
+    assert(mir_surface_is_valid(surface));
+
+    return surface;
+}
+
+void input_callback(MirSurface * /* surface */, MirEvent const* event, void* context)
+{
+    auto results = static_cast<TouchSamples*>(context);
+    
+    results->record_pointer_coordinates(std::chrono::high_resolution_clock::now(), *event);
+}
+
+void collect_input_and_frame_timing(MirSurface *surface, mt::Barrier& client_ready, std::chrono::high_resolution_clock::duration duration, std::shared_ptr<TouchSamples> const& results)
+{
+    MirEventDelegate event_handler = { input_callback, results.get() };
+    mir_surface_set_event_handler(surface, &event_handler);
+    
+    client_ready.ready();
+
+    // May be better if end time were relative to the first input event
+    auto end_time = std::chrono::high_resolution_clock::now() + duration;
+    while (std::chrono::high_resolution_clock::now() < end_time)
+    {
+        mir_surface_swap_buffers_sync(surface);
+        results->record_frame_time(std::chrono::high_resolution_clock::now());
+    }
+}
+
+}
+
+TouchMeasuringClient::TouchMeasuringClient(mt::Barrier& client_ready,
+    std::chrono::high_resolution_clock::duration const& touch_duration)
+    : client_ready(client_ready),
+      touch_duration(touch_duration),
+      results_(std::make_shared<TouchSamples>())
+{
+}
+
+namespace
+{
+void null_lifecycle_callback(MirConnection*, MirLifecycleState, void*)
+{
+}
+}
+
+void TouchMeasuringClient::run(std::string const& connect_string)
+{
+    auto connection = mir_connect_sync(connect_string.c_str(), "frame-uniformity-test");
+    assert(mir_connection_is_valid(connection));
+    
+    /*
+     * Set a null callback to avoid killing the process
+     * (default callback raises SIGHUP).
+     */
+    mir_connection_set_lifecycle_event_callback(connection, null_lifecycle_callback, nullptr);
+    
+    auto surface = create_surface(connection);
+
+    collect_input_and_frame_timing(surface, client_ready, touch_duration, results_);
+    
+    mir_surface_release_sync(surface);
+    mir_connection_release(connection);
+}
+
+std::shared_ptr<TouchSamples> TouchMeasuringClient::results()
+{
+    return results_;
+}

=== added file 'benchmarks/frame-uniformity/touch_measuring_client.h'
--- benchmarks/frame-uniformity/touch_measuring_client.h	1970-01-01 00:00:00 +0000
+++ benchmarks/frame-uniformity/touch_measuring_client.h	2014-11-25 17:45:03 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef TOUCH_MEASURING_CLIENT_H_
+#define TOUCH_MEASURING_CLIENT_H_
+
+#include "touch_samples.h"
+
+#include "mir_test/barrier.h"
+
+#include "mir_toolkit/mir_client_library.h"
+
+#include <chrono>
+#include <memory>
+#include <vector>
+#include <string>
+#include <mutex>
+
+class TouchMeasuringClient
+{
+public:
+    TouchMeasuringClient(mir::test::Barrier& client_ready,
+        std::chrono::high_resolution_clock::duration const& touch_duration);
+    
+    void run(std::string const& connect_string);
+    
+    std::shared_ptr<TouchSamples> results();
+
+private:
+    mir::test::Barrier& client_ready;
+    
+    std::chrono::high_resolution_clock::duration const touch_duration;
+    
+    std::shared_ptr<TouchSamples> results_;
+};
+
+#endif // TOUCH_MEASURING_CLIENT_H_

=== added file 'benchmarks/frame-uniformity/touch_producing_server.cpp'
--- benchmarks/frame-uniformity/touch_producing_server.cpp	1970-01-01 00:00:00 +0000
+++ benchmarks/frame-uniformity/touch_producing_server.cpp	2014-11-25 17:45:03 +0000
@@ -0,0 +1,114 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#include "touch_producing_server.h"
+#include "vsync_simulating_graphics_platform.h"
+
+#include "mir_test/event_factory.h"
+#include "mir_test/fake_event_hub.h"
+
+#include <functional>
+
+namespace mi = mir::input;
+namespace mia = mi::android;
+namespace mg = mir::graphics;
+namespace mis = mi::synthesis;
+namespace geom = mir::geometry;
+namespace mt = mir::test;
+
+namespace mtf = mir_test_framework;
+
+TouchProducingServer::TouchProducingServer(geom::Rectangle screen_dimensions, geom::Point touch_start,
+    geom::Point touch_end, std::chrono::high_resolution_clock::duration touch_duration,
+    mt::Barrier &client_ready)
+    : FakeEventHubServerConfiguration({screen_dimensions}),
+      screen_dimensions(screen_dimensions),
+      touch_start(touch_start),
+      touch_end(touch_end),
+      touch_duration(touch_duration),
+      client_ready(client_ready)
+{
+    input_injection_thread = std::thread(std::mem_fn(&TouchProducingServer::thread_function), this);
+}                                           
+
+TouchProducingServer::~TouchProducingServer()
+{
+    if (input_injection_thread.joinable())
+        input_injection_thread.join();
+}
+
+std::shared_ptr<mg::Platform> TouchProducingServer::the_graphics_platform()
+{
+    // TODO: Support configuration
+    int const refresh_rate_in_hz = 60;
+
+    if (!graphics_platform)
+        graphics_platform = std::make_shared<VsyncSimulatingPlatform>(screen_dimensions.size, refresh_rate_in_hz);
+    
+    return graphics_platform;
+}
+
+void TouchProducingServer::synthesize_event_at(geom::Point const& point)
+{
+    auto const minimum_touch = mia::FakeEventHub::TouchScreenMinAxisValue;
+    auto const maximum_touch = mia::FakeEventHub::TouchScreenMaxAxisValue;
+    auto const display_width = screen_dimensions.size.width.as_int();
+    auto const display_height = screen_dimensions.size.height.as_int();
+    
+    auto px_frac = point.x.as_int() / static_cast<double>(display_width);
+    auto py_frac = point.y.as_int() / static_cast<double>(display_height);
+    auto const abs_touch_x = minimum_touch + (maximum_touch-minimum_touch) * px_frac;
+    auto const abs_touch_y = minimum_touch + (maximum_touch-minimum_touch) * py_frac;
+    
+    fake_event_hub->synthesize_event(
+        mis::a_touch_event().at_position({abs_touch_x, abs_touch_y}));                                      
+}
+
+void TouchProducingServer::thread_function()
+{
+    // We could make the touch sampling rate customizable
+    std::chrono::milliseconds const pause_between_events{10};
+
+    client_ready.ready();
+    
+    auto start = std::chrono::high_resolution_clock::now();
+    auto end = start + touch_duration;
+    auto now = start;
+
+    touch_start_time = std::chrono::high_resolution_clock::time_point::min();
+    while (now < end)
+    {
+        std::this_thread::sleep_for(pause_between_events);
+
+        now = std::chrono::high_resolution_clock::now();
+        if (touch_start_time == std::chrono::high_resolution_clock::time_point::min())
+            touch_start_time = now;
+        touch_end_time = now;
+        
+        double alpha = (now.time_since_epoch().count()-start.time_since_epoch().count()) / static_cast<double>(end.time_since_epoch().count()-start.time_since_epoch().count());
+        auto point = geom::Point{touch_start.x.as_int()+(touch_end.x.as_int()-touch_start.x.as_int())*alpha,
+            touch_start.y.as_int()+(touch_end.y.as_int()-touch_start.y.as_int())*alpha};
+        synthesize_event_at(point);
+    }
+}
+
+TouchProducingServer::TouchTimings
+TouchProducingServer::touch_timings()
+{
+    return {touch_start_time, touch_end_time};
+}

=== added file 'benchmarks/frame-uniformity/touch_producing_server.h'
--- benchmarks/frame-uniformity/touch_producing_server.h	1970-01-01 00:00:00 +0000
+++ benchmarks/frame-uniformity/touch_producing_server.h	2014-11-25 17:45:03 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef TOUCH_PRODUCING_SERVER_H_
+#define TOUCH_PRODUCING_SERVER_H_
+
+#include "mir_test_framework/fake_event_hub_server_configuration.h"
+#include "mir_test/barrier.h"
+
+#include "mir/geometry/rectangle.h"
+#include "mir/geometry/point.h"
+
+#include <thread>
+
+class TouchProducingServer : public mir_test_framework::FakeEventHubServerConfiguration
+{
+public:
+    TouchProducingServer(mir::geometry::Rectangle screen_dimensions, mir::geometry::Point touch_start, mir::geometry::Point touch_end, std::chrono::high_resolution_clock::duration touch_duration, mir::test::Barrier& client_ready);
+    
+    struct TouchTimings {
+        std::chrono::high_resolution_clock::time_point touch_start;
+        std::chrono::high_resolution_clock::time_point touch_end;
+    };
+    TouchTimings touch_timings();
+    
+    std::shared_ptr<mir::graphics::Platform> the_graphics_platform() override;
+
+    ~TouchProducingServer();    
+private:
+    mir::geometry::Rectangle const screen_dimensions;
+
+    mir::geometry::Point const touch_start;
+    mir::geometry::Point const touch_end;
+    std::chrono::high_resolution_clock::duration const touch_duration;
+
+    mir::test::Barrier& client_ready;
+    
+    std::thread input_injection_thread;
+    
+    std::chrono::high_resolution_clock::time_point touch_start_time;
+    std::chrono::high_resolution_clock::time_point touch_end_time;
+    
+    std::shared_ptr<mir::graphics::Platform> graphics_platform;
+    
+    void synthesize_event_at(mir::geometry::Point const& point);
+    void thread_function();
+};
+
+#endif

=== added file 'benchmarks/frame-uniformity/touch_samples.cpp'
--- benchmarks/frame-uniformity/touch_samples.cpp	1970-01-01 00:00:00 +0000
+++ benchmarks/frame-uniformity/touch_samples.cpp	2014-11-25 17:45:03 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#include "touch_samples.h"
+
+void TouchSamples::record_frame_time(std::chrono::high_resolution_clock::time_point time)
+{
+    std::unique_lock<std::mutex> lg(guard);
+    for (auto& sample: samples_being_prepared)
+    {
+        sample.frame_time = time;
+        completed_samples.push_back(sample);
+    }
+    samples_being_prepared.clear();
+}
+    
+void TouchSamples::record_pointer_coordinates(std::chrono::high_resolution_clock::time_point reception_time,
+    MirEvent const& event)
+{
+    std::unique_lock<std::mutex> lg(guard);
+
+    if (event.type != mir_event_type_motion)
+        return;
+    
+    auto const& mev = event.motion;
+    if (mev.action != mir_motion_action_down &&
+        mev.action != mir_motion_action_up &&
+        mev.action != mir_motion_action_move)
+    {
+        return;
+    }
+    // We could support multitouch, etc...
+    auto const& coordinates = mev.pointer_coordinates[0];
+
+    // TODO: Record both event time and reception time
+    samples_being_prepared.push_back(Sample{coordinates.x, coordinates.y, reception_time, {}});
+}
+
+std::vector<TouchSamples::Sample> TouchSamples::get()
+{
+    return completed_samples;
+}

=== added file 'benchmarks/frame-uniformity/touch_samples.h'
--- benchmarks/frame-uniformity/touch_samples.h	1970-01-01 00:00:00 +0000
+++ benchmarks/frame-uniformity/touch_samples.h	2014-11-25 17:45:03 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef TOUCH_SAMPLES_H_
+#define TOUCH_SAMPLES_H_
+
+#include <vector>
+#include <chrono>
+#include <mutex>
+
+#include <mir_toolkit/event.h>
+
+class TouchSamples
+{
+public:
+    TouchSamples() = default;
+    ~TouchSamples() = default;
+    
+    // A touch sample
+    struct Sample
+    {
+        // Coordinates of the touch
+        float x,y;
+        // Time at which the event left the input device
+        std::chrono::high_resolution_clock::time_point event_time;
+        // Submission time of first frame after receipt of event, e.g.
+        // the earliest the event could potentially arrive onscreen.
+        std::chrono::high_resolution_clock::time_point frame_time;
+    };
+    std::vector<Sample> get();
+        
+    void record_frame_time(std::chrono::high_resolution_clock::time_point time);
+    void record_pointer_coordinates(std::chrono::high_resolution_clock::time_point reception_time,
+                                    MirEvent const& ev);
+private:
+    std::mutex guard;
+
+    // In between frames we will accumulate partially completed samples (lacking frame time)
+    // in the "samples_being_prepared" collection. At each frame time we will move them to
+    // the completed samples collection.
+    std::vector<Sample> samples_being_prepared;
+    std::vector<Sample> completed_samples;
+};
+
+#endif // TOUCH_SAMPLES_H_

=== added file 'benchmarks/frame-uniformity/vsync_simulating_graphics_platform.cpp'
--- benchmarks/frame-uniformity/vsync_simulating_graphics_platform.cpp	1970-01-01 00:00:00 +0000
+++ benchmarks/frame-uniformity/vsync_simulating_graphics_platform.cpp	2014-11-25 17:45:03 +0000
@@ -0,0 +1,145 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#include "vsync_simulating_graphics_platform.h"
+
+#include "mir/graphics/buffer_writer.h"
+#include "mir/graphics/platform_ipc_operations.h"
+#include "mir/graphics/platform_ipc_package.h"
+
+#include "mir_test_doubles/stub_buffer_allocator.h"
+#include "mir_test_doubles/stub_display.h"
+
+#include <chrono>
+#include <functional>
+
+namespace mg = mir::graphics;
+namespace geom = mir::geometry;
+
+namespace mtd = mir::test::doubles;
+
+namespace
+{
+
+struct StubBufferWriter : public mg::BufferWriter
+{
+    void write(mg::Buffer&, unsigned char const*, size_t) override
+    {
+    }
+};
+
+class StubIpcOps : public mg::PlatformIpcOperations
+{
+    void pack_buffer(
+        mg::BufferIpcMessage&,
+        mg::Buffer const&,
+        mg::BufferIpcMsgType) const override
+    {
+    }
+
+    void unpack_buffer(
+        mg::BufferIpcMessage&, mg::Buffer const&) const override
+    {
+    }
+
+    std::shared_ptr<mg::PlatformIPCPackage> connection_ipc_package() override
+    {
+        return std::make_shared<mg::PlatformIPCPackage>();
+    }
+
+    mg::PlatformIPCPackage platform_operation(unsigned int const, mg::PlatformIPCPackage const&) override
+    {
+        return mg::PlatformIPCPackage();
+    }
+};
+
+struct StubDisplayBuffer : mtd::StubDisplayBuffer
+{
+    StubDisplayBuffer(geom::Size output_size, int vsync_rate_in_hz)
+        : mtd::StubDisplayBuffer({{0, 0}, output_size}),
+          vsync_rate_in_hz(vsync_rate_in_hz),
+          last_sync(std::chrono::high_resolution_clock::now())
+    {
+    }
+    
+    void post_update() override
+    {
+        auto now = std::chrono::high_resolution_clock::now();
+        auto next_sync = last_sync + std::chrono::seconds(1) / vsync_rate_in_hz;
+        
+        if (now < next_sync)
+            std::this_thread::sleep_for(next_sync - now);
+        
+        last_sync = now;
+    }
+    
+    double const vsync_rate_in_hz;
+
+    std::chrono::high_resolution_clock::time_point last_sync;
+};
+
+struct StubDisplay : public mtd::StubDisplay
+{
+    StubDisplay(geom::Size output_size, int vsync_rate_in_hz)
+        : mtd::StubDisplay({{{0,0}, output_size}}),
+          buffer(output_size, vsync_rate_in_hz)
+    {
+    }
+    
+    void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& exec) override
+    {
+        exec(buffer);
+    }
+
+    StubDisplayBuffer buffer;
+};
+
+}
+
+VsyncSimulatingPlatform::VsyncSimulatingPlatform(geom::Size const& output_size, int vsync_rate_in_hz)
+    : display(std::make_shared<StubDisplay>(output_size, vsync_rate_in_hz))
+{
+}
+
+std::shared_ptr<mg::GraphicBufferAllocator> VsyncSimulatingPlatform::create_buffer_allocator()
+{
+    return std::make_shared<mtd::StubBufferAllocator>();
+}
+
+std::shared_ptr<mg::BufferWriter> VsyncSimulatingPlatform::make_buffer_writer()
+{
+    return std::make_shared<StubBufferWriter>();
+}
+    
+std::shared_ptr<mg::Display> VsyncSimulatingPlatform::create_display(
+    std::shared_ptr<mg::DisplayConfigurationPolicy> const&,
+    std::shared_ptr<mg::GLProgramFactory> const&,
+     std::shared_ptr<mg::GLConfig> const&)
+{
+    return display;
+}
+    
+std::shared_ptr<mg::PlatformIpcOperations> VsyncSimulatingPlatform::make_ipc_operations() const
+{
+    return std::make_shared<StubIpcOps>();
+}
+
+std::shared_ptr<mg::InternalClient> VsyncSimulatingPlatform::create_internal_client()
+{
+    return nullptr;
+}

=== added file 'benchmarks/frame-uniformity/vsync_simulating_graphics_platform.h'
--- benchmarks/frame-uniformity/vsync_simulating_graphics_platform.h	1970-01-01 00:00:00 +0000
+++ benchmarks/frame-uniformity/vsync_simulating_graphics_platform.h	2014-11-25 17:45:03 +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: Robert Carr <[e-mail]>
+ */
+
+#ifndef VSYNC_SIMULATING_GRAPHICS_PLATFORM_H_
+#define VSYNC_SIMULATING_GRAPHICS_PLATFORM_H_
+
+#include "mir/graphics/platform.h"
+#include "mir/geometry/rectangle.h"
+
+#include "mir_test_doubles/null_platform.h"
+
+class VsyncSimulatingPlatform : public mir::test::doubles::NullPlatform
+{
+public:
+    VsyncSimulatingPlatform(mir::geometry::Size const& output_size, int vsync_rate_in_hz);
+    ~VsyncSimulatingPlatform() = default;
+    
+    std::shared_ptr<mir::graphics::GraphicBufferAllocator> create_buffer_allocator();
+    std::shared_ptr<mir::graphics::BufferWriter> make_buffer_writer();
+    
+    std::shared_ptr<mir::graphics::Display> create_display(
+        std::shared_ptr<mir::graphics::DisplayConfigurationPolicy> const& initial_conf_policy,
+        std::shared_ptr<mir::graphics::GLProgramFactory> const& gl_program_factory,
+        std::shared_ptr<mir::graphics::GLConfig> const& gl_config);
+    
+    std::shared_ptr<mir::graphics::PlatformIpcOperations> make_ipc_operations() const;
+    std::shared_ptr<mir::graphics::InternalClient> create_internal_client();
+
+private:
+    std::shared_ptr<mir::graphics::Display> display;
+};
+
+#endif // VSYNC_SIMULATING_GRAPHICS_PLATFORM_H_

=== modified file 'client-ABI-sha1sums'
--- client-ABI-sha1sums	2014-09-30 06:11:33 +0000
+++ client-ABI-sha1sums	2014-11-25 17:45:03 +0000
@@ -1,16 +1,15 @@
-b64b3ca16e4130c838bdca248189f8055804c849  include/client/mir/client/private.h
-cbe1e3ccfea6ab5865510f4f598ec11571fcc852  include/client/mir_toolkit/mir_client_library_debug.h
+afd66e984f4f8c0303fd25fb6fea32fa47bbd37f  include/client/mir_toolkit/debug/surface.h
 b53736bcb22ddc09aab8275cfdd05c109fdd0f12  include/client/mir_toolkit/mir_client_library_drm.h
 1522a5fcdb01c0d9a990364539c4f1255853eef7  include/client/mir_toolkit/mir_client_library.h
-e6185b680533c5fdcf1294a4797d5c3dd01d433f  include/client/mir_toolkit/mir_connection.h
+626fbcc008539c5f1713d8f6eef8c2acc4929af9  include/client/mir_toolkit/mir_connection.h
 1ef8f51a3e3f8d1559266c5af58fbfde7cfabf0a  include/client/mir_toolkit/mir_cursor_configuration.h
-6ff12425fed19f2a5aa37390904c14ff6a647bcd  include/client/mir_toolkit/mir_prompt_session.h
+9d50df5a141ca03ee8a79f7e844ed4b8b3b7d5d3  include/client/mir_toolkit/mir_prompt_session.h
 21d07e655e85eeec8a3523e1c6f9c2252176ec01  include/client/mir_toolkit/mir_screencast.h
-8609754db3be20e11e43858dd2c36b5bd480d5ec  include/client/mir_toolkit/mir_surface.h
+4f85e3d00314a7df869e56c3701a45310909fae2  include/client/mir_toolkit/mir_surface.h
 b141c4d79802ad626d969249c0004744e5c2a525  include/client/mir_toolkit/mir_wait.h
 9907751d046e4aea81881cf19e5df52c7a6a813e  include/common/mir_toolkit/client_types.h
-183d9e5e6cfe48b3d9145a28541dd4202ff6137b  include/common/mir_toolkit/common.h
+2100c0674d9d882c1845550847357f6a5de5af66  include/common/mir_toolkit/common.h
 fce4c1a9e0d037244f7e9e96ea2d8eaab4fc404c  include/common/mir_toolkit/cursors.h
 bdaceadd56e41d2cb708f7c4da97acf84dfc75b7  include/common/mir_toolkit/event.h
-99ef5f3bf548508fae24c60f74be1dea018a6e8c  include/common/mir_toolkit/mesa/native_display.h
+4975998aa1056ed0d39dcc538127453e516ad8e9  include/common/mir_toolkit/mesa/native_display.h
 101017c17714a57db57d79b7b5e7df40a3568236  include/common/mir_toolkit/mir_native_buffer.h

=== modified file 'cmake/ABICheck.cmake'
--- cmake/ABICheck.cmake	2014-10-03 03:02:09 +0000
+++ cmake/ABICheck.cmake	2014-11-25 17:45:03 +0000
@@ -39,6 +39,10 @@
     ${private_headers}"
   )
 
+  if (NOT ${CMAKE_MAJOR_VERSION} LESS 3)
+    cmake_policy(SET CMP0026 OLD)
+  endif()
+  # TODO: Deprecate use of "LOCATION" (CMP0026) ...
   if ("${ABI_DUMP_PREBUILT_LIBDIR}" STREQUAL "")
     get_property(LIB_DESC_LIBS TARGET ${libname} PROPERTY LOCATION)
   else()

=== modified file 'cmake/MirCommon.cmake'
--- cmake/MirCommon.cmake	2014-09-30 06:11:33 +0000
+++ cmake/MirCommon.cmake	2014-11-25 17:45:03 +0000
@@ -43,7 +43,22 @@
 
 function (mir_discover_tests EXECUTABLE)
   if(DISABLE_GTEST_TEST_DISCOVERY)
-    add_test(${EXECUTABLE} ${VALGRIND_EXECUTABLE} ${VALGRIND_ARGS} ${EXECUTABLE_OUTPUT_PATH}/${EXECUTABLE} "--gtest_filter=-*DeathTest.*")
+    execute_process(
+      COMMAND uname -r
+      OUTPUT_VARIABLE KERNEL_VERSION_FULL
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    string(REGEX MATCH "^[0-9]+[.][0-9]+" KERNEL_VERSION ${KERNEL_VERSION_FULL})
+    message(STATUS "Kernel version detected: " ${KERNEL_VERSION})
+    # Some tests expect kernel version 3.11 and up
+    if (${KERNEL_VERSION} VERSION_LESS "3.11")
+        add_test(${EXECUTABLE} ${VALGRIND_EXECUTABLE} ${VALGRIND_ARGS} ${EXECUTABLE_OUTPUT_PATH}/${EXECUTABLE}
+            "--gtest_filter=-*DeathTest.*:AnonymousShmFile.*:MesaBufferAllocatorTest.software_buffers_dont_bypass:MesaBufferAllocatorTest.creates_software_rendering_buffer")
+    else()
+        add_test(${EXECUTABLE} ${VALGRIND_EXECUTABLE} ${VALGRIND_ARGS} ${EXECUTABLE_OUTPUT_PATH}/${EXECUTABLE}
+            "--gtest_filter=-*DeathTest.*")
+    endif()
+
     add_test(${EXECUTABLE}_death_tests ${EXECUTABLE_OUTPUT_PATH}/${EXECUTABLE} "--gtest_filter=*DeathTest.*")
     if (${ARGC} GREATER 1)
       set_property(TEST ${EXECUTABLE} PROPERTY ENVIRONMENT ${ARGN})

=== modified file 'cmake/src/mir/mir_discover_gtest_tests.cpp'
--- cmake/src/mir/mir_discover_gtest_tests.cpp	2014-09-11 05:51:44 +0000
+++ cmake/src/mir/mir_discover_gtest_tests.cpp	2014-11-25 17:45:03 +0000
@@ -16,6 +16,11 @@
 #include <getopt.h>
 #include <sys/ioctl.h>
 #include <unistd.h>
+#ifndef _GNU_SOURCE
+// Needed for O_TMPFILE
+#define _GNU_SOURCE
+#endif
+#include <fcntl.h>
 
 using namespace std;
 
@@ -302,9 +307,19 @@
         {
             testfilecmake << "SET( ENV{"<<env_pair.first<<"} \""<<env_pair.second<<"\" )"<<std::endl;
         }
+
+        int ret = open("/dev/shm", O_TMPFILE | O_RDWR | O_EXCL, S_IRWXU);
+        bool kernel_supports_O_TMPFILE = (ret != -1);
+        if (kernel_supports_O_TMPFILE) close(ret);
+
         for (auto test = tests.begin(); test != tests.end(); ++ test)
         {
             static char cmd_line[1024] = "";
+
+            // Don't run AnonymousShmFile.* tests on older kernels
+            if (!kernel_supports_O_TMPFILE && *test == "AnonymousShmFile.*")
+            	continue;
+
             snprintf(
                 cmd_line,
                 sizeof(cmd_line),
@@ -314,7 +329,10 @@
                 test_suite.c_str(),
                 elide_string_left(*test, output_width/2).c_str(),
                 config.executable,
-                test->c_str());
+                // Don't run MesaBufferAllocatorTest.{software_buffers_dont_bypass|creates_software_rendering_buffer} tests on older kernels
+                ((*test == "MesaBufferAllocatorTest.*") && !kernel_supports_O_TMPFILE)
+                    ? "MesaBufferAllocatorTest.*:-MesaBufferAllocatorTest.software_buffers_dont_bypass:MesaBufferAllocatorTest.creates_software_rendering_buffer"
+                    : test->c_str());
 
             if (testfilecmake.good())
             {

=== modified file 'common-ABI-sha1sums'
--- common-ABI-sha1sums	2014-09-30 06:11:33 +0000
+++ common-ABI-sha1sums	2014-11-25 17:45:03 +0000
@@ -9,10 +9,10 @@
 dcf8b8982f138bdde39a241825c610e955cd5e33  include/common/mir/input/input_platform.h
 208cd6aed5ef5f8f39b3eb86604e4133cb840485  include/common/mir/input/input_receiver_thread.h
 be7d58c9fde2ce91cc66dd6144b76e08b536266b  include/common/mir/int_wrapper.h
-48015c67ddc4998ed5a2e8bb04ff3a4bfdd6a613  include/common/mir/time/clock.h
+9ae8473df05dd9e048a73797f01a2f34f7447554  include/common/mir/time/types.h
 9907751d046e4aea81881cf19e5df52c7a6a813e  include/common/mir_toolkit/client_types.h
-183d9e5e6cfe48b3d9145a28541dd4202ff6137b  include/common/mir_toolkit/common.h
+2100c0674d9d882c1845550847357f6a5de5af66  include/common/mir_toolkit/common.h
 fce4c1a9e0d037244f7e9e96ea2d8eaab4fc404c  include/common/mir_toolkit/cursors.h
 bdaceadd56e41d2cb708f7c4da97acf84dfc75b7  include/common/mir_toolkit/event.h
-99ef5f3bf548508fae24c60f74be1dea018a6e8c  include/common/mir_toolkit/mesa/native_display.h
+4975998aa1056ed0d39dcc538127453e516ad8e9  include/common/mir_toolkit/mesa/native_display.h
 101017c17714a57db57d79b7b5e7df40a3568236  include/common/mir_toolkit/mir_native_buffer.h

=== modified file 'debian/changelog'
--- debian/changelog	2014-10-10 14:01:27 +0000
+++ debian/changelog	2014-11-25 17:45:03 +0000
@@ -1,3 +1,57 @@
+mir (0.9.0) UNRELEASED; urgency=medium
+
+  * New upstream release 0.9.0 (https://launchpad.net/mir/+milestone/0.9.0)
+    - Enhancements:
+      . New simpler API to configure and run a mir server.
+      . The event loop is now based on GLib's main loop library instead of
+        Boost.Asio.
+      . For Android platforms, the server now sends buffer fence fds to its
+        clients instead of potentially stalling the compositor thread waiting
+        for them to be signalled.
+      . New client debug interface to translate from surface to screen
+        coordinates.
+    - ABI summary: Servers need rebuilding, but clients do not;
+      . Mirclient ABI unchanged at 8
+      . Mircommon ABI bumped to 3
+      . Mirplatform ABI bumped to 4
+      . Mirserver ABI bumped to 27
+    - Bug fixes:
+      . Add a debug interface to translate from surface to screen coordinates
+        (LP: #1346633)
+      . Ensure a buffer requested by a surface is not delivered 
+        after the surface is deleted (LP: #1376324)
+      . Overlays are not displayed onscreen in some positions (LP: #1378326)
+      . Server aborts when an exception is thrown from the main thread
+        (LP: #1378740)
+      . Fix race causing lost alarm notifications (LP: #1381925)
+      . Avoid lifecycle notifications racing with connection release
+        (LP: #1386646)
+      . Improve error checking and reporting for the client library
+       (LP: #1390388)
+      . Mir demo-shell now detects power button using proper Linux scan codes
+       (LP: #1303817)
+      . A prompt session with an invalid application pid should be an error
+        (LP: #1377968)
+      . When XDG_RUNTIME_DIR is defined but pointing to a non-existing 
+        directory use "/tmp" (LP: #1304873)
+      . [regression] demo-shell bypass is not used on fullscreen surfaces if 
+        there are windowed surfaces behind (LP: #1378706)
+      . Mir upgrade through dist-upgrade installs incorrect platform
+        (LP: #1378995)
+      . Fix Mir progressbar example using internal glibc defines(LP: #239272)
+      . Stop the default_lifecycle_event_handler raising SIGHUP while 
+        disconnecting (LP: #1386185)
+      . [regression] Mir fails to build with MIR_ENABLE_TESTS=OFF (LP: #1388539)
+      . [regression] mir_demo_server_basic does not start (LP: #1391923)
+
+ -- Alberto Aguirre <[e-mail]>  Thu, 20 Nov 2014 10:04:54 -0600
+
+mir (0.8.0+14.10.20141010-0ubuntu2) vivid; urgency=medium
+
+  * No change rebuild to get debug symbols on all architectures.
+
+ -- Brian Murray <[e-mail]>  Wed, 19 Nov 2014 11:33:10 -0800
+
 mir (0.8.0+14.10.20141010-0ubuntu1) utopic; urgency=medium
 
   [ Daniel van Vugt ]

=== modified file 'debian/control'
--- debian/control	2014-10-01 03:41:21 +0000
+++ debian/control	2014-11-25 17:45:03 +0000
@@ -35,31 +35,46 @@
                liblttng-ust-dev,
                libxkbcommon-dev,
                libumockdev-dev (>= 0.6),
-               umockdev,
+               umockdev (>= 0.8.7),
                libudev-dev,
                google-mock (>= 1.6.0+svn437),
                valgrind [!arm64],
+               libglib2.0-dev,
 Standards-Version: 3.9.4
 Homepage: https://launchpad.net/mir
 # If you aren't a member of ~mir-team but need to upload packaging changes,
 # just go ahead. ~mir-team will notice and sync up the code again.
 Vcs-Bzr: https://code.launchpad.net/~mir-team/mir/trunk
 
-Package: libmirserver26
-Section: libs
-Architecture: i386 amd64 armhf arm64
-Multi-Arch: same
-Pre-Depends: ${misc:Pre-Depends}
-Depends: ${misc:Depends},
-         ${shlibs:Depends},
-         libmirplatform3driver-mesa | libmirplatform3driver-android,
+Package: libmirprotobuf0
+Section: libs
+Architecture: i386 amd64 armhf arm64
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends}
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+Description: Display server for Ubuntu - RPC definitions
+ Mir is a display server running on linux systems, with a focus on efficiency,
+ robust operation and a well-defined driver model.
+ .
+ Contains the shared library containing the Google Protobuf definitions
+ required for Mir clients and servers.
+
+Package: libmirserver27
+Section: libs
+Architecture: i386 amd64 armhf arm64
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends}
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+         libmir${platform-driver}-mesa | libmir${platform-driver}-android,
 Description: Display server for Ubuntu - server library
  Mir is a display server running on linux systems, with a focus on efficiency,
  robust operation and a well-defined driver model.
  .
  Contains the shared library needed by server applications for Mir.
 
-Package: libmirplatform3
+Package: libmirplatform4
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
@@ -73,40 +88,12 @@
  Contains the shared libraries required for the Mir server to interact with
  the underlying hardware platform.
 
-Package: libmirplatform3driver-mesa
-Section: libs
-Architecture: i386 amd64 armhf arm64
-Multi-Arch: same
-Pre-Depends: ${misc:Pre-Depends}
-Depends: ${misc:Depends},
-         ${shlibs:Depends},
-Description: Display server for Ubuntu - platform library for Mesa
- Mir is a display server running on linux systems, with a focus on efficiency,
- robust operation and a well-defined driver model.
- .
- Contains the shared libraries required for the Mir server to interact with
- the hardware platform using the Mesa drivers.
-
-Package: libmirplatform3driver-android
-Section: libs
-Architecture: i386 amd64 armhf
-Multi-Arch: same
-Pre-Depends: ${misc:Pre-Depends}
-Depends: ${misc:Depends},
-         ${shlibs:Depends},
-Description: Display server for Ubuntu - platform library for Android
- Mir is a display server running on linux systems, with a focus on efficiency,
- robust operation and a well-defined driver model.
- .
- Contains the shared libraries required for the Mir server to interact with
- the hardware platform using the Android drivers.
-
 Package: libmircommon-dev
 Section: libdevel
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmircommon2 (= ${binary:Version}), 
+Depends: libmircommon3 (= ${binary:Version}), 
          libprotobuf-dev (>= 2.4.1),
          ${misc:Depends},
 Breaks: mircommon-dev (<< 0.6)
@@ -122,7 +109,7 @@
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmirplatform3 (= ${binary:Version}), 
+Depends: libmirplatform4 (= ${binary:Version}), 
          libmircommon-dev,
          libboost-program-options-dev,
          ${misc:Depends},
@@ -139,7 +126,7 @@
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmirserver26 (= ${binary:Version}),
+Depends: libmirserver27 (= ${binary:Version}),
          libmirplatform-dev (= ${binary:Version}),
          libmircommon-dev (= ${binary:Version}),
          libglm-dev,
@@ -157,7 +144,7 @@
 Pre-Depends: ${misc:Pre-Depends}
 Depends: ${misc:Depends},
          ${shlibs:Depends},
-         libmirclient8driver-mesa | libmirclient8driver-android,
+         libmir${client-driver}-mesa | libmir${client-driver}-android,
 Description: Display server for Ubuntu - client library
  Mir is a display server running on linux systems, with a focus on efficiency,
  robust operation and a well-defined driver model.
@@ -179,33 +166,51 @@
  .
  Contains header files required to develop against Mir.
 
-Package: libmirclient8driver-mesa
+Package: libmirclient-debug-extension1
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
 Depends: ${misc:Depends},
-         ${shlibs:Depends}
-Description: Display server for Ubuntu - client platform library for Mesa
+         ${shlibs:Depends},
+Description: Display server for Ubuntu - optional client debug interfaces
  Mir is a display server running on linux systems, with a focus on efficiency,
  robust operation and a well-defined driver model.
  .
- Contains the shared libraries required for the Mir clients to interact with
- the underlying hardware platform using the Mesa drivers.
+ This package contains both a shared library containing the client side of
+ various optional debugging interfaces and the development headers required
+ to use them.
+ .
+ This is primarily useful for developing Mir servers, low-level client
+ toolkits, or for automated testing in constrained environments.
+ .
+ Not all Mir servers have the capability to service these APIs; end-user
+ applications SHOULD NOT depend on this library.
 
-Package: libmirclient8driver-android
-Section: libs
-Architecture: i386 amd64 armhf
+Package: libmirclient-debug-extension-dev
+Section: libdevel
+Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: ${misc:Depends},
-         ${shlibs:Depends}
-Description: Display server for Ubuntu - client platform library for Android
+Depends: libmirclient-debug-extension1 (= ${binary:Version}),
+	 ${misc:Depends},
+         ${shlibs:Depends},
+Description: Display server for Ubuntu - client debug interface headers
  Mir is a display server running on linux systems, with a focus on efficiency,
  robust operation and a well-defined driver model.
  .
- Contains the shared libraries required for the Mir clients to interact with
- the underlying hardware platform using the Android drivers.
+ This package contains both a shared library containing the client side of
+ various optional debugging interfaces and the development headers required
+ to use them.
+ .
+ This is primarily useful for developing Mir servers, low-level client
+ toolkits, or for automated testing in constrained environments.
+ .
+ Not all Mir servers have the capability to service these APIs; end-user
+ applications SHOULD NOT depend on this library.
+ .
+ This package contains the development headers required to develop against
+ the debug extensions.
 
 Package: mir-demos
 Architecture: i386 amd64 armhf arm64
@@ -247,7 +252,7 @@
  .
  Contains a tool for stress testing the Mir display server
 
-Package: libmircommon2
+Package: libmircommon3
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
@@ -259,3 +264,90 @@
  robust operation and a well-defined driver model.
  .
  Contains the shared libraries required for the Mir server and client.
+
+# Longer-term these drivers should move out-of-tree
+Package: libmirclient8driver-mesa
+Section: libs
+Architecture: i386 amd64 armhf arm64
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends}
+Depends: ${misc:Depends},
+         ${shlibs:Depends}
+Description: Display server for Ubuntu - client platform library for Mesa
+ Mir is a display server running on linux systems, with a focus on efficiency,
+ robust operation and a well-defined driver model.
+ .
+ Contains the shared libraries required for the Mir clients to interact with
+ the underlying hardware platform using the Mesa drivers.
+
+Package: libmirclient8driver-android
+Section: libs
+Architecture: i386 amd64 armhf
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends}
+Depends: ${misc:Depends},
+         ${shlibs:Depends}
+Description: Display server for Ubuntu - client platform library for Android
+ Mir is a display server running on linux systems, with a focus on efficiency,
+ robust operation and a well-defined driver model.
+ .
+ Contains the shared libraries required for the Mir clients to interact with
+ the underlying hardware platform using the Android drivers.
+
+Package: libmirplatform4driver-mesa
+Section: libs
+Architecture: i386 amd64 armhf arm64
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends}
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+Description: Display server for Ubuntu - platform library for Mesa
+ Mir is a display server running on linux systems, with a focus on efficiency,
+ robust operation and a well-defined driver model.
+ .
+ Contains the shared libraries required for the Mir server to interact with
+ the hardware platform using the Mesa drivers.
+
+Package: libmirplatform4driver-android
+Section: libs
+Architecture: i386 amd64 armhf
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends}
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+Description: Display server for Ubuntu - platform library for Android
+ Mir is a display server running on linux systems, with a focus on efficiency,
+ robust operation and a well-defined driver model.
+ .
+ Contains the shared libraries required for the Mir server to interact with
+ the hardware platform using the Android drivers.
+
+Package: mir-graphics-drivers-desktop
+Section: libs
+Architecture: i386 amd64 armhf arm64
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends}
+Depends: ${misc:Depends},
+         libmir${platform-driver}-mesa,
+         libmir${client-driver}-mesa
+Description: Display server for Ubuntu - desktop driver metapackage
+ Mir is a display server running on linux systems, with a focus on efficiency,
+ robust operation and a well-defined driver model.
+ .
+ This package depends on a full set of graphics drivers for traditional desktop
+ systems.
+
+Package: mir-graphics-drivers-android
+Section: libs
+Architecture: i386 amd64 armhf
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends}
+Depends: ${misc:Depends},
+         libmir${platform-driver}-android,
+         libmir${client-driver}-android
+Description: Display server for Ubuntu - android driver metapackage
+ Mir is a display server running on linux systems, with a focus on efficiency,
+ robust operation and a well-defined driver model.
+ .
+ This package depends on a full set of graphics drivers for running Mir on top
+ of an existing Android driver stack.

=== added file 'debian/libmirclient-debug-extension-dev.install'
--- debian/libmirclient-debug-extension-dev.install	1970-01-01 00:00:00 +0000
+++ debian/libmirclient-debug-extension-dev.install	2014-11-25 17:45:03 +0000
@@ -0,0 +1,3 @@
+usr/include/mirclient/mir_toolkit/debug
+usr/lib/*/pkgconfig/mirclient-debug-extension.pc
+usr/lib/*/libmirclient-debug-extension.so

=== added file 'debian/libmirclient-debug-extension1.install'
--- debian/libmirclient-debug-extension1.install	1970-01-01 00:00:00 +0000
+++ debian/libmirclient-debug-extension1.install	2014-11-25 17:45:03 +0000
@@ -0,0 +1,1 @@
+usr/lib/*/libmirclient-debug-extension.so.*

=== modified file 'debian/libmirclient-dev.install'
--- debian/libmirclient-dev.install	2013-06-24 12:15:28 +0000
+++ debian/libmirclient-dev.install	2014-11-25 17:45:03 +0000
@@ -1,3 +1,3 @@
-usr/include/mirclient
+usr/include/mirclient/mir_toolkit/*.h
 usr/lib/*/pkgconfig/mirclient.pc
 usr/lib/*/libmirclient.so

=== renamed file 'debian/libmircommon2.install' => 'debian/libmircommon3.install'
--- debian/libmircommon2.install	2014-09-30 06:11:33 +0000
+++ debian/libmircommon3.install	2014-11-25 17:45:03 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmircommon.so.2
+usr/lib/*/libmircommon.so.3

=== renamed file 'debian/libmirplatform3.install' => 'debian/libmirplatform4.install'
--- debian/libmirplatform3.install	2014-09-30 06:11:33 +0000
+++ debian/libmirplatform4.install	2014-11-25 17:45:03 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirplatform.so.3
+usr/lib/*/libmirplatform.so.4

=== renamed file 'debian/libmirplatform3driver-android.install' => 'debian/libmirplatform4driver-android.install'
=== renamed file 'debian/libmirplatform3driver-mesa.install' => 'debian/libmirplatform4driver-mesa.install'
=== added file 'debian/libmirprotobuf0.install'
--- debian/libmirprotobuf0.install	1970-01-01 00:00:00 +0000
+++ debian/libmirprotobuf0.install	2014-11-25 17:45:03 +0000
@@ -0,0 +1,1 @@
+usr/lib/*/libmirprotobuf.so.0

=== renamed file 'debian/libmirserver26.install' => 'debian/libmirserver27.install'
--- debian/libmirserver26.install	2014-09-30 06:11:33 +0000
+++ debian/libmirserver27.install	2014-11-25 17:45:03 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirserver.so.26
+usr/lib/*/libmirserver.so.27

=== modified file 'debian/mir-test-tools.install'
--- debian/mir-test-tools.install	2014-09-11 05:51:44 +0000
+++ debian/mir-test-tools.install	2014-11-25 17:45:03 +0000
@@ -5,3 +5,4 @@
 usr/bin/mir_performance_tests
 usr/lib/*/mir/tools/libmirclientlttng.so
 usr/lib/*/mir/tools/libmirserverlttng.so
+usr/lib/*/libmirplatformstub.so

=== modified file 'debian/rules'
--- debian/rules	2014-09-30 06:11:33 +0000
+++ debian/rules	2014-11-25 17:45:03 +0000
@@ -13,7 +13,7 @@
 export CC=$(DEB_HOST_GNU_TYPE)-gcc-4.9
 export CXX=$(DEB_HOST_GNU_TYPE)-g++-4.9
 
-export PLATFORM_DRIVER = platform3driver
+export PLATFORM_DRIVER = platform4driver
 export CLIENT_DRIVER = client8driver
 
 %:
@@ -51,6 +51,10 @@
 	dh_makeshlibs -V
 
 override_dh_install:
+# Nothing outside Mir should link to libmirprotobuf directly.
+# Delete the symlink so that --fail-missing doesn't think we've missed it
+# accidentally.
+	rm debian/tmp/usr/lib/*/libmirprotobuf.so
 	dh_install --fail-missing \
 	  -Xusr/lib/$(DEB_HOST_MULTIARCH)/libmir$(PLATFORM_DRIVER).so \
 	  -Xusr/lib/$(DEB_HOST_MULTIARCH)/libmir$(CLIENT_DRIVER).so
@@ -60,3 +64,8 @@
 	sh debian/create_postinst_prerm_scripts.sh \
 	  $(DEB_HOST_ARCH) $(DEB_HOST_MULTIARCH)
 	dh_installdeb
+
+override_dh_gencontrol:
+	dh_gencontrol -- \
+		-Vplatform-driver=$(PLATFORM_DRIVER) \
+		-Vclient-driver=$(CLIENT_DRIVER)

=== modified file 'doc/building_source_for_android.md'
--- doc/building_source_for_android.md	2014-09-11 05:51:44 +0000
+++ doc/building_source_for_android.md	2014-11-25 17:45:03 +0000
@@ -54,13 +54,13 @@
 Initial setup of a desktop machine for cross-compiling to armhf is simple:
 
     $ sudo apt-get install g++-arm-linux-gnueabihf debootstrap
-    $ sudo sh -c 'echo "deb [arch=armhf] http://ports.ubuntu.com/ubuntu-ports/ utopic main restricted universe multiverse" > /etc/apt/sources.list.d/armhf-xcompile.list'
+    $ sudo sh -c 'echo "deb [arch=armhf] http://ports.ubuntu.com/ubuntu-ports/ `lsb_release -sc` main restricted universe multiverse" > /etc/apt/sources.list.d/armhf-xcompile.list'
     $ sudo apt-get update
 
 Now to test that everything is working you can try downloading a package like
 this:
 
-    $ apt-get download gcc:armhf
+    $ apt-get download gcc:armhf && echo Success || echo Failure
 
 Once you're able to download armhf packages from the repository, the 
 cross-compile-chroot.sh script provides an example of how to build Mir for

=== modified file 'doc/demo_shell_controls.md'
--- doc/demo_shell_controls.md	2014-05-20 07:11:21 +0000
+++ doc/demo_shell_controls.md	2014-11-25 17:45:03 +0000
@@ -37,7 +37,8 @@
  - Move window: *Alt-leftmousebutton* or *3-finger drag*
  - Resize window: *Alt-middlemousebutton* or *3-finger pinch/zoom*
  - Sleep/wake all displays: *Alt-P* or *Android power button*
- - Rotate the focussed monitor: *Ctrl-Alt-(Left/Right/Up/Down)*
+ - Rotate the focussed monitor: *Ctrl-Alt-(Left/Right/Up/Down)* or
+   *Volume up/down while touching the screen*
  - Change display mode of the focussed monitor: *Ctrl-Alt-(=/-)*
  - Reset display mode to default, on focussed monitor: *Ctrl-Alt-0*
  - Adjust window opacity/alpha: *Alt-mousewheel*

=== modified file 'doc/mainpage.md'
--- doc/mainpage.md	2014-10-03 03:02:09 +0000
+++ doc/mainpage.md	2014-11-25 17:45:03 +0000
@@ -29,6 +29,12 @@
  - \ref building_source_for_pc
  - \ref building_source_for_android
 
+### Preparing a VM to run Mir
+
+Especially if you want to debug the shell without locking your system this might be a helpful setup:
+
+- \ref setup_kvm_for_mir
+
 Using Mir
 ---------
 

=== added file 'doc/setup_kvm_for_mir.md'
--- doc/setup_kvm_for_mir.md	1970-01-01 00:00:00 +0000
+++ doc/setup_kvm_for_mir.md	2014-11-25 17:45:03 +0000
@@ -0,0 +1,70 @@
+Setup KVM for Mir {#setup_kvm_for_mir}
+=================
+
+At the time of writing not all necessary patches to run Mir inside KVM can be
+found in a vanilla kernel release. The steps below describe setting up KVM and
+installing the right version of Mesa and the Linux kernel.
+
+Install KVM and utilities
+-------------------------
+
+The only way to run Mir inside KVM requires a setup with
+[SPICE](http://spice-space.org). So next to KVM a SPICE client is needed on
+the host to provide a monitor to the guest. The following description will use
+virt-manager for this task:
+
+    $ apt-get install qemu-KVM virt-manager python-spice-client-gtk
+
+More details on setting up KVM can be found in the
+[wiki](https://help.ubuntu.com/community/KVM/Installation).
+
+Now create a new virtual machine with virt-manager and a current Linux boot iso 
+image or reconfigure an existing installation.
+
+Configure the virtual machine
+-----------------------------
+
+Launch virt-manager and open your virtual machine. Go to the configuration
+options through the info icon in the toolbar. There are now two relevant
+configuration entries: Video and Display.
+
+* Open the Display settings and select SPICE instead of KVM
+* Open the Video settings and select QXL as model. 
+
+Now boot the machine and build a new kernel and verify that you have the right
+Mesa package.
+
+Build the right kernel
+----------------------
+
+Until Linux 3.18 is released either build 
+[drm-next](http://cgit.freedesktop.org/~airlied/linux/log/?h=drm-next) for your
+KVM architecture or pull the sources of the current Ubuntu kernel image and
+apply the following two patches before you build:
+
+* [drm/qxl: simple crtc page flipping emulated using buffer copy]
+(http://cgit.freedesktop.org/~airlied/linux/patch/?id=058e9f5c8236ad740ab984588b507758e5feee6d)
+* [drm/qxl: enables gem prime helpers for qxl using dummy driver callbacks]
+(http://cgit.freedesktop.org/~airlied/linux/patch/?id=47c1296829505d119d7d58dd23d39cc5db344f12)
+
+More detais on building a Kernel within and for Ubuntu is described [here]
+(https://help.ubuntu.com/community/Kernel/Compile) in full detail.
+
+
+Verify Mesa installation
+------------------------
+
+Since the DRM QXL driver only provides KMS, GEM and dma-buf support, and no 3D
+GPU emulation or forwarding, Mesa will load the kms-swrast driver. This driver
+is available since Mesa 10.3.0
+With that we have enough support for EGL and GLESv2 to run Mir.
+
+Additional steps
+----------------
+
+This is not necessary but helpful for day to day use:
+
+* Set up sharing on file system level using 9p as shown in
+[Fileystem Passthrough](http://www.linux-kvm.org/page/9p_virtio)
+
+Now you can finally install & run unity8-desktop-session-mir in KVM.

=== modified file 'examples/CMakeLists.txt'
--- examples/CMakeLists.txt	2014-10-03 15:10:23 +0000
+++ examples/CMakeLists.txt	2014-11-25 17:45:03 +0000
@@ -6,7 +6,8 @@
 )
 
 add_library(exampleserverconfig STATIC
-  server_configuration.cpp
+  example_display_configuration_policy.cpp
+  example_input_event_filter.cpp
 )
 
 target_link_libraries(eglapp
@@ -153,12 +154,14 @@
 
 add_executable(mir_demo_server_basic
   basic_server.cpp
-  basic_server_configuration.cpp
+  glog_logger.cpp
 )
 
 target_link_libraries(mir_demo_server_basic
   mirserver
   exampleserverconfig
+  ${GLog_LIBRARY}
+  ${GFlags_LIBRARY}
   ${Boost_LIBRARIES}
 )
 
@@ -172,23 +175,6 @@
     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
 )
 
-add_executable(mir_demo_server_translucent
-  translucent_server.cpp
-  translucent_server_configuration.cpp
-  pixel_format_selector.cpp
-  basic_server_configuration.cpp
-)
-
-target_link_libraries(mir_demo_server_translucent
-  mirserver
-  exampleserverconfig
-  ${Boost_LIBRARIES}
-)
-
-install(TARGETS mir_demo_server_translucent
-  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-)
-
 add_executable(mir_demo_standalone_render_overlays
     render_overlays.cpp
 )

=== modified file 'examples/basic_server.cpp'
--- examples/basic_server.cpp	2014-03-06 06:05:17 +0000
+++ examples/basic_server.cpp	2014-11-25 17:45:03 +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 as
@@ -16,23 +16,133 @@
  * Authored by: Alan Griffiths <[e-mail]>
  */
 
-#include "basic_server_configuration.h"
+#include "example_input_event_filter.h"
+#include "example_display_configuration_policy.h"
+#include "glog_logger.h"
 
+#include "mir/server.h"
 #include "mir/report_exception.h"
-#include "mir/run_mir.h"
-
-#include <iostream>
+#include "mir/options/option.h"
+#include "mir/input/composite_event_filter.h"
+
+#include <cstdlib>
+
+namespace me = mir::examples;
+namespace ml = mir::logging;
+namespace mg = mir::graphics;
+
+namespace
+{
+char const* const glog                 = "glog";
+char const* const glog_stderrthreshold = "glog-stderrthreshold";
+char const* const glog_minloglevel     = "glog-minloglevel";
+char const* const glog_log_dir         = "glog-log-dir";
+
+int const glog_stderrthreshold_default = 2;
+int const glog_minloglevel_default     = 0;
+char const* const glog_log_dir_default = "";
+}
 
 int main(int argc, char const* argv[])
 try
 {
-    mir::examples::BasicServerConfiguration config(argc, argv);
-
-    run_mir(config, [&](mir::DisplayServer&){ config.launch_client(); });
-    return 0;
+    static char const* const launch_child_opt = "launch-client";
+    static char const* const launch_client_descr = "system() command to launch client";
+
+    mir::Server server;
+
+    // Set up a Ctrl+Alt+BkSp => quit
+    auto const quit_filter = std::make_shared<me::QuitFilter>([&]{ server.stop(); });
+
+    server.add_init_callback([&] { server.the_composite_event_filter()->append(quit_filter); });
+
+    // Add choice of monitor configuration
+    server.add_configuration_option(
+        me::display_config_opt, me::display_config_descr,   me::clone_opt_val);
+    server.add_configuration_option(
+        me::display_alpha_opt,  me::display_alpha_descr,    me::display_alpha_off);
+
+    server.add_configuration_option(glog, "Use google::GLog for logging", mir::OptionType::null);
+
+    server.add_configuration_option(
+        glog_stderrthreshold,
+        "Copy log messages at or above this level "
+        "to stderr in addition to logfiles. The numbers "
+        "of severity levels INFO, WARNING, ERROR, and "
+        "FATAL are 0, 1, 2, and 3, respectively.",
+        glog_stderrthreshold_default);
+
+    server.add_configuration_option(
+        glog_minloglevel,
+        "Log messages at or above this level. The numbers "
+        "of severity levels INFO, WARNING, ERROR, and "
+        "FATAL are 0, 1, 2, and 3, respectively.",
+        glog_minloglevel_default);
+
+    server.add_configuration_option(
+        glog_log_dir,
+        "logfiles are written into this directory.",
+        glog_log_dir_default);
+
+    server.override_the_logger(
+        [&]() -> std::shared_ptr<ml::Logger>
+        {
+            if (server.get_options()->is_set(glog))
+            {
+                return std::make_shared<me::GlogLogger>(
+                    "mir",
+                    server.get_options()->get<int>(glog_stderrthreshold),
+                    server.get_options()->get<int>(glog_minloglevel),
+                    server.get_options()->get<std::string>(glog_log_dir));
+            }
+            else
+            {
+                return std::shared_ptr<ml::Logger>{};
+            }
+        });
+
+    server.wrap_display_configuration_policy(
+        [&](std::shared_ptr<mg::DisplayConfigurationPolicy> const& wrapped)
+        -> std::shared_ptr<mg::DisplayConfigurationPolicy>
+        {
+            auto const options = server.get_options();
+            auto display_layout = options->get<std::string>(me::display_config_opt);
+            auto with_alpha = options->get<std::string>(me::display_alpha_opt) == me::display_alpha_on;
+
+            auto layout_selector = wrapped;
+
+            if (display_layout == me::sidebyside_opt_val)
+                layout_selector = std::make_shared<me::SideBySideDisplayConfigurationPolicy>();
+            else if (display_layout == me::single_opt_val)
+                layout_selector = std::make_shared<me::SingleDisplayConfigurationPolicy>();
+
+            // Whatever the layout select a pixel format with requested alpha
+            return std::make_shared<me::PixelFormatSelector>(layout_selector, with_alpha);
+        });
+
+    // Add a launcher option
+    server.add_configuration_option(
+        launch_child_opt,       launch_client_descr,        mir::OptionType::string);
+
+    server.add_init_callback([&]
+        {
+            auto const options = server.get_options();
+
+            if (options->is_set(launch_child_opt))
+            {
+                auto ignore = std::system((options->get<std::string>(launch_child_opt) + "&").c_str());
+                (void)ignore;
+            }
+        });
+
+    // Provide the command line and run the server
+    server.set_command_line(argc, argv);
+    server.apply_settings();
+    server.run();
+    return server.exited_normally() ? EXIT_SUCCESS : EXIT_FAILURE;
 }
 catch (...)
 {
-    mir::report_exception(std::cerr);
-    return 1;
+    mir::report_exception();
+    return EXIT_FAILURE;
 }

=== removed file 'examples/basic_server_configuration.cpp'
--- examples/basic_server_configuration.cpp	2014-09-12 05:56:28 +0000
+++ examples/basic_server_configuration.cpp	1970-01-01 00:00:00 +0000
@@ -1,62 +0,0 @@
-/*
- * Copyright © 2012, 2014 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Alan Griffiths <[e-mail]>
- */
-
-#include "basic_server_configuration.h"
-#include "mir/options/default_configuration.h"
-
-#include "mir/abnormal_exit.h"
-#include "mir/options/option.h"
-
-#include <cstdlib>
-
-namespace
-{
-char const* const launch_child_opt = "launch-client";
-}
-
-namespace mir
-{
-namespace examples
-{
-
-BasicServerConfiguration::BasicServerConfiguration(int argc, char const** argv) :
-    ServerConfiguration([argc, argv]
-    {
-        auto result = std::make_shared<options::DefaultConfiguration>(argc, argv);
-
-        namespace po = boost::program_options;
-
-        result->add_options()
-            (launch_child_opt, po::value<std::string>(), "system() command to launch client");
-
-        return result;
-    }())
-{
-}
-
-void BasicServerConfiguration::launch_client()
-{
-    if (the_options()->is_set(launch_child_opt))
-    {
-        auto ignore = std::system((the_options()->get<std::string>(launch_child_opt) + "&").c_str());
-        (void)ignore;
-    }
-}
-
-}
-}

=== removed file 'examples/basic_server_configuration.h'
--- examples/basic_server_configuration.h	2014-01-02 14:54:13 +0000
+++ examples/basic_server_configuration.h	1970-01-01 00:00:00 +0000
@@ -1,43 +0,0 @@
-/*
- * Copyright © 2014 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Alexandros Frantzis <[e-mail]>
- */
-
-#ifndef MIR_EXAMPLES_BASIC_SERVER_CONFIGURATION_H_
-#define MIR_EXAMPLES_BASIC_SERVER_CONFIGURATION_H_
-
-#include "server_configuration.h"
-
-namespace mir
-{
-namespace examples
-{
-
-/**
- * \brief BasicServerConfiguration extends ServerConfiguration with the ability to launch a client application
- */
-class BasicServerConfiguration : public ServerConfiguration
-{
-public:
-    BasicServerConfiguration(int argc, char const** argv);
-
-    void launch_client();
-};
-
-}
-}
-
-#endif /* MIR_EXAMPLES_BASIC_SERVER_CONFIGURATION_H_ */

=== modified file 'examples/demo_input_filter.cpp'
--- examples/demo_input_filter.cpp	2014-09-12 05:56:28 +0000
+++ examples/demo_input_filter.cpp	2014-11-25 17:45:03 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -16,20 +16,20 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
-#include "mir/run_mir.h"
-#include "mir/abnormal_exit.h"
+#include "mir/server.h"
+#include "mir/report_exception.h"
+
+#include "example_input_event_filter.h"
 #include "mir/input/composite_event_filter.h"
-#include "server_configuration.h"
-
-#include <boost/exception/diagnostic_information.hpp>
-
+
+#include <cstdlib>
 #include <iostream>
 
+namespace me = mir::examples;
 namespace mi = mir::input;
 
 namespace
 {
-
 struct PrintingEventFilter : public mi::EventFilter
 {
     void print_motion_event(MirMotionEvent const& ev)
@@ -62,48 +62,29 @@
         return false;
     }
 };
-
-struct DemoServerConfiguration : public mir::examples::ServerConfiguration
-{
-    DemoServerConfiguration(int argc, char const* argv[])
-      : ServerConfiguration(argc, argv),
-        event_filter(std::make_shared<PrintingEventFilter>())
-    {
-    }
-
-    std::shared_ptr<mi::CompositeEventFilter> the_composite_event_filter() override
-    {
-        auto composite_filter = ServerConfiguration::the_composite_event_filter();
-        composite_filter->prepend(event_filter);
-        return composite_filter;
-    }
-
-    std::shared_ptr<PrintingEventFilter> const event_filter;
-};
-
-}
-
-
-void my_write_to_log(int /*prio*/, char const* buffer)
-{
-    printf("%s\n", buffer);
 }
 
 int main(int argc, char const* argv[])
 try
 {
-    DemoServerConfiguration config(argc, argv);
-
-    mir::run_mir(config, [](mir::DisplayServer&) {/* empty init */});
-    return 0;
-}
-catch (mir::AbnormalExit const& error)
-{
-    std::cerr << error.what() << std::endl;
-    return 1;
-}
-catch (std::exception const& error)
-{
-    std::cerr << "ERROR: " << boost::diagnostic_information(error) << std::endl;
-    return 1;
+    mir::Server server;
+
+    // Set up Ctrl+Alt+BkSp => quit
+    auto const quit_filter = std::make_shared<me::QuitFilter>([&]{ server.stop(); });
+    server.add_init_callback([&] { server.the_composite_event_filter()->append(quit_filter); });
+
+    // Set up a PrintingEventFilter
+    auto const printing_filter = std::make_shared<PrintingEventFilter>();
+    server.add_init_callback([&] { server.the_composite_event_filter()->prepend(printing_filter); });
+
+    // Provide the command line and run the server
+    server.set_command_line(argc, argv);
+    server.apply_settings();
+    server.run();
+    return server.exited_normally() ? EXIT_SUCCESS : EXIT_FAILURE;
+}
+catch (...)
+{
+    mir::report_exception(std::cerr);
+    return EXIT_FAILURE;
 }

=== added file 'examples/example_display_configuration_policy.cpp'
--- examples/example_display_configuration_policy.cpp	1970-01-01 00:00:00 +0000
+++ examples/example_display_configuration_policy.cpp	2014-11-25 17:45:03 +0000
@@ -0,0 +1,140 @@
+/*
+ * 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: Alan Griffiths <[e-mail]>
+ */
+
+#include "example_display_configuration_policy.h"
+
+#include "mir/graphics/display_configuration.h"
+
+#include <algorithm>
+#include <unordered_map>
+#include <stdexcept>
+
+namespace geom = mir::geometry;
+namespace me = mir::examples;
+namespace mg = mir::graphics;
+
+char const* const me::display_config_opt = "display-config";
+char const* const me::display_config_descr = "Display configuration [{clone,sidebyside,single}]";
+
+char const* const me::clone_opt_val = "clone";
+char const* const me::sidebyside_opt_val = "sidebyside";
+char const* const me::single_opt_val = "single";
+
+char const* const me::display_alpha_opt = "translucent";
+char const* const me::display_alpha_descr = "Select a display mode with alpha[{on,off}]";
+
+char const* const me::display_alpha_off = "off";
+char const* const me::display_alpha_on = "on";
+
+void me::SideBySideDisplayConfigurationPolicy::apply_to(graphics::DisplayConfiguration& conf)
+{
+    size_t const preferred_mode_index{0};
+    int max_x = 0;
+    std::unordered_map<mg::DisplayConfigurationCardId, size_t> available_outputs_for_card;
+
+    conf.for_each_card(
+        [&](mg::DisplayConfigurationCard const& card)
+        {
+            available_outputs_for_card[card.id] = card.max_simultaneous_outputs;
+        });
+
+    conf.for_each_output(
+        [&](mg::UserDisplayConfigurationOutput& conf_output)
+        {
+            if (conf_output.connected && conf_output.modes.size() > 0 &&
+                available_outputs_for_card[conf_output.card_id] > 0)
+            {
+                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_output.used = false;
+                conf_output.power_mode = mir_power_mode_off;
+            }
+        });
+}
+
+
+void me::SingleDisplayConfigurationPolicy::apply_to(graphics::DisplayConfiguration& conf)
+{
+    size_t const preferred_mode_index{0};
+    bool done{false};
+
+    conf.for_each_output(
+        [&](mg::UserDisplayConfigurationOutput& conf_output)
+        {
+            if (!done && conf_output.connected && conf_output.modes.size() > 0)
+            {
+                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_output.used = false;
+                conf_output.power_mode = mir_power_mode_off;
+            }
+        });
+}
+
+namespace
+{
+bool contains_alpha(MirPixelFormat format)
+{
+    return (format == mir_pixel_format_abgr_8888 ||
+            format == mir_pixel_format_argb_8888);
+}
+}
+
+me::PixelFormatSelector::PixelFormatSelector(std::shared_ptr<DisplayConfigurationPolicy> const& base_policy,
+                                         bool with_alpha)
+    : base_policy{base_policy},
+    with_alpha{with_alpha}
+{}
+
+void me::PixelFormatSelector::apply_to(graphics::DisplayConfiguration & conf)
+{
+    base_policy->apply_to(conf);
+    conf.for_each_output(
+        [&](graphics::UserDisplayConfigurationOutput& conf_output)
+        {
+            if (!conf_output.connected || !conf_output.used) return;
+
+            auto const& pos = find_if(conf_output.pixel_formats.begin(),
+                                      conf_output.pixel_formats.end(),
+                                      [&](MirPixelFormat format) -> bool
+                                          {
+                                              return contains_alpha(format) == with_alpha;
+                                          }
+                                     );
+
+            // keep the default settings if nothing was found
+            if (pos == conf_output.pixel_formats.end())
+                return;
+
+            conf_output.current_format = *pos;
+        });
+}

=== added file 'examples/example_display_configuration_policy.h'
--- examples/example_display_configuration_policy.h	1970-01-01 00:00:00 +0000
+++ examples/example_display_configuration_policy.h	2014-11-25 17:45:03 +0000
@@ -0,0 +1,72 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored By: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIR_EXAMPLE_DISPLAY_CONFIGURATION_POLICY_H_
+#define MIR_EXAMPLE_DISPLAY_CONFIGURATION_POLICY_H_
+
+#include "mir/graphics/display_configuration_policy.h"
+
+#include <memory>
+
+namespace mir
+{
+namespace examples
+{
+extern char const* const display_config_opt;
+extern char const* const display_config_descr;
+extern char const* const clone_opt_val;
+extern char const* const sidebyside_opt_val;
+extern char const* const single_opt_val;
+
+class SideBySideDisplayConfigurationPolicy : public graphics::DisplayConfigurationPolicy
+{
+public:
+    void apply_to(graphics::DisplayConfiguration& conf);
+};
+
+class SingleDisplayConfigurationPolicy : public graphics::DisplayConfigurationPolicy
+{
+public:
+    void apply_to(graphics::DisplayConfiguration& conf);
+};
+
+extern char const* const display_alpha_opt;
+extern char const* const display_alpha_descr;
+extern char const* const display_alpha_off;
+extern char const* const display_alpha_on;
+
+/**
+ * \brief Example of a DisplayConfigurationPolicy that tries to find
+ * an opaque or transparent pixel format, or falls back to the default
+ * if not found.
+ */
+class PixelFormatSelector : public graphics::DisplayConfigurationPolicy
+{
+public:
+    PixelFormatSelector(std::shared_ptr<graphics::DisplayConfigurationPolicy> const& base_policy,
+                        bool with_alpha);
+    virtual void apply_to(graphics::DisplayConfiguration& conf);
+private:
+    std::shared_ptr<graphics::DisplayConfigurationPolicy> const base_policy;
+    bool const with_alpha;
+};
+
+}
+}
+
+#endif /* MIR_EXAMPLE_DISPLAY_CONFIGURATION_POLICY_H_ */

=== added file 'examples/example_input_event_filter.cpp'
--- examples/example_input_event_filter.cpp	1970-01-01 00:00:00 +0000
+++ examples/example_input_event_filter.cpp	2014-11-25 17:45:03 +0000
@@ -0,0 +1,45 @@
+/*
+ * 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: Alan Griffiths <[e-mail]>
+ */
+
+#include "example_input_event_filter.h"
+
+#include "mir/server.h"
+
+#include <linux/input.h>
+
+namespace me = mir::examples;
+
+me::QuitFilter::QuitFilter(std::function<void()> const& quit_action)
+    : quit_action{quit_action}
+{
+}
+
+bool me::QuitFilter::handle(MirEvent const& event)
+{
+    if (event.type == mir_event_type_key &&
+        event.key.action == mir_key_action_down &&
+        (event.key.modifiers & mir_key_modifier_alt) &&
+        (event.key.modifiers & mir_key_modifier_ctrl) &&
+        event.key.scan_code == KEY_BACKSPACE)
+    {
+        quit_action();
+        return true;
+    }
+
+    return false;
+}

=== added file 'examples/example_input_event_filter.h'
--- examples/example_input_event_filter.h	1970-01-01 00:00:00 +0000
+++ examples/example_input_event_filter.h	2014-11-25 17:45:03 +0000
@@ -0,0 +1,43 @@
+/*
+ * 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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef EXAMPLE_INPUT_EVENT_FILTER_H_
+#define EXAMPLE_INPUT_EVENT_FILTER_H_
+
+#include "mir/input/event_filter.h"
+
+#include <functional>
+
+namespace mir
+{
+namespace examples
+{
+class QuitFilter : public mir::input::EventFilter
+{
+public:
+    QuitFilter(std::function<void()> const& quit_action);
+
+    bool handle(MirEvent const& event) override;
+
+private:
+    std::function<void()> const quit_action;
+};
+}
+}
+
+#endif /* EXAMPLE_INPUT_EVENT_FILTER_H_ */

=== renamed file 'src/server/logging/glog_logger.cpp' => 'examples/glog_logger.cpp'
--- src/server/logging/glog_logger.cpp	2014-03-06 06:05:17 +0000
+++ examples/glog_logger.cpp	2014-11-25 17:45:03 +0000
@@ -16,7 +16,7 @@
  * Authored by: Alan Griffiths <[e-mail]>
  */
 
-#include "mir/logging/glog_logger.h"
+#include "glog_logger.h"
 
 #include <glog/logging.h>
 #include <gflags/gflags.h>
@@ -24,6 +24,8 @@
 #include <mutex>
 #include <cstdlib>
 
+namespace ml=mir::logging;
+
 namespace
 {
 std::once_flag init_flag;
@@ -53,7 +55,7 @@
 }
 
 
-mir::logging::GlogLogger::GlogLogger(
+mir::examples::GlogLogger::GlogLogger(
     const char* argv0,
     int stderrthreshold,
     int minloglevel,
@@ -66,7 +68,7 @@
     static google_glog_guard_t guard(argv0);
 }
 
-void mir::logging::GlogLogger::log(Severity severity, const std::string& message, const std::string& component)
+void mir::examples::GlogLogger::log(ml::Severity severity, std::string const& message, std::string const& component)
 {
     static int glog_level[] =
     {
@@ -78,6 +80,6 @@
     };
 
     // Since we're not collecting __FILE__ or __LINE__ this is misleading
-    google::LogMessage(__FILE__, __LINE__, glog_level[severity]).stream()
+    google::LogMessage(__FILE__, __LINE__, glog_level[static_cast<int>(severity)]).stream()
         << '[' << component << "] " << message;
 }

=== renamed file 'src/include/server/mir/logging/glog_logger.h' => 'examples/glog_logger.h'
--- src/include/server/mir/logging/glog_logger.h	2014-09-11 05:51:44 +0000
+++ examples/glog_logger.h	2014-11-25 17:45:03 +0000
@@ -20,9 +20,9 @@
 
 namespace mir
 {
-namespace logging
+namespace examples
 {
-class GlogLogger : public Logger
+class GlogLogger : public logging::Logger
 {
 public:
     GlogLogger(
@@ -33,9 +33,9 @@
 
 private:
     virtual void log(
-        Severity severity,
-        const std::string& message,
-        const std::string& component) override;
+        mir::logging::Severity severity,
+        std::string const& message,
+        std::string const& component) override;
 };
 }
 }

=== modified file 'examples/minimal_server.cpp'
--- examples/minimal_server.cpp	2014-09-11 05:51:44 +0000
+++ examples/minimal_server.cpp	2014-11-25 17:45:03 +0000
@@ -16,21 +16,22 @@
  * Authored by: Daniel van Vugt <[e-mail]>
  */
 
-#include "mir/default_server_configuration.h"
+#include "mir/server.h"
 #include "mir/report_exception.h"
-#include "mir/run_mir.h"
 
-#include <iostream>
+#include <cstdlib>
 
 int main(int argc, char const* argv[])
 try
 {
-    mir::DefaultServerConfiguration config(argc, argv);
-    run_mir(config, [](mir::DisplayServer&){} );
-    return 0;
+    mir::Server server;
+    server.set_command_line(argc, argv);
+    server.apply_settings();
+    server.run();
+    return server.exited_normally() ? EXIT_SUCCESS : EXIT_FAILURE;
 }
 catch (...)
 {
-    mir::report_exception(std::cerr);
-    return 1;
+    mir::report_exception();
+    return EXIT_FAILURE;
 }

=== removed file 'examples/pixel_format_selector.cpp'
--- examples/pixel_format_selector.cpp	2014-09-12 05:56:28 +0000
+++ examples/pixel_format_selector.cpp	1970-01-01 00:00:00 +0000
@@ -1,72 +0,0 @@
-/*
- * Copyright © 2014 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Andreas Pokorny <[e-mail]>
- */
-
-#include "pixel_format_selector.h"
-
-#include "mir/graphics/display_configuration.h"
-
-#include <stdexcept>
-#include <algorithm>
-
-namespace
-{
-bool contains_alpha(MirPixelFormat format)
-{
-    return (format == mir_pixel_format_abgr_8888 ||
-            format == mir_pixel_format_argb_8888);
-}
-}
-
-namespace mir
-{
-namespace examples
-{
-
-PixelFormatSelector::PixelFormatSelector(std::shared_ptr<DisplayConfigurationPolicy> const& base_policy,
-                                         bool with_alpha)
-    : base_policy{base_policy},
-    with_alpha{with_alpha}
-{}
-
-void PixelFormatSelector::apply_to(graphics::DisplayConfiguration & conf)
-{
-    base_policy->apply_to(conf);
-    conf.for_each_output(
-        [&](graphics::UserDisplayConfigurationOutput& conf_output)
-        {
-            if (!conf_output.connected || !conf_output.used) return;
-
-            auto const& pos = find_if(conf_output.pixel_formats.begin(),
-                                      conf_output.pixel_formats.end(),
-                                      [&](MirPixelFormat format) -> bool
-                                          {
-                                              return contains_alpha(format) == with_alpha;
-                                          }
-                                     );
-
-            // keep the default settings if nothing was found
-            if (pos == conf_output.pixel_formats.end())
-                return;
-
-            conf_output.current_format = *pos;
-        });
-}
-
-}
-}
-

=== removed file 'examples/pixel_format_selector.h'
--- examples/pixel_format_selector.h	2014-01-13 17:03:34 +0000
+++ examples/pixel_format_selector.h	1970-01-01 00:00:00 +0000
@@ -1,51 +0,0 @@
-/*
- * Copyright © 2014 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Andreas Pokorny <[e-mail]>
- */
-
-
-#ifndef MIR_EXAMPLES_SELECT_PIXEL_FORMAT_H
-#define MIR_EXAMPLES_SELECT_PIXEL_FORMAT_H
-
-#include "mir/graphics/display_configuration_policy.h"
-
-#include <memory>
-
-namespace mir
-{
-namespace examples
-{
-
-/**
- * \brief Example of a DisplayConfigurationPolicy that tries to find
- * an opaque or transparent pixel format, or falls back to the default
- * if not found.
- */
-class PixelFormatSelector : public graphics::DisplayConfigurationPolicy
-{
-public:
-    PixelFormatSelector(std::shared_ptr<graphics::DisplayConfigurationPolicy> const& base_policy,
-                        bool with_alpha);
-    virtual void apply_to(graphics::DisplayConfiguration& conf);
-private:
-    std::shared_ptr<graphics::DisplayConfigurationPolicy> const base_policy;
-    bool const with_alpha;
-};
-
-}
-}
-
-#endif

=== modified file 'examples/progressbar.c'
--- examples/progressbar.c	2014-09-11 05:51:44 +0000
+++ examples/progressbar.c	2014-11-25 17:45:03 +0000
@@ -16,12 +16,14 @@
  * Author: Daniel van Vugt <[e-mail]>
  */
 
+#define _DEFAULT_SOURCE
+#define _BSD_SOURCE /* for usleep() */
+
 #include "mir_toolkit/mir_client_library.h"
 #include <stdio.h>
 #include <signal.h>
 #include <stdint.h>
 #include <stdlib.h>
-#define __USE_BSD 1  /* for usleep() */
 #include <unistd.h>  /* sleep() */
 #include <string.h>
 

=== modified file 'examples/render_overlays.cpp'
--- examples/render_overlays.cpp	2014-10-01 10:35:29 +0000
+++ examples/render_overlays.cpp	2014-11-25 17:45:03 +0000
@@ -16,14 +16,14 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#include "mir/default_server_configuration.h"
+#include "mir/server.h"
+#include "mir/report_exception.h"
 #include "mir/graphics/display.h"
 #include "mir/graphics/renderable.h"
 #include "mir/graphics/display_buffer.h"
 #include "mir/graphics/platform.h"
 #include "mir/graphics/graphic_buffer_allocator.h"
 #include "mir/graphics/buffer_properties.h"
-#include "mir/report_exception.h"
 
 #include "testdraw/graphics_region_factory.h"
 #include "testdraw/patterns.h"
@@ -33,7 +33,6 @@
 #include <iostream>
 
 namespace mg=mir::graphics;
-namespace ml=mir::logging;
 namespace mo=mir::options;
 namespace geom=mir::geometry;
 
@@ -150,12 +149,9 @@
     geom::Rectangle const position;
     glm::mat4 const trans;
 };
-}
 
-int main(int argc, char const** argv)
-try
+void render_loop(mir::Server& server)
 {
-
     /* Set up graceful exit on SIGINT and SIGTERM */
     struct sigaction sa;
     sa.sa_handler = signal_handler;
@@ -165,11 +161,9 @@
     sigaction(SIGINT, &sa, NULL);
     sigaction(SIGTERM, &sa, NULL);
 
-    mir::DefaultServerConfiguration conf{argc, argv};
-
-    auto platform = conf.the_graphics_platform();
-    auto display = conf.the_display();
-    auto buffer_allocator = platform->create_buffer_allocator(conf.the_buffer_initializer());
+    auto platform = server.the_graphics_platform();
+    auto display = server.the_display();
+    auto buffer_allocator = platform->create_buffer_allocator();
 
      mg::BufferProperties buffer_properties{
         geom::Size{512, 512},
@@ -196,10 +190,22 @@
             buffer.post_renderables_if_optimizable(renderlist);
         });
     }
-   return 0;
+}
+}
+
+int main(int argc, char const** argv)
+try
+{
+    mir::Server server;
+    server.set_command_line(argc, argv);
+    server.apply_settings();
+
+    render_loop(server);
+
+    return EXIT_SUCCESS;
 }
 catch (...)
 {
     mir::report_exception(std::cerr);
-    return 1;
+    return EXIT_FAILURE;
 }

=== modified file 'examples/render_to_fb.cpp'
--- examples/render_to_fb.cpp	2014-03-11 13:44:57 +0000
+++ examples/render_to_fb.cpp	2014-11-25 17:45:03 +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 as
@@ -18,13 +18,12 @@
 
 #include "graphics.h"
 
-#include "mir/default_server_configuration.h"
+#include "mir/server.h"
+#include "mir/report_exception.h"
 #include "mir/graphics/display.h"
 #include "mir/graphics/display_buffer.h"
-#include "mir/report_exception.h"
 
 #include <csignal>
-#include <iostream>
 
 namespace mg=mir::graphics;
 namespace mo=mir::options;
@@ -39,8 +38,7 @@
 }
 }
 
-int main(int argc, char const** argv)
-try
+void render_loop(mir::Server& server)
 {
     /* Set up graceful exit on SIGINT and SIGTERM */
     struct sigaction sa;
@@ -51,9 +49,7 @@
     sigaction(SIGINT, &sa, NULL);
     sigaction(SIGTERM, &sa, NULL);
 
-    mir::DefaultServerConfiguration conf{argc, argv};
-
-    auto display = conf.the_display();
+    auto display = server.the_display();
 
     mir::draw::glAnimationBasic gl_animation;
 
@@ -76,11 +72,21 @@
 
         gl_animation.step();
     }
-
-    return 0;
+}
+
+int main(int argc, char const** argv)
+try
+{
+    mir::Server server;
+    server.set_command_line(argc, argv);
+    server.apply_settings();
+
+    render_loop(server);
+
+    return EXIT_SUCCESS;
 }
 catch (...)
 {
-    mir::report_exception(std::cerr);
-    return 1;
+    mir::report_exception();
+    return EXIT_FAILURE;
 }

=== removed file 'examples/translucent_server.cpp'
--- examples/translucent_server.cpp	2014-01-02 14:54:13 +0000
+++ examples/translucent_server.cpp	1970-01-01 00:00:00 +0000
@@ -1,38 +0,0 @@
-/*
- * Copyright © 2014 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Andreas Pokorny <[e-mail]>
- */
-
-#include "translucent_server_configuration.h"
-
-#include "mir/report_exception.h"
-#include "mir/run_mir.h"
-
-#include <iostream>
-
-int main(int argc, char const* argv[])
-try
-{
-    mir::examples::TranslucentServerConfiguration config(argc, argv);
-
-    run_mir(config, [&](mir::DisplayServer&){ config.launch_client(); });
-    return 0;
-}
-catch (...)
-{
-    mir::report_exception(std::cerr);
-    return 1;
-}

=== removed file 'examples/translucent_server_configuration.cpp'
--- examples/translucent_server_configuration.cpp	2014-01-02 14:54:13 +0000
+++ examples/translucent_server_configuration.cpp	1970-01-01 00:00:00 +0000
@@ -1,45 +0,0 @@
-/*
- * Copyright © 2014 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Andreas Pokorny <[e-mail]>
- */
-
-#include "translucent_server_configuration.h"
-
-#include "pixel_format_selector.h"
-
-namespace mir
-{
-namespace examples
-{
-
-TranslucentServerConfiguration::TranslucentServerConfiguration(int argc, char const** argv)
-    : BasicServerConfiguration(argc, argv)
-{
-}
-
-std::shared_ptr<graphics::DisplayConfigurationPolicy>
-TranslucentServerConfiguration::the_display_configuration_policy()
-{
-    return display_configuration_policy(
-        [this]() -> std::shared_ptr<graphics::DisplayConfigurationPolicy>
-        {
-            return std::make_shared<PixelFormatSelector>(BasicServerConfiguration::the_display_configuration_policy(), true);
-        });
-}
-
-
-}
-}

=== removed file 'examples/translucent_server_configuration.h'
--- examples/translucent_server_configuration.h	2014-01-02 14:54:13 +0000
+++ examples/translucent_server_configuration.h	1970-01-01 00:00:00 +0000
@@ -1,43 +0,0 @@
-/*
- * Copyright © 2014 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Andreas Pokorny <[e-mail]>
- */
-
-#ifndef MIR_EXAMPLES_TRANSLUCENT_SERVER_CONFIGURATION_H_
-#define MIR_EXAMPLES_TRANSLUCENT_SERVER_CONFIGURATION_H_
-
-#include "basic_server_configuration.h"
-
-namespace mir
-{
-namespace examples
-{
-
-/**
- * \brief TranslucentServerConfiguration extends BasicServerConfiguration with a different pixel format selection
- */
-class TranslucentServerConfiguration : public BasicServerConfiguration
-{
-public:
-    TranslucentServerConfiguration(int argc, char const** argv);
-
-    std::shared_ptr<graphics::DisplayConfigurationPolicy> the_display_configuration_policy();
-};
-
-}
-}
-
-#endif /* MIR_EXAMPLES_TRANSLUCENT_SERVER_CONFIGURATION_H_ */

=== removed directory 'include/client/mir'
=== removed directory 'include/client/mir/client'
=== added directory 'include/client/mir_toolkit/debug'
=== renamed file 'include/client/mir_toolkit/mir_client_library_debug.h' => 'include/client/mir_toolkit/debug/surface.h'
--- include/client/mir_toolkit/mir_client_library_debug.h	2014-09-11 05:51:44 +0000
+++ include/client/mir_toolkit/debug/surface.h	2014-11-25 17:45:03 +0000
@@ -28,6 +28,7 @@
 
 /**
  * Return the ID of a surface (only useful for debug output).
+ *   \pre                 The surface is valid
  *   \param [in] surface  The surface
  *   \return              An internal ID that identifies the surface
  */
@@ -43,6 +44,25 @@
  */
 uint32_t mir_debug_surface_current_buffer_id(MirSurface *surface);
 
+/**
+ * Get the screen coordinates corresponding to a pair of surface coordinates
+ * \pre                               The surface is valid
+ * \param   [in] surface              The surface
+ * \param   [in] x, y                 Surface coordinates to map to screen coordinates
+ * \param   [out] screen_x, screen_y  The screen coordinates corresponding to x, y.
+ * \return                            True if screen_x and screen_y contain values
+ * \note    There are many cases where such a mapping does not exist or would be expensive
+ *          to calculate. Only Mir servers started with the --debug option will ever return
+ *          values for this call, and even when --debug is enabled servers are free to
+ *          return nothing.
+ *
+ *          This call will only be interesting for automated testing, where both the client
+ *          and shell state is known and constrained.
+ */
+bool mir_debug_surface_coords_to_screen(MirSurface* surface,
+                                        int x, int y,
+                                        int* screen_x, int* screen_y);
+
 #ifdef __cplusplus
 }
 #endif

=== modified file 'include/client/mir_toolkit/mir_connection.h'
--- include/client/mir_toolkit/mir_connection.h	2014-09-11 05:51:44 +0000
+++ include/client/mir_toolkit/mir_connection.h	2014-11-25 17:45:03 +0000
@@ -21,6 +21,8 @@
 #include <mir_toolkit/client_types.h>
 #include <mir_toolkit/common.h>
 
+#include <stdbool.h>
+
 #ifdef __cplusplus
 /**
  * \addtogroup mir_toolkit
@@ -66,7 +68,7 @@
  * \return                 True if the supplied connection is valid, or
  *                         false otherwise.
  */
-MirBool mir_connection_is_valid(MirConnection *connection);
+bool mir_connection_is_valid(MirConnection *connection);
 
 /**
  * Retrieve a text description of the last error. The returned string is owned

=== modified file 'include/client/mir_toolkit/mir_prompt_session.h'
--- include/client/mir_toolkit/mir_prompt_session.h	2014-09-11 05:51:44 +0000
+++ include/client/mir_toolkit/mir_prompt_session.h	2014-11-25 17:45:03 +0000
@@ -20,6 +20,7 @@
 #include "mir_toolkit/mir_client_library.h"
 
 #include <sys/types.h>
+#include <stdbool.h>
 
 #ifdef __cplusplus
 /**
@@ -74,7 +75,7 @@
  *   \param [in] prompt_session  The prompt session
  *   \return                     True if prompt_session is valid, false otherwise
  */
-MirBool mir_prompt_session_is_valid(MirPromptSession *prompt_session);
+bool mir_prompt_session_is_valid(MirPromptSession *prompt_session);
 
 /**
  * Retrieve a text description of the last error. The returned string is owned

=== modified file 'include/client/mir_toolkit/mir_surface.h'
--- include/client/mir_toolkit/mir_surface.h	2014-09-11 05:51:44 +0000
+++ include/client/mir_toolkit/mir_surface.h	2014-11-25 17:45:03 +0000
@@ -23,6 +23,8 @@
 #include <mir_toolkit/common.h>
 #include <mir_toolkit/mir_cursor_configuration.h>
 
+#include <stdbool.h>
+
 #ifdef __cplusplus
 /**
  * \addtogroup mir_toolkit
@@ -89,7 +91,7 @@
  *   \return              True if the supplied surface is valid, or
  *                        false otherwise.
  */
-MirBool mir_surface_is_valid(MirSurface *surface);
+bool mir_surface_is_valid(MirSurface *surface);
 
 /**
  * Retrieve a text description of the error. The returned string is owned by

=== added file 'include/common/mir/time/types.h'
--- include/common/mir/time/types.h	1970-01-01 00:00:00 +0000
+++ include/common/mir/time/types.h	2014-11-25 17:45:03 +0000
@@ -0,0 +1,35 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_TIME_TYPES_H_
+#define MIR_TIME_TYPES_H_
+
+#include <chrono>
+
+namespace mir
+{
+namespace time
+{
+
+using Timestamp = std::chrono::steady_clock::time_point;
+using Duration = std::chrono::steady_clock::duration;
+
+}
+}
+
+#endif

=== modified file 'include/common/mir_toolkit/common.h'
--- include/common/mir_toolkit/common.h	2014-09-11 05:51:44 +0000
+++ include/common/mir_toolkit/common.h	2014-11-25 17:45:03 +0000
@@ -48,13 +48,17 @@
 
 typedef enum MirSurfaceType
 {
-    mir_surface_type_normal,
-    mir_surface_type_utility,
+    mir_surface_type_normal,       /**< AKA "regular"                       */
+    mir_surface_type_utility,      /**< AKA "floating"                      */
     mir_surface_type_dialog,
-    mir_surface_type_overlay,
+    mir_surface_type_overlay,      /**< \deprecated  Use "gloss" instead.   */
+    mir_surface_type_gloss = mir_surface_type_overlay,
     mir_surface_type_freestyle,
-    mir_surface_type_popover,
-    mir_surface_type_inputmethod,
+    mir_surface_type_popover,      /**< \deprecated  Choose "menu" or "tip" */
+    mir_surface_type_menu = mir_surface_type_popover,
+    mir_surface_type_inputmethod,  /**< AKA "OSK" or handwriting etc.       */
+    mir_surface_type_satellite,    /**< AKA "toolbox"/"toolbar"             */
+    mir_surface_type_tip,          /**< AKA "tooltip"                       */
     mir_surface_types
 } MirSurfaceType;
 

=== modified file 'include/common/mir_toolkit/mesa/native_display.h'
--- include/common/mir_toolkit/mesa/native_display.h	2013-08-28 03:41:48 +0000
+++ include/common/mir_toolkit/mesa/native_display.h	2014-11-25 17:45:03 +0000
@@ -39,7 +39,7 @@
 struct MirMesaEGLNativeDisplay
 {
     int (*display_get_platform)(MirMesaEGLNativeDisplay* display,
-                                 MirPlatformPackage* package);
+                                MirPlatformPackage* package);
     void *context;
 };
 
@@ -47,9 +47,9 @@
 {
     int (*surface_set_swapinterval)(MirMesaEGLNativeSurface* surface, int interval);
     int (*surface_advance_buffer)(MirMesaEGLNativeSurface* surface,
-                                   MirBufferPackage* buffer_package);
+                                  MirBufferPackage* buffer_package);
     int (*surface_get_parameters)(MirMesaEGLNativeSurface* surface,
-                                   MirSurfaceParameters* surface_parameters);
+                                  MirSurfaceParameters* surface_parameters);
 };
 
 typedef int (*MirMesaEGLNativeDisplayIsValidFunc)(MirMesaEGLNativeDisplay* display);

=== modified file 'include/platform/mir/graphics/native_platform.h'
--- include/platform/mir/graphics/native_platform.h	2014-10-03 03:02:09 +0000
+++ include/platform/mir/graphics/native_platform.h	2014-11-25 17:45:03 +0000
@@ -32,7 +32,6 @@
 namespace graphics
 {
 class GraphicBufferAllocator;
-class BufferInitializer;
 class PlatformIPCPackage;
 class InternalClient;
 class BufferIpcMessage;
@@ -46,10 +45,7 @@
 public:
     NativePlatform() {}
 
-    virtual void initialize(std::shared_ptr<NestedContext> const& nested_context) = 0;
-
-    virtual std::shared_ptr<GraphicBufferAllocator> create_buffer_allocator(
-        std::shared_ptr<BufferInitializer> const& buffer_initializer) = 0;
+    virtual std::shared_ptr<GraphicBufferAllocator> create_buffer_allocator() = 0;
 
     virtual std::shared_ptr<PlatformIPCPackage> connection_ipc_package() = 0;
 
@@ -67,8 +63,12 @@
     NativePlatform& operator=(NativePlatform const&) = delete;
 };
 
-extern "C" typedef std::shared_ptr<NativePlatform>(*CreateNativePlatform)(std::shared_ptr<DisplayReport> const& report);
-extern "C" std::shared_ptr<NativePlatform> create_native_platform(std::shared_ptr<DisplayReport> const& report);
+extern "C" typedef std::shared_ptr<NativePlatform>(*CreateNativePlatform)(
+    std::shared_ptr<DisplayReport> const&,
+    std::shared_ptr<NestedContext> const&);
+extern "C" std::shared_ptr<NativePlatform> create_native_platform(
+    std::shared_ptr<DisplayReport> const& report,
+    std::shared_ptr<NestedContext> const&);
 }
 }
 

=== modified file 'include/platform/mir/graphics/platform.h'
--- include/platform/mir/graphics/platform.h	2014-09-24 17:01:33 +0000
+++ include/platform/mir/graphics/platform.h	2014-11-25 17:45:03 +0000
@@ -44,7 +44,6 @@
 {
 class Buffer;
 class Display;
-class BufferInitializer;
 class InternalClient;
 class DisplayReport;
 class DisplayConfigurationPolicy;
@@ -75,12 +74,8 @@
 
     /**
      * Creates the buffer allocator subsystem.
-     *
-     * \param [in] buffer_initializer the object responsible for initializing the buffers
      */
-
-    virtual std::shared_ptr<GraphicBufferAllocator> create_buffer_allocator(
-        std::shared_ptr<BufferInitializer> const& buffer_initializer) = 0;
+    virtual std::shared_ptr<GraphicBufferAllocator> create_buffer_allocator() = 0;
     
     virtual std::shared_ptr<BufferWriter> make_buffer_writer() = 0;
 

=== modified file 'include/platform/mir/graphics/platform_ipc_operations.h'
--- include/platform/mir/graphics/platform_ipc_operations.h	2014-10-03 03:02:09 +0000
+++ include/platform/mir/graphics/platform_ipc_operations.h	2014-11-25 17:45:03 +0000
@@ -19,6 +19,7 @@
 #ifndef MIR_GRAPHICS_PLATFORM_IPC_OPERATIONS_H_
 #define MIR_GRAPHICS_PLATFORM_IPC_OPERATIONS_H_
 
+#include "platform_ipc_package.h"
 #include <memory>
 
 namespace mir
@@ -32,7 +33,6 @@
 };
 class Buffer;
 class BufferIpcMessage;
-struct PlatformIPCPackage;
 
 class PlatformIpcOperations
 {
@@ -68,6 +68,15 @@
      */
     virtual std::shared_ptr<PlatformIPCPackage> connection_ipc_package() = 0;
 
+    
+    /**
+     * Arranges a platform specific operation triggered by an IPC call
+     * \returns              the response that will be sent to the client
+     * \param [in]  opcode   the opcode that indicates the action to be performed 
+     * \param [in]  request  the message that was sent to the server
+     */
+    virtual PlatformIPCPackage platform_operation(unsigned int const opcode, PlatformIPCPackage const& package) = 0; 
+
 protected:
     PlatformIpcOperations() = default;
     PlatformIpcOperations(PlatformIpcOperations const&) = delete;

=== modified file 'include/platform/mir/graphics/platform_ipc_package.h'
--- include/platform/mir/graphics/platform_ipc_package.h	2014-10-03 03:02:09 +0000
+++ include/platform/mir/graphics/platform_ipc_package.h	2014-11-25 17:45:03 +0000
@@ -32,7 +32,6 @@
  */
 struct PlatformIPCPackage
 {
-    virtual ~PlatformIPCPackage() {}
     std::vector<int32_t> ipc_data;
     std::vector<int32_t> ipc_fds;
 };

=== modified file 'include/platform/mir/options/configuration.h'
--- include/platform/mir/options/configuration.h	2014-09-30 06:11:33 +0000
+++ include/platform/mir/options/configuration.h	2014-11-25 17:45:03 +0000
@@ -43,15 +43,12 @@
 extern char const* const frontend_threads_opt;
 extern char const* const touchspots_opt;
 extern char const* const fatal_abort_opt;
+extern char const* const debug_opt;
+extern char const* const use_asio_main_loop_opt;
 
 extern char const* const name_opt;
 extern char const* const offscreen_opt;
 
-extern char const* const glog;
-extern char const* const glog_stderrthreshold;
-extern char const* const glog_minloglevel;
-extern char const* const glog_log_dir;
-
 extern char const* const off_opt_value;
 extern char const* const log_opt_value;
 extern char const* const lttng_opt_value;

=== renamed file 'src/include/server/mir/compositor/display_buffer_compositor.h' => 'include/server/mir/compositor/display_buffer_compositor.h'
--- src/include/server/mir/compositor/display_buffer_compositor.h	2014-10-03 03:02:09 +0000
+++ include/server/mir/compositor/display_buffer_compositor.h	2014-11-25 17:45:03 +0000
@@ -20,6 +20,8 @@
 #ifndef MIR_COMPOSITOR_DISPLAY_BUFFER_COMPOSITOR_H_
 #define MIR_COMPOSITOR_DISPLAY_BUFFER_COMPOSITOR_H_
 
+#include "mir/compositor/scene.h"
+
 namespace mir
 {
 namespace compositor
@@ -30,7 +32,7 @@
 public:
     virtual ~DisplayBufferCompositor() = default;
 
-    virtual void composite() = 0;
+    virtual void composite(SceneElementSequence&& scene_sequence) = 0;
 
 protected:
     DisplayBufferCompositor() = default;

=== renamed file 'src/include/server/mir/compositor/display_buffer_compositor_factory.h' => 'include/server/mir/compositor/display_buffer_compositor_factory.h'
=== modified file 'include/server/mir/compositor/scene_element.h'
--- include/server/mir/compositor/scene_element.h	2014-10-03 03:02:09 +0000
+++ include/server/mir/compositor/scene_element.h	2014-11-25 17:45:03 +0000
@@ -19,7 +19,6 @@
 #ifndef MIR_COMPOSITOR_SCENE_ELEMENT_H_
 #define MIR_COMPOSITOR_SCENE_ELEMENT_H_
 
-#include "mir/compositor/compositor_id.h"
 #include <memory>
 
 namespace mir
@@ -37,8 +36,8 @@
     virtual ~SceneElement() = default;
 
     virtual std::shared_ptr<graphics::Renderable> renderable() const = 0;
-    virtual void rendered_in(CompositorID cid) = 0;
-    virtual void occluded_in(CompositorID cid) = 0;
+    virtual void rendered() = 0;
+    virtual void occluded() = 0;
     
     // Query whether the SceneElement represents a window-surface, which at the discretion of the compositor
     // may be eligible for window decoration.

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2014-09-30 06:11:33 +0000
+++ include/server/mir/default_server_configuration.h	2014-11-25 17:45:03 +0000
@@ -26,7 +26,12 @@
 
 namespace android
 {
+class EventHubInterface;
+class InputReaderInterface;
+class InputReaderPolicyInterface;
+class InputListenerInterface;
 class InputDispatcherInterface;
+class InputEnumerator;
 class InputDispatcherPolicyInterface;
 }
 
@@ -96,13 +101,13 @@
 class SceneReport;
 class PromptSessionListener;
 class PromptSessionManager;
+class CoordinateTranslator;
 }
 namespace graphics
 {
 class NativePlatform;
 class Platform;
 class Display;
-class BufferInitializer;
 class DisplayReport;
 class GraphicBufferAllocator;
 class BufferWriter;
@@ -119,7 +124,6 @@
 class InputManager;
 class CompositeEventFilter;
 class InputChannelFactory;
-class InputConfiguration;
 class CursorListener;
 class TouchVisualizer;
 class InputRegion;
@@ -169,7 +173,6 @@
     std::shared_ptr<ServerStatusListener>   the_server_status_listener() override;
     std::shared_ptr<DisplayChanger>         the_display_changer() override;
     std::shared_ptr<graphics::Platform>     the_graphics_platform() override;
-    std::shared_ptr<input::InputConfiguration> the_input_configuration() override;
     std::shared_ptr<input::InputDispatcher> the_input_dispatcher() override;
     std::shared_ptr<EmergencyCleanup>  the_emergency_cleanup() override;
     /**
@@ -186,7 +189,6 @@
     /** @name graphics configuration - customization
      * configurable interfaces for modifying graphics
      *  @{ */
-    virtual std::shared_ptr<graphics::BufferInitializer> the_buffer_initializer();
     virtual std::shared_ptr<compositor::RendererFactory>   the_renderer_factory();
     virtual std::shared_ptr<graphics::DisplayConfigurationPolicy> the_display_configuration_policy();
     virtual std::shared_ptr<graphics::nested::HostConnection> the_host_connection();
@@ -285,6 +287,7 @@
      *  @{ */
     // To customize this behaviour it is recommended you override wrap_session_coordinator().
     virtual std::shared_ptr<scene::SessionCoordinator>  the_session_coordinator();
+    virtual std::shared_ptr<scene::CoordinateTranslator> the_coordinate_translator();
     /** @} */
 
 
@@ -299,6 +302,11 @@
     virtual std::shared_ptr<input::InputRegion>    the_input_region();
     virtual std::shared_ptr<input::InputSender>    the_input_sender();
     virtual std::shared_ptr<input::InputSendObserver> the_input_send_observer();
+    virtual std::shared_ptr<droidinput::EventHubInterface> the_event_hub();
+    virtual std::shared_ptr<droidinput::InputReaderInterface> the_input_reader();
+    virtual std::shared_ptr<droidinput::InputReaderPolicyInterface> the_input_reader_policy();
+    virtual std::shared_ptr<droidinput::InputListenerInterface> the_input_translator();
+    virtual std::shared_ptr<input::android::InputThread> the_input_reader_thread();
     /** @} */
 
     /** @name logging configuration - customization
@@ -323,6 +331,7 @@
      *  @{ */
     virtual std::shared_ptr<input::android::InputRegistrar> the_input_registrar();
     virtual std::shared_ptr<droidinput::InputDispatcherInterface> the_android_input_dispatcher();
+    virtual std::shared_ptr<droidinput::InputEnumerator> the_input_target_enumerator();
     virtual std::shared_ptr<input::android::InputThread> the_dispatcher_thread();
     virtual std::shared_ptr<droidinput::InputDispatcherPolicyInterface> the_dispatcher_policy();
     virtual bool is_key_repeat_enabled() const;
@@ -330,23 +339,33 @@
 
     /** @Convenience wrapper functions
      *  @{ */
+    virtual std::shared_ptr<graphics::DisplayConfigurationPolicy> wrap_display_configuration_policy(
+        std::shared_ptr<graphics::DisplayConfigurationPolicy> const& wrapped);
+
     virtual std::shared_ptr<scene::SurfaceCoordinator>  wrap_surface_coordinator(
         std::shared_ptr<scene::SurfaceCoordinator> const& wrapped);
 
     virtual std::shared_ptr<scene::SessionCoordinator>  wrap_session_coordinator(
         std::shared_ptr<scene::SessionCoordinator> const& wrapped);
+
+    virtual std::shared_ptr<input::CursorListener>  wrap_cursor_listener(
+        std::shared_ptr<input::CursorListener> const& wrapped);
 /** @} */
 
     CachedPtr<input::android::InputRegistrar> input_registrar;
     CachedPtr<input::android::InputThread> dispatcher_thread;
+    CachedPtr<input::android::InputThread> input_reader_thread;
     CachedPtr<droidinput::InputDispatcherInterface> android_input_dispatcher;
+    CachedPtr<droidinput::InputEnumerator> input_target_enumerator;
     CachedPtr<droidinput::InputDispatcherPolicyInterface> android_dispatcher_policy;
+    CachedPtr<droidinput::EventHubInterface> event_hub;
+    CachedPtr<droidinput::InputReaderPolicyInterface> input_reader_policy;
+    CachedPtr<droidinput::InputReaderInterface> input_reader;
+    CachedPtr<droidinput::InputListenerInterface> input_translator;
 
     CachedPtr<frontend::Connector>   connector;
     CachedPtr<frontend::Connector>   prompt_connector;
 
-    CachedPtr<input::InputConfiguration> input_configuration;
-
     CachedPtr<input::InputReport> input_report;
     CachedPtr<input::CompositeEventFilter> composite_event_filter;
     CachedPtr<input::InputManager>    input_manager;
@@ -359,7 +378,6 @@
     CachedPtr<input::TouchVisualizer> touch_visualizer;
     CachedPtr<graphics::Platform>     graphics_platform;
     CachedPtr<graphics::NativePlatform>    graphics_native_platform;
-    CachedPtr<graphics::BufferInitializer> buffer_initializer;
     CachedPtr<graphics::GraphicBufferAllocator> buffer_allocator;
     CachedPtr<graphics::BufferWriter> buffer_writer;
     CachedPtr<graphics::Display>      display;
@@ -396,8 +414,7 @@
     CachedPtr<compositor::CompositorReport> compositor_report;
     CachedPtr<logging::Logger> logger;
     CachedPtr<graphics::DisplayReport> display_report;
-    // static to workaround the singleton clock in AsioMainLoop when running multiple servers
-    static CachedPtr<time::Clock> clock;
+    CachedPtr<time::Clock> clock;
     CachedPtr<MainLoop> main_loop;
     CachedPtr<ServerStatusListener> server_status_listener;
     CachedPtr<graphics::DisplayConfigurationPolicy> display_configuration_policy;
@@ -408,6 +425,7 @@
     CachedPtr<scene::PromptSessionListener> prompt_session_listener;
     CachedPtr<scene::PromptSessionManager> prompt_session_manager;
     CachedPtr<scene::SessionCoordinator> session_coordinator;
+    CachedPtr<scene::CoordinateTranslator> coordinate_translator;
     CachedPtr<EmergencyCleanup> emergency_cleanup;
     CachedPtr<shell::HostLifecycleEventListener> host_lifecycle_event_listener;
 

=== removed file 'include/server/mir/input/input_configuration.h'
--- include/server/mir/input/input_configuration.h	2014-10-03 03:02:09 +0000
+++ include/server/mir/input/input_configuration.h	1970-01-01 00:00:00 +0000
@@ -1,46 +0,0 @@
-/*
- * Copyright © 2014 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Andreas Pokorny <[e-mail]>
- */
-
-#ifndef MIR_INPUT_INPUT_CONFIGURATION_H_
-#define MIR_INPUT_INPUT_CONFIGURATION_H_
-
-#include <memory>
-
-namespace mir
-{
-namespace input
-{
-class InputManager;
-
-class InputConfiguration
-{
-public:
-    virtual ~InputConfiguration() = default;
-
-    virtual std::shared_ptr<InputManager> the_input_manager() = 0;
-
-protected:
-    InputConfiguration() = default;
-    InputConfiguration(InputConfiguration const&) = delete;
-    InputConfiguration& operator=(InputConfiguration const&) = delete;
-};
-
-}
-}
-
-#endif

=== modified file 'include/server/mir/report_exception.h'
--- include/server/mir/report_exception.h	2013-04-25 16:52:27 +0000
+++ include/server/mir/report_exception.h	2014-11-25 17:45:03 +0000
@@ -29,6 +29,12 @@
  *  to write error information to an output stream.
  */
 void report_exception(std::ostream& out);
+
+/**
+ *  Call this from a catch block (and only from a catch block)
+ *  to write error information to std:cerr.
+ */
+void report_exception();
 }
 
 

=== modified file 'include/server/mir/run_mir.h'
--- include/server/mir/run_mir.h	2014-09-11 05:51:44 +0000
+++ include/server/mir/run_mir.h	2014-11-25 17:45:03 +0000
@@ -38,11 +38,19 @@
     ServerConfiguration& config,
     std::function<void(DisplayServer&)> init);
 
-void report_exception(std::ostream& out);
+/**
+ *  Run a DisplayServer with the supplied configuration.
+ *  init will be called after constructing the server, but before invoking DisplayServer::run()
+ *  The terminator will be called following receipt of SIGTERM or SIGINT
+ *  (but not in a signal handler - so arbitrary functions may be invoked).
+ *  This function does not return until the server has stopped.
+ */
+void run_mir(
+    ServerConfiguration& config,
+    std::function<void(DisplayServer&)> init,
+    std::function<void(int)> const& terminator);
 
 void terminate_with_current_exception();
 }
 
-
-
 #endif /* MIR_RUN_MIR_H_ */

=== added file 'include/server/mir/scene/coordinate_translator.h'
--- include/server/mir/scene/coordinate_translator.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/scene/coordinate_translator.h	2014-11-25 17:45:03 +0000
@@ -0,0 +1,66 @@
+/*
+ * 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: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#ifndef MIR_SCENE_COORDINATE_TRANSLATOR_H_
+#define MIR_SCENE_COORDINATE_TRANSLATOR_H_
+
+#include "mir/geometry/point.h"
+#include <memory>
+
+namespace mir
+{
+namespace frontend
+{
+class Surface;
+}
+
+namespace scene
+{
+
+/**
+ * Support for the debug "surface to screen" coordinate translation interface.
+ * \note For shells which do surface transformations the default implementation
+ *       will return incorrect results.
+ */
+class CoordinateTranslator
+{
+public:
+    virtual ~CoordinateTranslator() = default;
+
+    /**
+     * \brief Translate a surface coordinate into the screen coordinate space
+     * \param [in] surface  A frontend::Surface. This will need to be dynamic_cast into
+     *                      the scene::Surface relevant for the shell.
+     * \param [in] x, y     Coordinates to translate from the surface coordinate space
+     * \return              The coordinates in the screen coordinate space.
+     * \throws              A std::runtime_error if the translation cannot be performed
+     *                      for any reason.
+     *
+     * \note It is acceptable for this call to unconditionally throw a std::runtime_error.
+     *       It is not required for normal functioning of the server or clients; clients which
+     *       use the debug extension will receive an appropriate failure notice.
+     */
+    virtual geometry::Point surface_to_screen(std::shared_ptr<frontend::Surface> surface,
+                                              int32_t x, int32_t y) = 0;
+};
+
+
+}
+}
+
+#endif // MIR_SCENE_COORDINATE_TRANSLATOR_H_

=== renamed file 'src/include/server/mir/scene/null_session_listener.h' => 'include/server/mir/scene/null_session_listener.h'
=== modified file 'include/server/mir/scene/null_surface_observer.h'
--- include/server/mir/scene/null_surface_observer.h	2014-09-11 05:51:44 +0000
+++ include/server/mir/scene/null_surface_observer.h	2014-11-25 17:45:03 +0000
@@ -31,16 +31,16 @@
     NullSurfaceObserver() = default;
     virtual ~NullSurfaceObserver() = default;
 
-    void attrib_changed(MirSurfaceAttrib attrib, int value);
-    void resized_to(geometry::Size const& size);
-    void moved_to(geometry::Point const& top_left);
-    void hidden_set_to(bool hide);
-    void frame_posted(int frames_available);
-    void alpha_set_to(float alpha);
+    void attrib_changed(MirSurfaceAttrib attrib, int value) override;
+    void resized_to(geometry::Size const& size) override;
+    void moved_to(geometry::Point const& top_left) override;
+    void hidden_set_to(bool hide) override;
+    void frame_posted(int frames_available) override;
+    void alpha_set_to(float alpha) override;
     void orientation_set_to(MirOrientation orientation) override;
-    void transformation_set_to(glm::mat4 const& t);
-    void cursor_image_set_to(graphics::CursorImage const& image);
-    void reception_mode_set_to(input::InputReceptionMode mode);
+    void transformation_set_to(glm::mat4 const& t) override;
+    void cursor_image_set_to(graphics::CursorImage const& image) override;
+    void reception_mode_set_to(input::InputReceptionMode mode) override;
 
 protected:
     NullSurfaceObserver(NullSurfaceObserver const&) = delete;

=== modified file 'include/server/mir/scene/surface.h'
--- include/server/mir/scene/surface.h	2014-09-11 05:51:44 +0000
+++ include/server/mir/scene/surface.h	2014-11-25 17:45:03 +0000
@@ -30,7 +30,7 @@
 {
 namespace input { class InputChannel; }
 namespace shell { class InputTargeter; }
-namespace geometry { class Rectangle; }
+namespace geometry { struct Rectangle; }
 namespace graphics { class CursorImage; }
 
 namespace scene
@@ -85,15 +85,15 @@
     virtual void set_orientation(MirOrientation orientation) = 0;
     virtual void force_requests_to_complete() = 0;
     
-    virtual void set_cursor_image(std::shared_ptr<graphics::CursorImage> const& image) = 0;
-    virtual std::shared_ptr<graphics::CursorImage> cursor_image() const = 0;
+    virtual void set_cursor_image(std::shared_ptr<graphics::CursorImage> const& image) override = 0;
+    virtual std::shared_ptr<graphics::CursorImage> cursor_image() const override = 0;
 
     virtual void add_observer(std::shared_ptr<SurfaceObserver> const& observer) = 0;
     virtual void remove_observer(std::weak_ptr<SurfaceObserver> const& observer) = 0;
 
     // TODO input_channel() relates to adding and removing the surface
     // TODO from the scene and is probably not cleanest interface for this.
-    virtual std::shared_ptr<input::InputChannel> input_channel() const = 0;
+    virtual std::shared_ptr<input::InputChannel> input_channel() const override = 0;
     virtual void set_reception_mode(input::InputReceptionMode mode) = 0;
 };
 }

=== added file 'include/server/mir/server.h'
--- include/server/mir/server.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/server.h	2014-11-25 17:45:03 +0000
@@ -0,0 +1,340 @@
+/*
+ * 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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIR_SERVER_H_
+#define MIR_SERVER_H_
+
+#include <functional>
+#include <memory>
+
+namespace mir
+{
+namespace compositor { class Compositor; class DisplayBufferCompositorFactory; }
+namespace frontend { class SessionAuthorizer; class Session; }
+namespace graphics { class Platform; class Display; class GLConfig; class DisplayConfigurationPolicy; }
+namespace input { class CompositeEventFilter; class InputDispatcher; class CursorListener; class TouchVisualizer; }
+namespace logging { class Logger; }
+namespace options { class Option; }
+namespace shell { class FocusController; class FocusSetter; class DisplayLayout; }
+namespace scene
+{
+class PlacementStrategy;
+class PromptSessionListener;
+class PromptSessionManager;
+class SessionListener;
+class SessionCoordinator;
+class SurfaceConfigurator;
+class SurfaceCoordinator;
+}
+
+class Fd;
+class MainLoop;
+class ServerStatusListener;
+
+enum class OptionType
+{
+    null,
+    integer,
+    string,
+    boolean
+};
+
+/// Customise and run a Mir server.
+class Server
+{
+public:
+    Server();
+
+/** @name Essential operations
+ * These are the commands used to run and stop.
+ *  @{ */
+    /// set the command line.
+    /// This must remain valid while apply_settings() and run() are called.
+    void set_command_line(int argc, char const* argv[]);
+
+    /// Applies any configuration options, hooks, or custom implementations.
+    /// Must be called before calling run() or accessing any mir subsystems.
+    void apply_settings();
+
+    /// Run the Mir server until it exits
+    void run();
+
+    /// Tell the Mir server to exit
+    void stop();
+
+    /// returns true if and only if server exited normally. Otherwise false.
+    bool exited_normally();
+/** @} */
+
+/** @name Configuration options
+ *  These functions allow customization of the handling of configuration
+ * options. The add and set functions should be called before apply_settings()
+ * otherwise they throw a std::logic_error.
+ *  @{ */
+    /// Add user configuration option(s) to Mir's option handling.
+    /// These will be resolved during initialisation from the command line,
+    /// environment variables, a config file or the supplied default.
+    void add_configuration_option(
+        std::string const& option,
+        std::string const& description,
+        int default_value);
+
+    /// Add user configuration option(s) to Mir's option handling.
+    /// These will be resolved during initialisation from the command line,
+    /// environment variables, a config file or the supplied default.
+    void add_configuration_option(
+        std::string const& option,
+        std::string const& description,
+        std::string const& default_value);
+
+    /// Add user configuration option(s) to Mir's option handling.
+    /// These will be resolved during initialisation from the command line,
+    /// environment variables, a config file or the supplied default.
+    void add_configuration_option(
+        std::string const& option,
+        std::string const& description,
+        char const* default_value);
+
+    /// Add user configuration option(s) to Mir's option handling.
+    /// These will be resolved during initialisation from the command line,
+    /// environment variables, a config file or the supplied default.
+    void add_configuration_option(
+        std::string const& option,
+        std::string const& description,
+        bool default_value);
+
+    /// Add user configuration option(s) to Mir's option handling.
+    /// These will be resolved during initialisation from the command line,
+    /// environment variables, a config file or the supplied default.
+    void add_configuration_option(
+        std::string const& option,
+        std::string const& description,
+        OptionType type);
+
+    /// Set a handler for any command line options Mir does not recognise.
+    /// This will be invoked if any unrecognised options are found during initialisation.
+    /// Any unrecognised arguments are passed to this function. The pointers remain valid
+    /// for the duration of the call only.
+    /// If set_command_line_handler is not called the default action is to exit by
+    /// throwing mir::AbnormalExit (which will be handled by the exception handler prior to
+    /// exiting run().
+    void set_command_line_handler(
+        std::function<void(int argc, char const* const* argv)> const& command_line_hander);
+
+    /// Set the configuration filename.
+    /// This will be searched for and parsed in the standard locations. Vis:
+    /// 1. $XDG_CONFIG_HOME (if set, otherwise $HOME/.config (if set))
+    /// 2. $XDG_CONFIG_DIRS (if set, otherwise /etc/xdg)
+    void set_config_filename(std::string const& config_file);
+
+    /// Returns the configuration options.
+    /// This will be null before initialization starts. It will be available
+    /// when the init_callback has been invoked (and thereafter until the server exits).
+    auto get_options() const -> std::shared_ptr<options::Option>;
+/** @} */
+
+/** @name Using hooks into the run() logic
+ *  These allow the user to insert logic into startup or error handling.
+ *  For obvious reasons they should be called before run().
+ *  @{ */
+    /// Add a callback to be invoked when the server has been initialized,
+    /// but before it starts. This allows client code to get access Mir objects.
+    /// If multiple callbacks are added they will be invoked in the sequence added.
+    void add_init_callback(std::function<void()> const& init_callback);
+
+    /// Set a handler for exceptions. This is invoked in a catch (...) block and
+    /// the exception can be re-thrown to retrieve type information.
+    /// The default action is to call mir::report_exception(std::cerr)
+    void set_exception_handler(std::function<void()> const& exception_handler);
+
+    /// Functor for processing SIGTERM or SIGINT
+    /// This will not be called directly by a signal handler: arbitrary functions may be invoked.
+    using Terminator = std::function<void(int signal)>;
+
+    /// Set handler for termination requests.
+    /// terminator will be called following receipt of SIGTERM or SIGINT.
+    /// The default terminator stop()s the server, replacements should probably
+    /// do the same in addition to any additional shutdown logic.
+    void set_terminator(Terminator const& terminator);
+
+    /// Functor for processing fatal signals for any "emergency cleanup".
+    /// That is: SIGQUIT, SIGABRT, SIGFPE, SIGSEGV & SIGBUS
+    ///
+    /// \warning This will be called directly by a signal handler:
+    /// Only async-signal-safe functions may be called
+    using EmergencyCleanupHandler = std::function<void()>;
+
+    /// Add cleanup for abnormal terminations.
+    /// handler will be called on receipt of a fatal signal after which the
+    /// default signal-handler will terminate the process.
+    void add_emergency_cleanup(EmergencyCleanupHandler const& handler);
+/** @} */
+
+/** @name Providing custom implementation
+ * Provide alternative implementations of Mir subsystems: the functors will be invoked
+ * during initialization of the Mir server (or when accessor methods are called).
+ * They should be called before apply_settings() otherwise they throw a std::logic_error.
+ *  @{ */
+    /// Each of the override functions takes a builder functor of the same form
+    /// \note If a null pointer is returned by the builder the default is used instead.
+    template<typename T> using Builder = std::function<std::shared_ptr<T>()>;
+
+    /// Sets an override functor for creating the compositor.
+    void override_the_compositor(Builder<compositor::Compositor> const& compositor_builder);
+
+    /// Sets an override functor for creating the per-display rendering code.
+    void override_the_display_buffer_compositor_factory(
+        Builder<compositor::DisplayBufferCompositorFactory> const& compositor_builder);
+
+    /// Sets an override functor for creating the gl config.
+    void override_the_gl_config(Builder<graphics::GLConfig> const& gl_config_builder);
+
+    /// Sets an override functor for creating the input dispatcher.
+    void override_the_input_dispatcher(Builder<input::InputDispatcher> const& input_dispatcher_builder);
+
+    /// Sets an override functor for creating the logger.
+    void override_the_logger(Builder<logging::Logger> const& logger_builder);
+
+    /// Sets an override functor for creating the placement strategy.
+    void override_the_placement_strategy(Builder<scene::PlacementStrategy> const& placement_strategy_builder);
+
+    /// Sets an override functor for creating the prompt session listener.
+    void override_the_prompt_session_listener(Builder<scene::PromptSessionListener> const& prompt_session_listener_builder);
+
+    /// Sets an override functor for creating the prompt session manager.
+    void override_the_prompt_session_manager(Builder<scene::PromptSessionManager> const& prompt_session_manager_builder);
+
+    /// Sets an override functor for creating the status listener.
+    void override_the_server_status_listener(Builder<ServerStatusListener> const& server_status_listener_builder);
+
+    /// Sets an override functor for creating the session authorizer.
+    void override_the_session_authorizer(Builder<frontend::SessionAuthorizer> const& session_authorizer_builder);
+
+    /// Sets an override functor for creating the session listener.
+    void override_the_session_listener(Builder<scene::SessionListener> const& session_listener_builder);
+
+    /// Sets an override functor for creating the shell focus setter.
+    void override_the_shell_focus_setter(Builder<shell::FocusSetter> const& focus_setter_builder);
+
+    /// Sets an override functor for creating the surface configurator.
+    void override_the_surface_configurator(Builder<scene::SurfaceConfigurator> const& surface_configurator_builder);
+
+    /// Each of the wrap functions takes a wrapper functor of the same form
+    template<typename T> using Wrapper = std::function<std::shared_ptr<T>(std::shared_ptr<T> const&)>;
+
+    /// Sets a wrapper functor for creating the cursor listener.
+    void wrap_cursor_listener(Wrapper<input::CursorListener> const& wrapper);
+
+    /// Sets a wrapper functor for creating the display configuration policy.
+    void wrap_display_configuration_policy(Wrapper<graphics::DisplayConfigurationPolicy> const& wrapper);
+
+    /// Sets a wrapper functor for creating the session coordinator.
+    void wrap_session_coordinator(Wrapper<scene::SessionCoordinator> const& wrapper);
+
+    /// Sets a wrapper functor for creating the surface coordinator.
+    void wrap_surface_coordinator(Wrapper<scene::SurfaceCoordinator> const& wrapper);
+/** @} */
+
+/** @name Getting access to Mir subsystems
+ * These may be invoked by the functors that provide alternative implementations of
+ * Mir subsystems.
+ * They should only be used after apply_settings() is called - otherwise they throw
+ *  a std::logic_error.
+ *  @{ */
+    /// \return the compositor.
+    auto the_compositor() const -> std::shared_ptr<compositor::Compositor>;
+
+    /// \return the composite event filter.
+    auto the_composite_event_filter() const -> std::shared_ptr<input::CompositeEventFilter>;
+
+    /// \return the cursor listener.
+    auto the_cursor_listener() const -> std::shared_ptr<input::CursorListener>;
+
+    /// \return the focus controller.
+    auto the_focus_controller() const -> std::shared_ptr<shell::FocusController>;
+
+    /// \return the graphics display.
+    auto the_display() const -> std::shared_ptr<graphics::Display>;
+
+    /// \return the GL config.
+    auto the_gl_config() const -> std::shared_ptr<graphics::GLConfig>;
+
+    /// \return the graphics platform.
+    auto the_graphics_platform() const -> std::shared_ptr<graphics::Platform>;
+
+    /// \return the main loop.
+    auto the_main_loop() const -> std::shared_ptr<MainLoop>;
+
+    /// \return the prompt session listener.
+    auto the_prompt_session_listener() const -> std::shared_ptr<scene::PromptSessionListener>;
+
+    /// \return the prompt session manager.
+    auto the_prompt_session_manager() const ->std::shared_ptr<scene::PromptSessionManager>;
+
+    /// \return the session authorizer.
+    auto the_session_authorizer() const -> std::shared_ptr<frontend::SessionAuthorizer>;
+
+    /// \return the session coordinator.
+    auto the_session_coordinator() const -> std::shared_ptr<scene::SessionCoordinator>;
+
+    /// \return the session listener.
+    auto the_session_listener() const -> std::shared_ptr<scene::SessionListener>;
+
+    /// \return the display layout.
+    auto the_shell_display_layout() const -> std::shared_ptr<shell::DisplayLayout>;
+
+    /// \return the surface configurator.
+    auto the_surface_configurator() const -> std::shared_ptr<scene::SurfaceConfigurator>;
+
+    /// \return the surface coordinator.
+    auto the_surface_coordinator() const -> std::shared_ptr<scene::SurfaceCoordinator>;
+
+    /// \return the touch visualizer.
+    auto the_touch_visualizer() const -> std::shared_ptr<input::TouchVisualizer>;
+/** @} */
+
+/** @name Client side support
+ * These facilitate use of the server through the client API.
+ * They should be called while the server is running (i.e. run() has been called and
+ * not exited) otherwise they throw a std::logic_error.
+ * @{ */
+    using ConnectHandler = std::function<void(std::shared_ptr<frontend::Session> const& session)>;
+
+    /// Get a file descriptor that can be used to connect a client
+    /// It can be passed to another process, or used directly with mir_connect()
+    /// using the format "fd://%d".
+    auto open_client_socket() -> Fd;
+
+    /// Get a file descriptor that can be used to connect a client
+    /// It can be passed to another process, or used directly with mir_connect()
+    /// using the format "fd://%d".
+    /// \param connect_handler callback to be invoked when the client connects
+    auto open_client_socket(ConnectHandler const& connect_handler) -> Fd;
+
+    /// Get a file descriptor that can be used to connect a prompt provider
+    /// It can be passed to another process, or used directly with mir_connect()
+    /// using the format "fd://%d".
+    auto open_prompt_socket() -> Fd;
+/** @} */
+private:
+    struct ServerConfiguration;
+    struct Self;
+    std::shared_ptr<Self> const self;
+};
+}
+#endif /* SERVER_H_ */

=== modified file 'include/server/mir/server_configuration.h'
--- include/server/mir/server_configuration.h	2014-09-30 06:11:33 +0000
+++ include/server/mir/server_configuration.h	2014-11-25 17:45:03 +0000
@@ -69,7 +69,6 @@
     virtual std::shared_ptr<ServerStatusListener> the_server_status_listener() = 0;
     virtual std::shared_ptr<DisplayChanger> the_display_changer() = 0;
     virtual std::shared_ptr<graphics::Platform>  the_graphics_platform() = 0;
-    virtual std::shared_ptr<input::InputConfiguration> the_input_configuration() = 0;
     virtual std::shared_ptr<EmergencyCleanup> the_emergency_cleanup() = 0;
     virtual auto the_fatal_error_strategy() -> void (*)(char const* reason, ...) = 0;
 

=== modified file 'include/server/mir/shell/session_coordinator_wrapper.h'
--- include/server/mir/shell/session_coordinator_wrapper.h	2014-09-30 06:11:33 +0000
+++ include/server/mir/shell/session_coordinator_wrapper.h	2014-11-25 17:45:03 +0000
@@ -39,7 +39,7 @@
     virtual void close_session(std::shared_ptr<frontend::Session> const& session) override;
 
     void focus_next() override;
-    std::weak_ptr<scene::Session> focussed_application() const;
+    std::weak_ptr<scene::Session> focussed_application() const override;
     void set_focus_to(std::shared_ptr<scene::Session> const& focus) override;
 
     void handle_surface_created(std::shared_ptr<frontend::Session> const& session) override;

=== modified file 'include/server/mir/time/alarm.h'
--- include/server/mir/time/alarm.h	2014-09-11 05:51:44 +0000
+++ include/server/mir/time/alarm.h	2014-11-25 17:45:03 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_TIME_ALARM_H_
 #define MIR_TIME_ALARM_H_
 
-#include "mir/time/clock.h"
+#include "mir/time/types.h"
 
 namespace mir
 {

=== modified file 'platform-ABI-sha1sums'
--- platform-ABI-sha1sums	2014-10-03 03:02:09 +0000
+++ platform-ABI-sha1sums	2014-11-25 17:45:03 +0000
@@ -9,12 +9,12 @@
 dcf8b8982f138bdde39a241825c610e955cd5e33  include/common/mir/input/input_platform.h
 208cd6aed5ef5f8f39b3eb86604e4133cb840485  include/common/mir/input/input_receiver_thread.h
 be7d58c9fde2ce91cc66dd6144b76e08b536266b  include/common/mir/int_wrapper.h
-48015c67ddc4998ed5a2e8bb04ff3a4bfdd6a613  include/common/mir/time/clock.h
+9ae8473df05dd9e048a73797f01a2f34f7447554  include/common/mir/time/types.h
 9907751d046e4aea81881cf19e5df52c7a6a813e  include/common/mir_toolkit/client_types.h
-183d9e5e6cfe48b3d9145a28541dd4202ff6137b  include/common/mir_toolkit/common.h
+2100c0674d9d882c1845550847357f6a5de5af66  include/common/mir_toolkit/common.h
 fce4c1a9e0d037244f7e9e96ea2d8eaab4fc404c  include/common/mir_toolkit/cursors.h
 bdaceadd56e41d2cb708f7c4da97acf84dfc75b7  include/common/mir_toolkit/event.h
-99ef5f3bf548508fae24c60f74be1dea018a6e8c  include/common/mir_toolkit/mesa/native_display.h
+4975998aa1056ed0d39dcc538127453e516ad8e9  include/common/mir_toolkit/mesa/native_display.h
 101017c17714a57db57d79b7b5e7df40a3568236  include/common/mir_toolkit/mir_native_buffer.h
 871e609c0fed0d566ddbaaa8ac2d7cd5c06dd09a  include/platform/mir/abnormal_exit.h
 8f47feb6d983aa5c9ebd58e9d1524361c9f5e651  include/platform/mir/fatal.h
@@ -35,12 +35,12 @@
 979d2c1ac723ccef538d9a378228a02b0f173bd7  include/platform/mir/graphics/graphic_buffer_allocator.h
 f90a35371e236a6cfec8e9a8474dbb3305c7621e  include/platform/mir/graphics/internal_client.h
 c9730cac4a3a101f9706ec6f444958abe047fd88  include/platform/mir/graphics/internal_surface.h
-b4aaa941df9c0a6f9342629b26542700876f3aaa  include/platform/mir/graphics/native_platform.h
-f47dac961f060eb29a44ed3c8c18a49a3d353bb1  include/platform/mir/graphics/platform.h
-1fbe488b4581486fd01e2f03e504f31b72c09040  include/platform/mir/graphics/platform_ipc_operations.h
-9c7712af84b6fde1970ff802ad2ea78f892c7b7e  include/platform/mir/graphics/platform_ipc_package.h
+d062fde60f1caa3102560b0b50da9909e18b3449  include/platform/mir/graphics/native_platform.h
+109d2c82d245a512e7c1790a3b853c9c275ebd4d  include/platform/mir/graphics/platform.h
+3b3463d2513f4c3985f2400496dab333518f9a13  include/platform/mir/graphics/platform_ipc_operations.h
+1b77fb3290af00dc7d1c11dcc5388972dacb9ec3  include/platform/mir/graphics/platform_ipc_package.h
 84c063346b3bd51b4624d9f940008d4c3f8be066  include/platform/mir/graphics/renderable.h
-f5746dab3336266cfd410ce4e4d01333df6e5b99  include/platform/mir/options/configuration.h
+abeb45a8c6bfc81a12136f25e455e9803c32c10e  include/platform/mir/options/configuration.h
 47007c783c174f8e94d332c4b13c6b01358b48fb  include/platform/mir/options/default_configuration.h
 b45f14082c4f8b29efaa1b13de795dcb29deb738  include/platform/mir/options/option.h
 3c37cc31e8b290b89c311d82f02e07d342766451  include/platform/mir/options/program_option.h

=== modified file 'playground/CMakeLists.txt'
--- playground/CMakeLists.txt	2014-10-03 15:10:23 +0000
+++ playground/CMakeLists.txt	2014-11-25 17:45:03 +0000
@@ -8,6 +8,10 @@
   ${PROJECT_SOURCE_DIR}/examples/
 )
 
+add_library(playgroundserverconfig STATIC
+    server_configuration.cpp
+)
+
 set(RENDER_SURFACES_SOURCES
     render_surfaces.cpp
     buffer_render_target.cpp
@@ -16,6 +20,7 @@
 add_executable(mir_demo_standalone_render_surfaces ${RENDER_SURFACES_SOURCES})
 target_link_libraries(mir_demo_standalone_render_surfaces
     mirserver
+    playgroundserverconfig
     exampleserverconfig
     ${Boost_LIBRARIES}
 )

=== modified file 'playground/demo-inprocess-surface-client/CMakeLists.txt'
--- playground/demo-inprocess-surface-client/CMakeLists.txt	2014-10-03 15:46:20 +0000
+++ playground/demo-inprocess-surface-client/CMakeLists.txt	2014-11-25 17:45:03 +0000
@@ -7,6 +7,7 @@
 target_link_libraries(mir_demo_standalone_inprocess_egl
   mirserver
   mirdraw
+  playgroundserverconfig
   exampleserverconfig
 )
 # TODO Install this demo?

=== modified file 'playground/demo-inprocess-surface-client/demo_inprocess_surface_client.cpp'
--- playground/demo-inprocess-surface-client/demo_inprocess_surface_client.cpp	2014-09-12 05:56:28 +0000
+++ playground/demo-inprocess-surface-client/demo_inprocess_surface_client.cpp	2014-11-25 17:45:03 +0000
@@ -19,7 +19,7 @@
 #include "inprocess_egl_client.h"
 
 #include "mir/run_mir.h"
-#include "server_configuration.h"
+#include "../server_configuration.h"
 
 #include "mir/report_exception.h"
 

=== modified file 'playground/demo-shell/CMakeLists.txt'
--- playground/demo-shell/CMakeLists.txt	2014-09-30 06:11:33 +0000
+++ playground/demo-shell/CMakeLists.txt	2014-11-25 17:45:03 +0000
@@ -12,6 +12,7 @@
 target_link_libraries(mir_demo_server_shell
   demo-shell
   mirserver
+  playgroundserverconfig
   exampleserverconfig
 )
 

=== modified file 'playground/demo-shell/demo_compositor.cpp'
--- playground/demo-shell/demo_compositor.cpp	2014-09-30 06:11:33 +0000
+++ playground/demo-shell/demo_compositor.cpp	2014-11-25 17:45:03 +0000
@@ -18,7 +18,6 @@
 
 #include "mir/graphics/display_buffer.h"
 #include "mir/compositor/compositor_report.h"
-#include "mir/compositor/scene.h"
 #include "mir/compositor/scene_element.h"
 #include "mir/compositor/destination_alpha.h"
 #include "demo_compositor.h"
@@ -38,11 +37,9 @@
 
 me::DemoCompositor::DemoCompositor(
     mg::DisplayBuffer& display_buffer,
-    std::shared_ptr<mc::Scene> const& scene,
     mg::GLProgramFactory const& factory,
     std::shared_ptr<mc::CompositorReport> const& report) :
     display_buffer(display_buffer),
-    scene(scene),
     report(report),
     renderer(
         factory,
@@ -51,15 +48,13 @@
         30.0f, //titlebar_height
         80.0f) //shadow_radius
 {
-    scene->register_compositor(this);
 }
 
 me::DemoCompositor::~DemoCompositor()
 {
-    scene->unregister_compositor(this);
 }
 
-void me::DemoCompositor::composite()
+void me::DemoCompositor::composite(mc::SceneElementSequence&& elements)
 {
     report->began_frame(this);
     //a simple filtering out of renderables that shouldn't be drawn
@@ -68,7 +63,6 @@
     mg::RenderableList renderable_list;
     std::unordered_set<mg::Renderable::ID> decoration_skip_list;
 
-    auto elements = scene->scene_elements_for(this);
     for(auto const& it : elements)
     {
         auto const& renderable = it->renderable();
@@ -81,15 +75,35 @@
         if (renderable->visible() && any_part_drawn)
         {
             renderable_list.push_back(renderable);
-            it->rendered_in(this);
+
+            // Fullscreen and opaque? Definitely no embellishment
+            if (renderable->screen_position() == view_area &&
+                renderable->alpha() == 1.0f &&
+                !renderable->shaped() &&
+                renderable->transformation() == glm::mat4())
+            {
+                embellished = false;
+                nonrenderlist_elements = false; // Don't care what's underneath
+            }
+
+            it->rendered();
         }
         else
         {
-            it->occluded_in(this);
+            it->occluded();
         }
         nonrenderlist_elements |= embellished;
     }
 
+    /*
+     * Note: Buffer lifetimes are ensured by the two objects holding
+     *       references to them; elements and renderable_list.
+     *       So no buffer is going to be released back to the client till
+     *       both of those containers get destroyed (end of the function).
+     *       Actually, there's a third reference held by the texture cache
+     *       in GLRenderer, but that gets released earlier in render().
+     */
+
     if (!nonrenderlist_elements &&
         display_buffer.post_renderables_if_optimizable(renderable_list))
     {
@@ -104,7 +118,6 @@
         renderer.begin(std::move(decoration_skip_list));
         renderer.render(renderable_list);
         display_buffer.post_update();
-        renderer.end();
         report->finished_frame(false, this);
     }
 }

=== modified file 'playground/demo-shell/demo_compositor.h'
--- playground/demo-shell/demo_compositor.h	2014-09-30 06:11:33 +0000
+++ playground/demo-shell/demo_compositor.h	2014-11-25 17:45:03 +0000
@@ -43,16 +43,14 @@
 public:
     DemoCompositor(
         graphics::DisplayBuffer& display_buffer,
-        std::shared_ptr<compositor::Scene> const& scene,
         graphics::GLProgramFactory const& factory,
         std::shared_ptr<compositor::CompositorReport> const& report);
     ~DemoCompositor();
 
-    void composite() override;
+    void composite(compositor::SceneElementSequence&& elements) override;
 
 private:
     graphics::DisplayBuffer& display_buffer;
-    std::shared_ptr<compositor::Scene> const scene;
     std::shared_ptr<compositor::CompositorReport> const report;
     DemoRenderer renderer;
 };

=== modified file 'playground/demo-shell/demo_renderer.cpp'
--- playground/demo-shell/demo_renderer.cpp	2014-10-01 03:41:21 +0000
+++ playground/demo-shell/demo_renderer.cpp	2014-11-25 17:45:03 +0000
@@ -163,6 +163,9 @@
     titlebar_corner_tex = generate_frame_corner_texture(corner_radius,
                                                         {128,128,128,255},
                                                         255);
+
+    clear_color[0] = clear_color[1] = clear_color[2] = 0.2f;
+    clear_color[3] = 1.0f;
 }
 
 DemoRenderer::~DemoRenderer()
@@ -173,15 +176,6 @@
 
 void DemoRenderer::begin(std::unordered_set<graphics::Renderable::ID> decoration_skip_list_) const
 {
-    bool const opaque = destination_alpha() == compositor::DestinationAlpha::opaque;
-    glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
-
-    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-    glClear(GL_COLOR_BUFFER_BIT);
-
-    if (opaque)
-        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
-    
     decoration_skip_list = decoration_skip_list_;
 }
 

=== modified file 'playground/demo-shell/demo_renderer.h'
--- playground/demo-shell/demo_renderer.h	2014-09-30 06:11:33 +0000
+++ playground/demo-shell/demo_renderer.h	2014-11-25 17:45:03 +0000
@@ -39,7 +39,6 @@
         float const shadow_radius);
     ~DemoRenderer();
 
-    void begin() const override { GLRenderer::begin(); }
     void begin(std::unordered_set<graphics::Renderable::ID> renderables_not_to_decorate) const;
     
     void tessellate(

=== modified file 'playground/demo-shell/demo_shell.cpp'
--- playground/demo-shell/demo_shell.cpp	2014-09-12 05:56:28 +0000
+++ playground/demo-shell/demo_shell.cpp	2014-11-25 17:45:03 +0000
@@ -21,7 +21,7 @@
 #include "demo_compositor.h"
 #include "window_manager.h"
 #include "fullscreen_placement_strategy.h"
-#include "server_configuration.h"
+#include "../server_configuration.h"
 
 #include "mir/options/default_configuration.h"
 #include "mir/run_mir.h"
@@ -53,10 +53,8 @@
 {
 public:
     DisplayBufferCompositorFactory(
-        std::shared_ptr<mc::Scene> const& scene,
         std::shared_ptr<mg::GLProgramFactory> const& gl_program_factory,
         std::shared_ptr<mc::CompositorReport> const& report) :
-        scene(scene),
         gl_program_factory(gl_program_factory),
         report(report)
     {
@@ -66,11 +64,10 @@
         mg::DisplayBuffer& display_buffer) override
     {
         return std::unique_ptr<mc::DisplayBufferCompositor>(
-            new me::DemoCompositor{display_buffer, scene, *gl_program_factory, report});
+            new me::DemoCompositor{display_buffer, *gl_program_factory, report});
     }
 
 private:
-    std::shared_ptr<mc::Scene> const scene;
     std::shared_ptr<mg::GLProgramFactory> const gl_program_factory;
     std::shared_ptr<mc::CompositorReport> const report;
 };
@@ -96,13 +93,12 @@
     }
 
 
-    std::shared_ptr<compositor::DisplayBufferCompositorFactory> the_display_buffer_compositor_factory()
+    std::shared_ptr<compositor::DisplayBufferCompositorFactory> the_display_buffer_compositor_factory() override
     {
         return display_buffer_compositor_factory(
             [this]()
             {
                 return std::make_shared<me::DisplayBufferCompositorFactory>(
-                    the_scene(),
                     the_gl_program_factory(),
                     the_compositor_report());
             });

=== modified file 'playground/demo-shell/window_manager.cpp'
--- playground/demo-shell/window_manager.cpp	2014-09-12 05:56:28 +0000
+++ playground/demo-shell/window_manager.cpp	2014-11-25 17:45:03 +0000
@@ -123,7 +123,6 @@
     assert(compositor);
 
     bool handled = false;
-    static int const ANDROID_KEYCODE_POWER = 26;
 
     if (event.key.type == mir_event_type_key &&
         event.key.action == mir_key_action_down)
@@ -136,7 +135,7 @@
         }
         else if ((event.key.modifiers & mir_key_modifier_alt &&
                   event.key.scan_code == KEY_P) ||
-                 (event.key.key_code == ANDROID_KEYCODE_POWER))
+                 (event.key.scan_code == KEY_POWER))
         {
             compositor->stop();
             auto conf = display->configuration();
@@ -232,7 +231,37 @@
                 return true;
             }
         }
+        else if ((event.key.scan_code == KEY_VOLUMEDOWN ||
+                  event.key.scan_code == KEY_VOLUMEUP) &&
+                 max_fingers == 1)
+        {
+            int delta = (event.key.scan_code == KEY_VOLUMEDOWN) ? -1 : +1;
+            static const MirOrientation order[4] =
+            {
+                mir_orientation_normal,
+                mir_orientation_right,
+                mir_orientation_inverted,
+                mir_orientation_left
+            };
 
+            compositor->stop();
+            auto conf = display->configuration();
+            conf->for_each_output(
+                [&](mg::UserDisplayConfigurationOutput& output)
+                {
+                    int i = 0;
+                    for (; i < 4; ++i)
+                    {
+                        if (output.orientation == order[i])
+                            break;
+                    }
+                    output.orientation = order[(i+4+delta) % 4];
+                }
+            );
+            display->configure(*conf.get());
+            compositor->start();
+            return true;
+        }
     }
     else if (event.type == mir_event_type_motion &&
              focus_controller)
@@ -346,6 +375,9 @@
             }
         }
 
+        if (fingers == 1 && action == mir_motion_action_up)
+            max_fingers = 0;
+
         old_cursor = cursor;
     }
     return handled;

=== modified file 'playground/render_surfaces.cpp'
--- playground/render_surfaces.cpp	2014-09-12 05:56:28 +0000
+++ playground/render_surfaces.cpp	2014-11-25 17:45:03 +0000
@@ -25,7 +25,6 @@
 #include "mir/scene/surface_creation_parameters.h"
 #include "mir/geometry/size.h"
 #include "mir/geometry/rectangles.h"
-#include "mir/graphics/buffer_initializer.h"
 #include "mir/graphics/display.h"
 #include "mir/graphics/display_buffer.h"
 #include "mir/graphics/gl_context.h"
@@ -72,9 +71,7 @@
 ///\section RenderSurfacesServerConfiguration RenderSurfacesServerConfiguration
 /// The configuration stubs out client connectivity and input.
 /// \snippet render_surfaces.cpp RenderSurfacesServerConfiguration_stubs_tag
-/// it also provides a bespoke buffer initializer
-/// \snippet render_surfaces.cpp RenderResourcesBufferInitializer_tag
-/// and a bespoke display buffer compositor
+/// it also provides a bespoke display buffer compositor
 /// \snippet render_surfaces.cpp RenderSurfacesDisplayBufferCompositor_tag
 ///\section Utilities Utility classes
 /// For smooth animation we need to track time and move surfaces accordingly
@@ -238,8 +235,8 @@
     {
         struct NullConnector : public mf::Connector
         {
-            void start() {}
-            void stop() {}
+            void start() override {}
+            void stop() override {}
             int client_socket_fd() const override { return 0; }
             int client_socket_fd(std::function<void(std::shared_ptr<mf::Session> const&)> const&) const override { return 0; }
         };
@@ -248,44 +245,9 @@
     }
     ///\internal [RenderSurfacesServerConfiguration_stubs_tag]
 
-    ///\internal [RenderResourcesBufferInitializer_tag]
-    // Override for a bespoke buffer initializer
-    std::shared_ptr<mg::BufferInitializer> the_buffer_initializer() override
-    {
-        class RenderResourcesBufferInitializer : public mg::BufferInitializer
-        {
-        public:
-            RenderResourcesBufferInitializer(std::unique_ptr<mg::GLContext> gl_context)
-                : gl_context{std::move(gl_context)}
-            {
-            }
-
-            void operator()(mg::Buffer& buffer)
-            {
-                auto using_gl_context = mir::raii::paired_calls(
-                    [this] { gl_context->make_current(); },
-                    [this] { gl_context->release_current(); });
-
-                mt::ImageRenderer img_renderer{mir_image.pixel_data,
-                               geom::Size{mir_image.width, mir_image.height},
-                               mir_image.bytes_per_pixel};
-                mt::BufferRenderTarget brt{buffer};
-                brt.make_current();
-                img_renderer.render();
-            }
-
-        private:
-            std::unique_ptr<mg::GLContext> const gl_context;
-
-        };
-
-        return std::make_shared<RenderResourcesBufferInitializer>(the_display()->create_gl_context());
-    }
-    ///\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()
+    std::shared_ptr<mir::ServerStatusListener> the_server_status_listener() override
     {
         struct ServerStatusListener : mir::ServerStatusListener
         {
@@ -324,7 +286,7 @@
             {
             }
 
-            void composite()
+            void composite(mc::SceneElementSequence&& scene_sequence) override
             {
                 while (!created) std::this_thread::yield();
                 stop_watch.stop();
@@ -336,7 +298,7 @@
                 }
 
                 glClearColor(0.0, 1.0, 0.0, 1.0);
-                db_compositor->composite();
+                db_compositor->composite(std::move(scene_sequence));
 
                 for (auto& m : moveables)
                     m.step();
@@ -389,6 +351,8 @@
 
         auto const display = the_display();
         auto const surface_coordinator = the_surface_coordinator();
+        auto const gl_context = the_display()->create_gl_context();
+
         /* TODO: Get proper configuration */
         geom::Rectangles view_area;
         display->for_each_display_buffer([&view_area](mg::DisplayBuffer const& db)
@@ -413,16 +377,23 @@
                                    .of_buffer_usage(mg::BufferUsage::hardware),
                     nullptr);
 
-            /*
-             * We call swap_buffers() twice so that the surface is
-             * considers the first buffer to be posted.
-             * (TODO There must be a better way!)
-             */
             {
                 mg::Buffer* buffer{nullptr};
                 auto const complete = [&](mg::Buffer* new_buf){ buffer = new_buf; };
-                s->swap_buffers(buffer, complete);
-                s->swap_buffers(buffer, complete);
+                s->swap_buffers(buffer, complete); // Fetch buffer for rendering
+                {
+                    auto using_gl_context = mir::raii::paired_calls(
+                        [&gl_context] { gl_context->make_current(); },
+                        [&gl_context] { gl_context->release_current(); });
+
+                    mt::ImageRenderer img_renderer{mir_image.pixel_data,
+                                   geom::Size{mir_image.width, mir_image.height},
+                                   mir_image.bytes_per_pixel};
+                    mt::BufferRenderTarget brt{*buffer};
+                    brt.make_current();
+                    img_renderer.render();
+                }
+                s->swap_buffers(buffer, complete); // Post rendered buffer
             }
 
             /*

=== renamed file 'examples/server_configuration.cpp' => 'playground/server_configuration.cpp'
--- examples/server_configuration.cpp	2014-03-26 05:48:59 +0000
+++ playground/server_configuration.cpp	2014-11-25 17:45:03 +0000
@@ -18,122 +18,14 @@
 
 #include "server_configuration.h"
 #include "mir/options/default_configuration.h"
-#include "mir/graphics/display_configuration_policy.h"
-#include "mir/graphics/display_configuration.h"
 #include "mir/input/composite_event_filter.h"
 #include "mir/main_loop.h"
 
-#include <string>
-
-#include <linux/input.h>
-#include <unordered_map>
+#include "example_display_configuration_policy.h"
+#include "example_input_event_filter.h"
 
 namespace me = mir::examples;
 namespace mg = mir::graphics;
-namespace geom = mir::geometry;
-
-namespace
-{
-
-char const* const display_config_opt = "display-config";
-char const* const clone_opt_val = "clone";
-char const* const sidebyside_opt_val = "sidebyside";
-char const* const single_opt_val = "single";
-
-class SideBySideDisplayConfigurationPolicy : public mg::DisplayConfigurationPolicy
-{
-public:
-    void apply_to(mg::DisplayConfiguration& conf)
-    {
-        size_t const preferred_mode_index{0};
-        int max_x = 0;
-        std::unordered_map<mg::DisplayConfigurationCardId, size_t> available_outputs_for_card;
-
-        conf.for_each_card(
-            [&](mg::DisplayConfigurationCard const& card)
-            {
-                available_outputs_for_card[card.id] = card.max_simultaneous_outputs;
-            });
-
-        conf.for_each_output(
-            [&](mg::UserDisplayConfigurationOutput& conf_output)
-            {
-                if (conf_output.connected && conf_output.modes.size() > 0 &&
-                    available_outputs_for_card[conf_output.card_id] > 0)
-                {
-                    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_output.used = false;
-                    conf_output.power_mode = mir_power_mode_off;
-                }
-            });
-    }
-};
-
-class SingleDisplayConfigurationPolicy : public mg::DisplayConfigurationPolicy
-{
-public:
-    void apply_to(mg::DisplayConfiguration& conf)
-    {
-        size_t const preferred_mode_index{0};
-        bool done{false};
-
-        conf.for_each_output(
-            [&](mg::UserDisplayConfigurationOutput& conf_output)
-            {
-                if (!done && conf_output.connected && conf_output.modes.size() > 0)
-                {
-                    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_output.used = false;
-                    conf_output.power_mode = mir_power_mode_off;
-                }
-            });
-    }
-};
-
-class QuitFilter : public mir::input::EventFilter
-{
-public:
-    QuitFilter(std::shared_ptr<mir::MainLoop> const& main_loop)
-        : main_loop{main_loop}
-    {
-    }
-
-    bool handle(MirEvent const& event) override
-    {
-        if (event.type == mir_event_type_key &&
-            event.key.action == mir_key_action_down &&
-            (event.key.modifiers & mir_key_modifier_alt) &&
-            (event.key.modifiers & mir_key_modifier_ctrl) &&
-            event.key.scan_code == KEY_BACKSPACE)
-        {