Merge lp:~mterry/mir/missing-links into lp:mir/0.1

[Michael Terry]

Add some missing library link lines to mirplatformgraphicsandroid.

Add some missing library link lines to mirplatformgraphicsandroid.

These were causing crashes in unity8 for me. You can see that dpkg-shlibs will actually warn about these missing libraries with something like: "symbol X used by Y found in none of the libraries."

But there is no way to make that an error, which would help avoid these problems in the future. See Debian bug https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=644791

=== modified file '3rd_party/android-input/android/CMakeLists.txt'
--- 3rd_party/android-input/android/CMakeLists.txt	2014-03-06 06:05:17 +0000
+++ 3rd_party/android-input/android/CMakeLists.txt	2014-04-02 18:58:27 +0000
@@ -7,6 +7,7 @@
   system/extras/ext4_utils
 
   ${PROJECT_SOURCE_DIR}/include/server
+  ${PROJECT_SOURCE_DIR}/include/platform
 )
 
 add_definitions(
@@ -64,6 +65,7 @@
 target_link_libraries(
   android-input
 
+  mirplatform
   ${Boost_LIBRARIES}
 )
 

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/EventHub.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/EventHub.cpp	2013-10-03 05:12:59 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/EventHub.cpp	2014-04-02 18:58:27 +0000
@@ -205,34 +205,34 @@
 
 // --- EventHub ---
 
-const uint32_t EventHub::EPOLL_ID_INOTIFY;
+const uint32_t EventHub::EPOLL_ID_UDEV;
 const uint32_t EventHub::EPOLL_ID_WAKE;
 const int EventHub::EPOLL_SIZE_HINT;
 const int EventHub::EPOLL_MAX_EVENTS;
 
 EventHub::EventHub(std::shared_ptr<mi::InputReport> const& input_report) :
         input_report(input_report),
+        device_listener{mir::udev::Context()},
         mBuiltInKeyboardId(NO_BUILT_IN_KEYBOARD), mNextDeviceId(1),
         mOpeningDevices(0), mClosingDevices(0),
         mNeedToSendFinishedDeviceScan(false),
         mNeedToReopenDevices(false), mNeedToScanDevices(true),
-        mPendingEventCount(0), mPendingEventIndex(0), mPendingINotify(false) {
+        mPendingEventCount(0), mPendingEventIndex(0), mPendingUdevEvent(false) {
     acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);
 
     mEpollFd = epoll_create(EPOLL_SIZE_HINT);
     LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance.  errno=%d", errno);
 
-    mINotifyFd = inotify_init();
-    int result = inotify_add_watch(mINotifyFd, DEVICE_PATH, IN_DELETE | IN_CREATE | IN_ATTRIB);
-    LOG_ALWAYS_FATAL_IF(result < 0, "Could not register INotify for %s.  errno=%d",
-            DEVICE_PATH, errno);
+    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_INOTIFY;
-    result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd, &eventItem);
-    LOG_ALWAYS_FATAL_IF(result != 0, "Could not add INotify to epoll instance.  errno=%d", errno);
+    eventItem.data.u32 = EPOLL_ID_UDEV;
+    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];
     result = pipe(wakeFds);
@@ -265,7 +265,6 @@
     }
 
     ::close(mEpollFd);
-    ::close(mINotifyFd);
     ::close(mWakeReadPipeFd);
     ::close(mWakeWritePipeFd);
 
@@ -730,9 +729,9 @@
         bool deviceChanged = false;
         while (mPendingEventIndex < mPendingEventCount) {
             const struct epoll_event& eventItem = mPendingEventItems[mPendingEventIndex++];
-            if (eventItem.data.u32 == EPOLL_ID_INOTIFY) {
+            if (eventItem.data.u32 == EPOLL_ID_UDEV) {
                 if (eventItem.events & EPOLLIN) {
-                    mPendingINotify = true;
+                    mPendingUdevEvent = true;
                 } else {
                     ALOGW("Received unexpected epoll event 0x%08x for INotify.", eventItem.events);
                 }
@@ -839,9 +838,9 @@
         // readNotify() will modify the list of devices so this must be done after
         // processing all other events to ensure that we read all remaining events
         // before closing the devices.
-        if (mPendingINotify && mPendingEventIndex >= mPendingEventCount) {
-            mPendingINotify = false;
-            readNotifyLocked();
+        if (mPendingUdevEvent && mPendingEventIndex >= mPendingEventCount) {
+            mPendingUdevEvent = false;
+            handleUdevEventsLocked();
             deviceChanged = true;
         }
 
@@ -916,15 +915,44 @@
 }
 
 void EventHub::scanDevicesLocked() {
-    status_t res = scanDirLocked(DEVICE_PATH);
-    if(res < 0) {
-        ALOGE("scan dir failed for %s\n", DEVICE_PATH);
+    mir::udev::Enumerator input_enumerator{std::make_shared<mir::udev::Context>()};
+
+    input_enumerator.match_subsystem("input");
+    input_enumerator.scan_devices();
+
+    for (auto& device : input_enumerator)
+    {
+        if (device.devnode() != nullptr)
+        {
+            openDeviceLocked(device.devnode());
+        }
     }
+
     if (mDevices.indexOfKey(VIRTUAL_KEYBOARD_ID) < 0) {
         createVirtualKeyboardLocked();
     }
 }
 
+void EventHub::handleUdevEventsLocked()
+{
+    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)
+            {
+                openDeviceLocked(dev.devnode());
+            }
+        }
+        else if (type == mir::udev::Monitor::REMOVED)
+        {
+            if (dev.devnode() != nullptr)
+            {
+                closeDeviceByPathLocked(dev.devnode());
+            }
+        }
+    });
+}
+
 // ----------------------------------------------------------------------------
 
 static bool containsNonZeroByte(const uint8_t* array, uint32_t startIndex, uint32_t endIndex) {
@@ -1391,80 +1419,6 @@
     }
 }
 
-status_t EventHub::readNotifyLocked() {
-    int res;
-    char devname[PATH_MAX];
-    char *filename;
-    char event_buf[512];
-    int event_size;
-    int event_pos = 0;
-    struct inotify_event *event;
-
-    ALOGV("EventHub::readNotify nfd: %d\n", mINotifyFd);
-    res = read(mINotifyFd, event_buf, sizeof(event_buf));
-    if(res < (int)sizeof(*event)) {
-        if(errno == EINTR)
-            return 0;
-        ALOGW("could not get event, %s\n", strerror(errno));
-        return -1;
-    }
-    //printf("got %d bytes of event information\n", res);
-
-    strcpy(devname, DEVICE_PATH);
-    filename = devname + strlen(devname);
-    *filename++ = '/';
-
-    while(res >= (int)sizeof(*event)) {
-        event = (struct inotify_event *)(event_buf + event_pos);
-        //printf("%d: %08x \"%s\"\n", event->wd, event->mask, event->len ? event->name : "");
-        if(event->len) {
-            strcpy(filename, event->name);
-            if(event->mask & IN_CREATE) {
-                openDeviceLocked(devname);
-            } else if (event->mask & IN_ATTRIB) {
-                Device* device = getDeviceByPathLocked(devname);
-                if (!device) {
-                    ALOGI("Retry opening device file %s", devname);
-                    // file permissions might have changed, making the device readable now
-                    // let's retry opening it
-                    openDeviceLocked(devname);
-                }
-            } else {
-                ALOGI("Removing device '%s' due to inotify event\n", devname);
-                closeDeviceByPathLocked(devname);
-            }
-        }
-        event_size = sizeof(*event) + event->len;
-        res -= event_size;
-        event_pos += event_size;
-    }
-    return 0;
-}
-
-status_t EventHub::scanDirLocked(const char *dirname)
-{
-    char devname[PATH_MAX];
-    char *filename;
-    DIR *dir;
-    struct dirent *de;
-    dir = opendir(dirname);
-    if(dir == NULL)
-        return -1;
-    strcpy(devname, dirname);
-    filename = devname + strlen(devname);
-    *filename++ = '/';
-    while((de = readdir(dir))) {
-        if(de->d_name[0] == '.' &&
-           (de->d_name[1] == '\0' ||
-            (de->d_name[1] == '.' && de->d_name[2] == '\0')))
-            continue;
-        strcpy(filename, de->d_name);
-        openDeviceLocked(devname);
-    }
-    closedir(dir);
-    return 0;
-}
-
 void EventHub::requestReopenDevices() {
     ALOGV("requestReopenDevices() called");
 

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/EventHub.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/EventHub.h	2013-10-03 05:12:59 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/EventHub.h	2014-04-02 18:58:27 +0000
@@ -18,6 +18,8 @@
 #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>
@@ -366,9 +368,8 @@
     void closeDeviceLocked(Device* device);
     void closeAllDevicesLocked();
 
-    status_t scanDirLocked(const char *dirname);
     void scanDevicesLocked();
-    status_t readNotifyLocked();
+    void handleUdevEventsLocked();
 
     Device* getDeviceLocked(int32_t deviceId) const;
     Device* getDeviceByPathLocked(const char* devicePath) const;
@@ -407,12 +408,12 @@
     Vector<String8> mExcludedDevices;
 
     int mEpollFd;
-    int mINotifyFd;
+    mir::udev::Monitor device_listener;
     int mWakeReadPipeFd;
     int mWakeWritePipeFd;
 
     // Ids used for epoll notifications not associated with devices.
-    static const uint32_t EPOLL_ID_INOTIFY = 0x80000001;
+    static const uint32_t EPOLL_ID_UDEV = 0x80000001;
     static const uint32_t EPOLL_ID_WAKE = 0x80000002;
 
     // Epoll FD list size hint.
@@ -425,7 +426,7 @@
     struct epoll_event mPendingEventItems[EPOLL_MAX_EVENTS];
     size_t mPendingEventCount;
     size_t mPendingEventIndex;
-    bool mPendingINotify;
+    bool mPendingUdevEvent;
 };
 
 // Made available to test

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-03-06 06:05:17 +0000
+++ CMakeLists.txt	2014-04-02 18:58:27 +0000
@@ -28,7 +28,7 @@
 
 set(MIR_VERSION_MAJOR 0)
 set(MIR_VERSION_MINOR 1)
-set(MIR_VERSION_PATCH 7)
+set(MIR_VERSION_PATCH 8)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 execute_process(

=== modified file 'benchmarks/android-input/CMakeLists.txt'
--- benchmarks/android-input/CMakeLists.txt	2013-10-15 10:10:05 +0000
+++ benchmarks/android-input/CMakeLists.txt	2014-04-02 18:58:27 +0000
@@ -5,7 +5,9 @@
  )
 
 include_directories(
-  ${Mir_SOURCE_DIR}/include/test)
+  ${Mir_SOURCE_DIR}/include/test
+  ${Mir_SOURCE_DIR}/include/platform
+)
 
 add_executable(input-reader-perf ${SOURCES})
 

=== modified file 'cmake/MirCommon.cmake'
--- cmake/MirCommon.cmake	2014-03-06 06:05:17 +0000
+++ cmake/MirCommon.cmake	2014-04-02 18:58:27 +0000
@@ -22,8 +22,10 @@
     valgrind)
 
   if(VALGRIND_EXECUTABLE)
-    set(VALGRIND_ARGS "--error-exitcode=1" "--trace-children=yes")
+    set(VALGRIND_ARGS "--error-exitcode=1" "--trace-children=yes" "--leak-check=full" "--show-leak-kinds=definite" "--errors-for-leak-kinds=definite")
+    set(VALGRIND_ARGS ${VALGRIND_ARGS} "--suppressions=${CMAKE_SOURCE_DIR}/tools/valgrind_suppressions_generic")
     set(DISCOVER_FLAGS "--enable-memcheck")
+    set(DISCOVER_FLAGS ${DISCOVER_FLAGS} "--suppressions=${CMAKE_SOURCE_DIR}/tools/valgrind_suppressions_generic")
     if (TARGET_ARCH STREQUAL "arm-linux-gnueabihf")
         set(VALGRIND_ARGS ${VALGRIND_ARGS} "--suppressions=${CMAKE_SOURCE_DIR}/tools/valgrind_suppressions_armhf")
         set(DISCOVER_FLAGS ${DISCOVER_FLAGS} "--suppressions=${CMAKE_SOURCE_DIR}/tools/valgrind_suppressions_armhf")
@@ -35,10 +37,11 @@
 
 function (mir_discover_tests EXECUTABLE)
   if(DISABLE_GTEST_TEST_DISCOVERY)
-    add_test(${EXECUTABLE} ${VALGRIND_EXECUTABLE} ${VALGRIND_ARGS} "${EXECUTABLE_OUTPUT_PATH}/${EXECUTABLE}")
-
+    add_test(${EXECUTABLE} ${VALGRIND_EXECUTABLE} ${VALGRIND_ARGS} ${EXECUTABLE_OUTPUT_PATH}/${EXECUTABLE} "--gtest_filter=-*DeathTest.*")
+    add_test(${EXECUTABLE}_death_tests ${EXECUTABLE_OUTPUT_PATH}/${EXECUTABLE} "--gtest_filter=*DeathTest.*")
     if (${ARGC} GREATER 1)
       set_property(TEST ${EXECUTABLE} PROPERTY ENVIRONMENT ${ARGN})
+      set_property(TEST ${EXECUTABLE}_death_tests PROPERTY ENVIRONMENT ${ARGN})
     endif()
   else()
     set(CHECK_TEST_DISCOVERY_TARGET_NAME "check_discover_tests_in_${EXECUTABLE}")
@@ -82,7 +85,15 @@
 function (mir_add_memcheck_test)
   if (ENABLE_MEMCHECK_OPTION)
       if(DISABLE_GTEST_TEST_DISCOVERY)
-          ADD_TEST("memcheck-test" "sh" "-c" "${VALGRIND_EXECUTABLE} ${VALGRIND_ARGS} ${CMAKE_BINARY_DIR}/mir_gtest/mir_test_memory_error; if [ $? != 0 ]; then exit 0; else exit 1; fi")
+	add_custom_target(
+	  memcheck_test ALL
+	)
+	ADD_TEST("memcheck-test" ${CMAKE_BINARY_DIR}/mir_gtest/fail_on_success.sh ${VALGRIND_EXECUTABLE} ${VALGRIND_ARGS} ${CMAKE_BINARY_DIR}/mir_gtest/mir_test_memory_error)
+	add_dependencies(
+	  memcheck_test
+
+	  mir_test_memory_error
+	)
       else()
         add_custom_target(
           memcheck_test ALL

=== modified file 'cmake/src/mir/CMakeLists.txt'
--- cmake/src/mir/CMakeLists.txt	2013-03-13 04:54:15 +0000
+++ cmake/src/mir/CMakeLists.txt	2014-04-02 18:58:27 +0000
@@ -17,3 +17,8 @@
   mir_test_memory_error PROPERTIES
   RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/mir_gtest
 )
+
+file(INSTALL ${CMAKE_CURRENT_SOURCE_DIR}/fail_on_success.sh
+  DESTINATION ${CMAKE_BINARY_DIR}/mir_gtest
+  USE_SOURCE_PERMISSIONS
+)

=== added file 'cmake/src/mir/fail_on_success.sh'
--- cmake/src/mir/fail_on_success.sh	1970-01-01 00:00:00 +0000
+++ cmake/src/mir/fail_on_success.sh	2014-04-02 18:58:27 +0000
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+$@
+
+if [ $? -eq 0 ] ; then
+    exit 1;
+fi
+exit 0;

=== modified file 'cmake/src/mir/mir_discover_gtest_tests.cpp'
--- cmake/src/mir/mir_discover_gtest_tests.cpp	2014-03-06 06:05:17 +0000
+++ cmake/src/mir/mir_discover_gtest_tests.cpp	2014-04-02 18:58:27 +0000
@@ -234,6 +234,18 @@
 }
 }
 
+bool is_death_test(string const& test)
+{
+    // precondition: test will match Foo.*
+    // assumption: death tests will match FooDeathTest.*
+    bool death_test = false;
+    if (test.size() > strlen("DeathTest.*"))
+       death_test = test.substr(test.size() - strlen("DeathTest.*"),
+				strlen("DeathTest")) == "DeathTest";
+
+    return death_test;
+}
+
 int main (int argc, char **argv)
 {
     int output_width = get_output_width();
@@ -291,8 +303,9 @@
             snprintf(
                 cmd_line,
                 sizeof(cmd_line),
-                config.enable_memcheck ? memcheck_cmd_line_pattern(config.suppressions).c_str() :
-                                         ordinary_cmd_line_pattern().c_str(),
+                (config.enable_memcheck && !is_death_test(*test)) ?
+		    memcheck_cmd_line_pattern(config.suppressions).c_str() :
+                    ordinary_cmd_line_pattern().c_str(),
                 test_suite.c_str(),
                 elide_string_left(*test, output_width/2).c_str(),
                 config.executable,

=== modified file 'debian/changelog'
--- debian/changelog	2014-03-18 18:38:01 +0000
+++ debian/changelog	2014-04-02 18:58:27 +0000
@@ -1,3 +1,25 @@
+mir (0.1.8-0ubuntu1) UNRELEASED; urgency=medium
+
+  * New upstream release 0.1.8 (https://launchpad.net/mir/+milestone/0.1.8)
+    - mirserver ABI bumped to 18.
+    - mirclient ABI unchanged, still at 7. Clients do not need rebuilding.
+    - Server API changes affecting shells:
+      . GLRenderer::tessellate() changed syntax.
+    - Switch EventHub device enumeration and hotplug to Udev. NOTE! This means
+      mir_test_* can't run natively on touch devices any more without some
+      preparation first:
+        sudo mount -o remount,rw /
+        sudo apt-get update
+        sudo apt-get install -y umockdev
+    - Added logging for HWC events.
+    - Continued consolidation of Surface classes toward a simpler architecture.
+    - Added some decorations to demo-shell; shadows and basic title bars, all
+      anti-aliased and high-DPI-scalable.
+    - Bugs fixed:
+      . TODO (during merge proposal to distro)
+
+ -- Daniel van Vugt <[e-mail]>  Thu, 20 Mar 2014 14:05:25 +0800
+
 mir (0.1.7+14.04.20140318-0ubuntu1) trusty; urgency=low
 
   [ Alberto Aguirre ]

=== modified file 'debian/control'
--- debian/control	2014-03-17 07:35:22 +0000
+++ debian/control	2014-04-02 18:58:27 +0000
@@ -31,7 +31,7 @@
                libgoogle-glog-dev,
                liblttng-ust-dev,
                libxkbcommon-dev,
-               libumockdev-dev,
+               libumockdev-dev (>= 0.6),
                umockdev,
                libudev-dev,
                google-mock (>= 1.6.0+svn437),
@@ -70,7 +70,7 @@
  .
  Contains the protocol's definition files.
 
-Package: libmirserver17
+Package: libmirserver18
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
@@ -148,7 +148,7 @@
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmirserver17 (= ${binary:Version}),
+Depends: libmirserver18 (= ${binary:Version}),
          libmirprotobuf-dev (= ${binary:Version}),
          mircommon-dev (= ${binary:Version}),
          libglm-dev,

=== renamed file 'debian/libmirserver17.install' => 'debian/libmirserver18.install'
--- debian/libmirserver17.install	2014-03-12 06:41:13 +0000
+++ debian/libmirserver18.install	2014-04-02 18:58:27 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirserver.so.17
+usr/lib/*/libmirserver.so.18

=== added file 'deploy-and-test.sh'
--- deploy-and-test.sh	1970-01-01 00:00:00 +0000
+++ deploy-and-test.sh	2014-04-02 18:58:27 +0000
@@ -0,0 +1,21 @@
+#!/bin/sh
+
+if [ ! -d build-android-arm ] ; then
+    echo "Built tree not found in $(pwd)/build-android-arm"
+    exit 1
+fi
+
+# Unpack umockdev requirements
+( cd build-android-arm ;
+  apt-get download umockdev:armhf libumockdev0:armhf ;
+  dpkg -x umockdev_*armhf*.deb . ;
+  dpkg -x libumockdev0_*armhf*.deb .
+)
+
+adb push build-android-arm/bin /home/phablet/mir/bin
+adb push build-android-arm/lib /home/phablet/mir/lib
+adb push build-android-arm/usr /home/phablet/mir/usr
+
+adb shell "LD_LIBRARY_PATH=/home/phablet/mir/usr/lib/arm-linux-gnueabihf/:/home/phablet/mir/lib PATH=$PATH:/home/phablet/mir/usr/bin bash -c \"cd /home/phablet/mir/usr/bin ; umockdev-run /home/phablet/mir/bin/mir_unit_tests\""
+adb shell "LD_LIBRARY_PATH=/home/phablet/mir/usr/lib/arm-linux-gnueabihf/:/home/phablet/mir/lib PATH=$PATH:/home/phablet/mir/usr/bin bash -c \"cd /home/phablet/mir/usr/bin ; umockdev-run /home/phablet/mir/bin/mir_integration_tests\""
+adb shell "LD_LIBRARY_PATH=/home/phablet/mir/usr/lib/arm-linux-gnueabihf/:/home/phablet/mir/lib PATH=$PATH:/home/phablet/mir/usr/bin bash -c \"cd /home/phablet/mir/usr/bin ; umockdev-run /home/phablet/mir/bin/mir_acceptance_tests\""

=== modified file 'examples/demo-shell/demo_renderer.cpp'
--- examples/demo-shell/demo_renderer.cpp	2014-03-05 04:13:32 +0000
+++ examples/demo-shell/demo_renderer.cpp	2014-04-02 18:58:27 +0000
@@ -17,13 +17,131 @@
  */
 
 #include "demo_renderer.h"
+#include <mir/graphics/renderable.h>
+#include <cmath>
 
 using namespace mir;
 using namespace mir::examples;
 
+namespace
+{
+
+float penumbra_curve(float x)
+{
+    return 1.0f - std::sin(x * M_PI / 2.0f);
+}
+
+GLuint generate_shadow_corner_texture(float opacity)
+{
+    struct Texel
+    {
+        GLubyte luminance;
+        GLubyte alpha;
+    };
+
+    int const width = 256;
+    Texel image[width][width];
+
+    int const max = width - 1;
+    for (int y = 0; y < width; ++y)
+    {
+        float curve_y = opacity * 255.0f *
+                        penumbra_curve(static_cast<float>(y) / max);
+        for (int x = 0; x < width; ++x)
+        {
+            Texel *t = &image[y][x];
+            t->luminance = 0;
+            t->alpha = curve_y * penumbra_curve(static_cast<float>(x) / max);
+        }
+    }
+
+    GLuint corner;
+    glGenTextures(1, &corner);
+    glBindTexture(GL_TEXTURE_2D, corner);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA,
+                 width, width, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
+                 image);
+
+    return corner;
+}
+
+GLuint generate_frame_corner_texture()
+{
+    struct Texel
+    {
+        GLubyte r, g, b, a;
+    };
+
+    int const width = 256;
+    Texel image[width][width];
+
+    int cx = width / 2;
+    int cy = width / 2;
+    int radius_sqr = cx * cx;
+
+    for (int y = 0; y < width; ++y)
+    {
+        for (int x = 0; x < width; ++x)
+        {
+            GLubyte lum = 128;
+            GLubyte alpha = 255;
+
+            // Cut out the corner in a circular shape.
+            if (x < cx && y < cy)
+            {
+                int dx = cx - x;
+                int dy = cy - y;
+                if (dx * dx + dy * dy >= radius_sqr)
+                    alpha = 0;
+            }
+
+            // Set gradient
+            if (y < cy)
+            {
+                float brighten = (1.0f - (static_cast<float>(y) / cy));
+                if (x < cx)
+                    brighten *= std::sin(x * M_PI / width);
+
+                lum += (255 - lum) * brighten;
+            }
+
+            image[y][x] = {lum, lum, lum, alpha};
+        }
+    }
+
+    GLuint corner;
+    glGenTextures(1, &corner);
+    glBindTexture(GL_TEXTURE_2D, corner);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                                   GL_LINEAR_MIPMAP_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
+                 width, width, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                 image);
+    glGenerateMipmap(GL_TEXTURE_2D); // Antialiasing please
+
+    return corner;
+}
+
+} // namespace
+
 DemoRenderer::DemoRenderer(geometry::Rectangle const& display_area)
     : GLRenderer(display_area)
 {
+    shadow_corner_tex = generate_shadow_corner_texture(0.4f);
+    titlebar_corner_tex = generate_frame_corner_texture();
+}
+
+DemoRenderer::~DemoRenderer()
+{
+    glDeleteTextures(1, &shadow_corner_tex);
+    glDeleteTextures(1, &titlebar_corner_tex);
 }
 
 void DemoRenderer::begin() const
@@ -31,3 +149,156 @@
     glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
     glClear(GL_COLOR_BUFFER_BIT);
 }
+
+void DemoRenderer::tessellate(std::vector<Primitive>& primitives,
+                              graphics::Renderable const& renderable,
+                              geometry::Size const& buf_size) const
+{
+    GLRenderer::tessellate(primitives, renderable, buf_size);
+    tessellate_shadow(primitives, renderable, 80.0f);
+    tessellate_frame(primitives, renderable, 30.0f);
+}
+
+void DemoRenderer::tessellate_shadow(std::vector<Primitive>& primitives,
+                                     graphics::Renderable const& renderable,
+                                     float radius) const
+{
+    auto const& rect = renderable.screen_position();
+    GLfloat left = rect.top_left.x.as_int();
+    GLfloat right = left + rect.size.width.as_int();
+    GLfloat top = rect.top_left.y.as_int();
+    GLfloat bottom = top + rect.size.height.as_int();
+
+    auto n = primitives.size();
+    primitives.resize(n + 8);
+
+    GLfloat rightr = right + radius;
+    GLfloat leftr = left - radius;
+    GLfloat topr = top - radius;
+    GLfloat bottomr = bottom + radius;
+
+    auto& right_shadow = primitives[n++];
+    right_shadow.tex_id = shadow_corner_tex;
+    right_shadow.type = GL_TRIANGLE_FAN;
+    right_shadow.vertices.resize(4);
+    right_shadow.vertices[0] = {{right,  top,    0.0f}, {0.0f, 0.0f}};
+    right_shadow.vertices[1] = {{rightr, top,    0.0f}, {1.0f, 0.0f}};
+    right_shadow.vertices[2] = {{rightr, bottom, 0.0f}, {1.0f, 0.0f}};
+    right_shadow.vertices[3] = {{right,  bottom, 0.0f}, {0.0f, 0.0f}};
+
+    auto& left_shadow = primitives[n++];
+    left_shadow.tex_id = shadow_corner_tex;
+    left_shadow.type = GL_TRIANGLE_FAN;
+    left_shadow.vertices.resize(4);
+    left_shadow.vertices[0] = {{leftr, top,    0.0f}, {1.0f, 0.0f}};
+    left_shadow.vertices[1] = {{left,  top,    0.0f}, {0.0f, 0.0f}};
+    left_shadow.vertices[2] = {{left,  bottom, 0.0f}, {0.0f, 0.0f}};
+    left_shadow.vertices[3] = {{leftr, bottom, 0.0f}, {1.0f, 0.0f}};
+
+    auto& top_shadow = primitives[n++];
+    top_shadow.tex_id = shadow_corner_tex;
+    top_shadow.type = GL_TRIANGLE_FAN;
+    top_shadow.vertices.resize(4);
+    top_shadow.vertices[0] = {{left,  topr, 0.0f}, {1.0f, 0.0f}};
+    top_shadow.vertices[1] = {{right, topr, 0.0f}, {1.0f, 0.0f}};
+    top_shadow.vertices[2] = {{right, top,  0.0f}, {0.0f, 0.0f}};
+    top_shadow.vertices[3] = {{left,  top,  0.0f}, {0.0f, 0.0f}};
+
+    auto& bottom_shadow = primitives[n++];
+    bottom_shadow.tex_id = shadow_corner_tex;
+    bottom_shadow.type = GL_TRIANGLE_FAN;
+    bottom_shadow.vertices.resize(4);
+    bottom_shadow.vertices[0] = {{left,  bottom,  0.0f}, {0.0f, 0.0f}};
+    bottom_shadow.vertices[1] = {{right, bottom,  0.0f}, {0.0f, 0.0f}};
+    bottom_shadow.vertices[2] = {{right, bottomr, 0.0f}, {1.0f, 0.0f}};
+    bottom_shadow.vertices[3] = {{left,  bottomr, 0.0f}, {1.0f, 0.0f}};
+
+    auto& tr_shadow = primitives[n++];
+    tr_shadow.tex_id = shadow_corner_tex;
+    tr_shadow.type = GL_TRIANGLE_FAN;
+    tr_shadow.vertices.resize(4);
+    tr_shadow.vertices[0] = {{right,  top,  0.0f}, {0.0f, 0.0f}};
+    tr_shadow.vertices[1] = {{right,  topr, 0.0f}, {1.0f, 0.0f}};
+    tr_shadow.vertices[2] = {{rightr, topr, 0.0f}, {1.0f, 1.0f}};
+    tr_shadow.vertices[3] = {{rightr, top,  0.0f}, {0.0f, 1.0f}};
+
+    auto& br_shadow = primitives[n++];
+    br_shadow.tex_id = shadow_corner_tex;
+    br_shadow.type = GL_TRIANGLE_FAN;
+    br_shadow.vertices.resize(4);
+    br_shadow.vertices[0] = {{right,  bottom,  0.0f}, {0.0f, 0.0f}};
+    br_shadow.vertices[1] = {{rightr, bottom,  0.0f}, {1.0f, 0.0f}};
+    br_shadow.vertices[2] = {{rightr, bottomr, 0.0f}, {1.0f, 1.0f}};
+    br_shadow.vertices[3] = {{right,  bottomr, 0.0f}, {0.0f, 1.0f}};
+
+    auto& bl_shadow = primitives[n++];
+    bl_shadow.tex_id = shadow_corner_tex;
+    bl_shadow.type = GL_TRIANGLE_FAN;
+    bl_shadow.vertices.resize(4);
+    bl_shadow.vertices[0] = {{left,  bottom,  0.0f}, {0.0f, 0.0f}};
+    bl_shadow.vertices[1] = {{left,  bottomr, 0.0f}, {1.0f, 0.0f}};
+    bl_shadow.vertices[2] = {{leftr, bottomr, 0.0f}, {1.0f, 1.0f}};
+    bl_shadow.vertices[3] = {{leftr, bottom,  0.0f}, {0.0f, 1.0f}};
+
+    auto& tl_shadow = primitives[n++];
+    tl_shadow.tex_id = shadow_corner_tex;
+    tl_shadow.type = GL_TRIANGLE_FAN;
+    tl_shadow.vertices.resize(4);
+    tl_shadow.vertices[0] = {{left,  top,  0.0f}, {0.0f, 0.0f}};
+    tl_shadow.vertices[1] = {{leftr, top,  0.0f}, {1.0f, 0.0f}};
+    tl_shadow.vertices[2] = {{leftr, topr, 0.0f}, {1.0f, 1.0f}};
+    tl_shadow.vertices[3] = {{left,  topr, 0.0f}, {0.0f, 1.0f}};
+
+    // Shadows always need blending...
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+}
+
+void DemoRenderer::tessellate_frame(std::vector<Primitive>& primitives,
+                                    graphics::Renderable const& renderable,
+                                    float titlebar_height) const
+{
+    auto const& rect = renderable.screen_position();
+    GLfloat left = rect.top_left.x.as_int();
+    GLfloat right = left + rect.size.width.as_int();
+    GLfloat top = rect.top_left.y.as_int();
+
+    auto n = primitives.size();
+    primitives.resize(n + 3);
+
+    GLfloat htop = top - titlebar_height;
+    GLfloat inleft = left + titlebar_height;  // Square proportions for corners
+    GLfloat inright = right - titlebar_height;
+
+    GLfloat mid = (left + right) / 2.0f;
+    if (inleft > mid) inleft = mid;
+    if (inright < mid) inright = mid;
+
+    auto& top_left_corner = primitives[n++];
+    top_left_corner.tex_id = titlebar_corner_tex;
+    top_left_corner.type = GL_TRIANGLE_FAN;
+    top_left_corner.vertices.resize(4);
+    top_left_corner.vertices[0] = {{left,   htop, 0.0f}, {0.0f, 0.0f}};
+    top_left_corner.vertices[1] = {{inleft, htop, 0.0f}, {1.0f, 0.0f}};
+    top_left_corner.vertices[2] = {{inleft, top,  0.0f}, {1.0f, 1.0f}};
+    top_left_corner.vertices[3] = {{left,   top,  0.0f}, {0.0f, 1.0f}};
+
+    auto& top_right_corner = primitives[n++];
+    top_right_corner.tex_id = titlebar_corner_tex;
+    top_right_corner.type = GL_TRIANGLE_FAN;
+    top_right_corner.vertices.resize(4);
+    top_right_corner.vertices[0] = {{inright, htop, 0.0f}, {1.0f, 0.0f}};
+    top_right_corner.vertices[1] = {{right,   htop, 0.0f}, {0.0f, 0.0f}};
+    top_right_corner.vertices[2] = {{right,   top,  0.0f}, {0.0f, 1.0f}};
+    top_right_corner.vertices[3] = {{inright, top,  0.0f}, {1.0f, 1.0f}};
+
+    auto& titlebar = primitives[n++];
+    titlebar.tex_id = titlebar_corner_tex;
+    titlebar.type = GL_TRIANGLE_FAN;
+    titlebar.vertices.resize(4);
+    titlebar.vertices[0] = {{inleft,  htop, 0.0f}, {1.0f, 0.0f}};
+    titlebar.vertices[1] = {{inright, htop, 0.0f}, {1.0f, 0.0f}};
+    titlebar.vertices[2] = {{inright, top,  0.0f}, {1.0f, 1.0f}};
+    titlebar.vertices[3] = {{inleft,  top,  0.0f}, {1.0f, 1.0f}};
+}
+

=== modified file 'examples/demo-shell/demo_renderer.h'
--- examples/demo-shell/demo_renderer.h	2014-02-14 09:58:06 +0000
+++ examples/demo-shell/demo_renderer.h	2014-04-02 18:58:27 +0000
@@ -30,7 +30,22 @@
 {
 public:
     DemoRenderer(geometry::Rectangle const& display_area);
+    ~DemoRenderer();
+
     void begin() const override;
+    void tessellate(std::vector<Primitive>& primitives,
+                    graphics::Renderable const& renderable,
+                    geometry::Size const& buf_size) const override;
+    void tessellate_shadow(std::vector<Primitive>& primitives,
+                    graphics::Renderable const& renderable,
+                    float radius) const;
+    void tessellate_frame(std::vector<Primitive>& primitives,
+                    graphics::Renderable const& renderable,
+                    float titlebar_height) const;
+
+private:
+    GLuint shadow_corner_tex;
+    GLuint titlebar_corner_tex;
 };
 
 } // namespace examples

=== modified file 'examples/render_overlays.cpp'
--- examples/render_overlays.cpp	2014-03-17 07:35:22 +0000
+++ examples/render_overlays.cpp	2014-04-02 18:58:27 +0000
@@ -105,17 +105,17 @@
     {
     }
 
-    std::shared_ptr<mg::Buffer> buffer(unsigned long) const override
+    std::shared_ptr<mg::Buffer> buffer(void const*) const override
     {
         return client->last_rendered();
     }
 
-    bool alpha_enabled() const
+    bool alpha_enabled() const override
     {
         return false;
     }
 
-    geom::Rectangle screen_position() const
+    geom::Rectangle screen_position() const override
     {
         return position;
     }
@@ -130,14 +130,14 @@
         return trans;
     }
 
-    bool shaped() const
+    bool shaped() const override
     {
         return false;
     }
 
-    bool should_be_rendered_in(geom::Rectangle const& rect) const override
+    bool visible() const override
     {
-        return rect.overlaps(position);
+        return true;
     }
 
     int buffers_ready_for_compositor() const override
@@ -168,7 +168,9 @@
     mir::DefaultServerConfiguration conf{argc, argv};
 
     auto platform = conf.the_graphics_platform();
-    auto display = platform->create_display(conf.the_display_configuration_policy());
+    auto display = platform->create_display(
+        conf.the_display_configuration_policy(),
+        conf.the_gl_config());
     auto buffer_allocator = platform->create_buffer_allocator(conf.the_buffer_initializer());
 
      mg::BufferProperties buffer_properties{

=== modified file 'examples/render_surfaces.cpp'
--- examples/render_surfaces.cpp	2014-03-11 04:03:54 +0000
+++ examples/render_surfaces.cpp	2014-04-02 18:58:27 +0000
@@ -31,7 +31,8 @@
 #include "mir/graphics/display_buffer.h"
 #include "mir/graphics/gl_context.h"
 #include "mir/shell/surface_factory.h"
-#include "mir/shell/surface.h"
+#include "mir/scene/surface.h"
+#include "mir/scene/surface_coordinator.h"
 #include "mir/run_mir.h"
 #include "mir/report_exception.h"
 #include "mir/raii.h"
@@ -41,6 +42,9 @@
 #include "image_renderer.h"
 #include "server_configuration.h"
 
+#define GLM_FORCE_RADIANS
+#include <glm/gtc/matrix_transform.hpp>
+
 #include <thread>
 #include <atomic>
 #include <chrono>
@@ -90,6 +94,7 @@
 std::weak_ptr<mg::Cursor> cursor;
 static const uint32_t bg_color = 0x00000000;
 static const uint32_t fg_color = 0xffdd4814;
+static const float min_alpha = 0.3f;
 
 void update_cursor(uint32_t bg_color, uint32_t fg_color)
 {
@@ -233,8 +238,16 @@
             y = new_y;
         }
 
-        surface->set_rotation(total_elapsed_sec * 120.0f, rotation_axis);
-        surface->set_alpha(0.5 + 0.5 * sin(alpha_offset + 2 * M_PI * total_elapsed_sec / 3.0));
+        glm::mat4 trans = glm::rotate(glm::mat4(1.0f),
+                                      glm::radians(total_elapsed_sec * 120.0f),
+                                      rotation_axis);
+        surface->set_transformation(trans);
+
+        float const alpha_amplitude = (1.0f - min_alpha) / 2.0f;
+        surface->set_alpha(min_alpha + alpha_amplitude +
+                           alpha_amplitude *
+                           sin(alpha_offset + 2 * M_PI * total_elapsed_sec /
+                               3.0));
     }
 
 private:
@@ -433,7 +446,7 @@
         std::cout << "Rendering " << moveables.size() << " surfaces" << std::endl;
 
         auto const display = the_display();
-        auto const surface_factory = the_scene_surface_factory();
+        auto const surface_coordinator = the_surface_coordinator();
         /* TODO: Get proper configuration */
         geom::Rectangles view_area;
         display->for_each_display_buffer([&view_area](mg::DisplayBuffer const& db)
@@ -452,12 +465,11 @@
         int i = 0;
         for (auto& m : moveables)
         {
-            auto const s = surface_factory->create_surface(
-                    nullptr,
+            auto const s = surface_coordinator->add_surface(
                     msh::a_surface().of_size(surface_size)
                                    .of_pixel_format(surface_pf)
                                    .of_buffer_usage(mg::BufferUsage::hardware),
-                    mf::SurfaceId(), {});
+                    {});
 
             /*
              * We call swap_buffers() twice so that the surface is

=== modified file 'include/platform/mir/graphics/display_buffer.h'
--- include/platform/mir/graphics/display_buffer.h	2014-03-06 06:05:17 +0000
+++ include/platform/mir/graphics/display_buffer.h	2014-04-02 18:58:27 +0000
@@ -20,11 +20,11 @@
 #define MIR_GRAPHICS_DISPLAY_BUFFER_H_
 
 #include <mir/geometry/rectangle.h>
+#include <mir/graphics/renderable.h>
 #include <mir_toolkit/common.h>
 
 #include <memory>
 #include <functional>
-#include <list>
 
 namespace mir
 {
@@ -32,7 +32,6 @@
 {
 
 class Buffer;
-class Renderable;
 
 /**
  * Interface to an output framebuffer.
@@ -57,7 +56,7 @@
         that Renderable via OpenGL, or via another method. If the Renderable is to be rendered
         via OpenGL, render_fn will be invoked on that Renderable. */
     virtual void render_and_post_update(
-        std::list<std::shared_ptr<Renderable>> const& renderlist,
+        RenderableList const& renderlist,
         std::function<void(Renderable const&)> const& render_fn) = 0;
 
     /** to be deprecated */

=== added file 'include/platform/mir/graphics/gl_config.h'
--- include/platform/mir/graphics/gl_config.h	1970-01-01 00:00:00 +0000
+++ include/platform/mir/graphics/gl_config.h	2014-04-02 18:58:27 +0000
@@ -0,0 +1,54 @@
+/*
+ * 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_GRAPHICS_GL_CONFIG_H_
+#define MIR_GRAPHICS_GL_CONFIG_H_
+
+namespace mir
+{
+namespace graphics
+{
+
+/**
+ * Interface for customizing aspects of the GL config used by the server.
+ */
+class GLConfig
+{
+public:
+    virtual ~GLConfig() = default;
+
+    /**
+     * Gets the bits to use for each pixel in the depth buffer.
+     */
+    virtual int depth_buffer_bits() const = 0;
+
+    /**
+     * Gets the bits to use for each pixel in the stencil buffer.
+     */
+    virtual int stencil_buffer_bits() const = 0;
+
+protected:
+    GLConfig() = default;
+    GLConfig(GLConfig const&) = delete;
+    GLConfig& operator=(GLConfig const&) = delete;
+};
+
+}
+}
+
+#endif /* MIR_GRAPHICS_GL_CONFIG_H_ */

=== modified file 'include/platform/mir/graphics/platform.h'
--- include/platform/mir/graphics/platform.h	2014-03-06 06:05:17 +0000
+++ include/platform/mir/graphics/platform.h	2014-04-02 18:58:27 +0000
@@ -22,6 +22,7 @@
 
 #include "basic_platform.h"
 
+#include <boost/program_options/options_description.hpp>
 #include <memory>
 
 namespace mir
@@ -48,6 +49,7 @@
 class DisplayReport;
 class DisplayConfigurationPolicy;
 class GraphicBufferAllocator;
+class GLConfig;
 
 /**
  * \defgroup platform_enablement Mir platform enablement
@@ -81,7 +83,8 @@
      * Creates the display subsystem.
      */
     virtual std::shared_ptr<Display> create_display(
-        std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy) = 0;
+        std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy,
+        std::shared_ptr<GLConfig> const& gl_config) = 0;
 
     /**
      * Gets the IPC package for the platform.
@@ -119,6 +122,10 @@
  */
 extern "C" typedef std::shared_ptr<Platform>(*CreatePlatform)(std::shared_ptr<options::Option> const& options, std::shared_ptr<DisplayReport> const& report);
 extern "C" std::shared_ptr<Platform> create_platform (std::shared_ptr<options::Option> const& options, std::shared_ptr<DisplayReport> const& report);
+extern "C" typedef void(*AddPlatformOptions)(
+    boost::program_options::options_description& config);
+extern "C" void add_platform_options(
+    boost::program_options::options_description& config);
 }
 }
 

=== modified file 'include/platform/mir/graphics/renderable.h'
--- include/platform/mir/graphics/renderable.h	2014-03-17 07:35:22 +0000
+++ include/platform/mir/graphics/renderable.h	2014-04-02 18:58:27 +0000
@@ -22,6 +22,7 @@
 #include <mir/geometry/rectangle.h>
 #include <glm/glm.hpp>
 #include <memory>
+#include <list>
 
 namespace mir
 {
@@ -35,19 +36,15 @@
     /**
      * Return the next buffer that should be composited/rendered.
      *
-     * \param [in] frameno The frameno parameter is important for
-     *                     multi-monitor platforms. Calls with the same frameno
-     *                     will get the same buffer returned. This ensures that
-     *                     a surface visible on multiple outputs does not get
-     *                     its buffers consumed any faster than the refresh
-     *                     rate of a single monitor. Implementations may ignore
-     *                     the value of frameno on single-monitor platforms
-     *                     only. The caller should always ensure the frameno
-     *                     is different to the previous frame. The exact value
-     *                     of frameno is not important but a large range of
-     *                     values is recommended.
+     * \param [in] user_id An arbitrary unique identifier used to distinguish
+     *                     separate threads/monitors/components which need
+     *                     to concurrently receive the same buffer. Calling
+     *                     with the same user_id will return a new (different)
+     *                     buffer to that user each time. For consistency,
+     *                     all callers need to determine their user_id in the
+     *                     same way (e.g. always use "this" pointer).
      */
-    virtual std::shared_ptr<Buffer> buffer(unsigned long frameno) const = 0;
+    virtual std::shared_ptr<Buffer> buffer(void const* user_id) const = 0;
 
     virtual bool alpha_enabled() const = 0;
     virtual geometry::Rectangle screen_position() const = 0;
@@ -69,7 +66,14 @@
      *          the surface itself).
      */
     virtual glm::mat4 transformation() const = 0;
-    virtual bool should_be_rendered_in(geometry::Rectangle const& rect) const = 0;
+
+    /**
+     * TODO: Its a bit questionable that we have this member function, why not 
+     *       just trim the renderable from the RenderableList? Its convenient
+     *       to have this function temporarily while refactoring --kdub
+     */ 
+    virtual bool visible() const = 0;
+
     virtual bool shaped() const = 0;  // meaning the pixel format has alpha
     virtual int buffers_ready_for_compositor() const = 0;
 
@@ -80,6 +84,9 @@
     Renderable& operator=(Renderable const&) = delete;
 };
 
+// XXX Would performance be better with a vector?
+typedef std::list<std::shared_ptr<Renderable>> RenderableList;
+
 }
 }
 

=== modified file 'include/platform/mir/options/default_configuration.h'
--- include/platform/mir/options/default_configuration.h	2014-03-17 07:35:22 +0000
+++ include/platform/mir/options/default_configuration.h	2014-04-02 18:58:27 +0000
@@ -37,6 +37,7 @@
     boost::program_options::options_description_easy_init add_options();
 
 private:
+    void add_platform_options();
     // accessed via the base interface, when access to add_options() has been "lost"
     std::shared_ptr<options::Option> the_options() const override;
 

=== added file 'include/platform/mir/shared_library_loader.h'
--- include/platform/mir/shared_library_loader.h	1970-01-01 00:00:00 +0000
+++ include/platform/mir/shared_library_loader.h	2014-04-02 18:58:27 +0000
@@ -0,0 +1,28 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_SHARED_LIBRARY_LOADER_H_
+#define MIR_SHARED_LIBRARY_LOADER_H_
+
+#include <string>
+namespace mir
+{
+class SharedLibrary;
+SharedLibrary const* load_library(std::string const& libname);
+}
+#endif

=== modified file 'include/server/mir/compositor/buffer_stream.h'
--- include/server/mir/compositor/buffer_stream.h	2014-03-07 03:15:55 +0000
+++ include/server/mir/compositor/buffer_stream.h	2014-04-02 18:58:27 +0000
@@ -43,7 +43,7 @@
 
     virtual void swap_client_buffers(graphics::Buffer* old_buffer, std::function<void(graphics::Buffer* new_buffer)> complete) = 0;
     virtual std::shared_ptr<graphics::Buffer>
-        lock_compositor_buffer(unsigned long frameno) = 0;
+        lock_compositor_buffer(void const* user_id) = 0;
     virtual std::shared_ptr<graphics::Buffer> lock_snapshot_buffer() = 0;
     virtual MirPixelFormat get_stream_pixel_format() = 0;
     virtual geometry::Size stream_size() = 0;

=== modified file 'include/server/mir/compositor/gl_renderer.h'
--- include/server/mir/compositor/gl_renderer.h	2014-03-17 07:35:22 +0000
+++ include/server/mir/compositor/gl_renderer.h	2014-04-02 18:58:27 +0000
@@ -54,14 +54,27 @@
         GLfloat texcoord[2];
     };
 
+    struct Primitive
+    {
+        GLenum type; // GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES etc
+        GLuint tex_id;  // GL texture ID (or 0 to represent the surface itself)
+        std::vector<Vertex> vertices;
+    };
+
     /**
      * tessellate defines the list of triangles that will be used to render
      * the surface. By default it just returns 4 vertices for a rectangle.
      * However you can override its behaviour to tessellate more finely and
      * deform freely for effects like wobbly windows.
      *
-     * \returns The mode to be passed to glDrawArrays, e.g. GL_TRIANGLE_STRIP,
-     *          GL_TRIANGLE_FAN or GL_TRIANGLES.
+     * \param [in,out] primitives The list of rendering primitives to be
+     *                            grown and/or modified.
+     * \param [in]     renderable The renderable surface being tessellated.
+     * \param [in]     buf_size   The dimensions of the buffer being rendered,
+     *                            which can be particularly useful in
+     *                            calculating texcoords for a surface being
+     *                            actively resized (as the buf_size doesn't
+     *                            yet match renderable.size()).
      *
      * \note The cohesion of this function to GLRenderer is quite loose and it
      *       does not strictly need to reside here.
@@ -69,8 +82,18 @@
      *       the only OpenGL-specific class in the display server, and
      *       tessellation is very much OpenGL-specific.
      */
-    virtual GLenum tessellate(graphics::Renderable const& renderable,
-                              std::vector<Vertex>& vertices) const;
+    virtual void tessellate(std::vector<Primitive>& primitives,
+                            graphics::Renderable const& renderable,
+                            geometry::Size const& buf_size) const;
+
+    /**
+     * Load the texture for a surface any which way you like. The default
+     * implementation does so with efficient GPU-side caching built in.
+     *
+     * \returns The OpenGL texture name for the surface.
+     */
+    virtual GLuint load_texture(graphics::Renderable const& renderable,
+                                graphics::Buffer& buffer) const;
 
 private:
     GLuint vertex_shader;

=== modified file 'include/server/mir/compositor/renderer.h'
--- include/server/mir/compositor/renderer.h	2014-03-17 07:35:22 +0000
+++ include/server/mir/compositor/renderer.h	2014-04-02 18:58:27 +0000
@@ -40,8 +40,8 @@
     virtual void set_rotation(float degrees) = 0;
     virtual void begin() const = 0;
 
-    // XXX The buffer parameter here could now be replaced with a "frameno"
-    //     instead, and use renderable.buffer(frameno). Is that better?
+    // XXX The buffer parameter here could now be replaced with
+    //     renderable::buffer().
     virtual void render(graphics::Renderable const& renderable,
                         graphics::Buffer& buffer) const = 0;
     virtual void end() const = 0;

=== modified file 'include/server/mir/compositor/scene.h'
--- include/server/mir/compositor/scene.h	2014-03-17 07:35:22 +0000
+++ include/server/mir/compositor/scene.h	2014-04-02 18:58:27 +0000
@@ -20,6 +20,7 @@
 #define MIR_COMPOSITOR_SCENE_H_
 
 #include "mir/geometry/forward.h"
+#include "mir/graphics/renderable.h"
 
 #include <memory>
 #include <functional>
@@ -62,13 +63,15 @@
 public:
     virtual ~Scene() {}
 
+    /**
+     * Generate a valid list of renderables based on the current state of the Scene.
+     * \returns a list of mg::Renderables. The list is in stacking order from back to front.
+     */
+    virtual graphics::RenderableList generate_renderable_list() const = 0;
+
     // Back to front; normal rendering order
     virtual void for_each_if(FilterForScene& filter, OperatorForScene& op) = 0;
 
-    // Front to back; as used when scanning for occlusions
-    virtual void reverse_for_each_if(FilterForScene& filter,
-                                     OperatorForScene& op) = 0;
-
     /**
      * Sets a callback to be called whenever the state of the
      * Scene changes.

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/default_server_configuration.h	2014-04-02 18:58:27 +0000
@@ -61,7 +61,6 @@
 class SessionListener;
 class FocusController;
 class DisplayLayout;
-class SurfaceConfigurator;
 }
 namespace time
 {
@@ -69,6 +68,7 @@
 }
 namespace scene
 {
+class SurfaceFactory;
 class BroadcastingSessionEventSink;
 class BufferStreamFactory;
 class MediatingDisplayChanger;
@@ -78,7 +78,8 @@
 class SessionEventHandlerRegister;
 class SessionManager;
 class SnapshotStrategy;
-class SurfaceBuilder;
+class SurfaceCoordinator;
+class SurfaceConfigurator;
 class SurfaceStackModel;
 class SurfaceStack;
 class SurfaceRanker;
@@ -93,6 +94,7 @@
 class BufferInitializer;
 class DisplayReport;
 class GraphicBufferAllocator;
+class GLConfig;
 namespace nested { class HostConnection; }
 }
 namespace input
@@ -152,6 +154,7 @@
     virtual std::shared_ptr<graphics::DisplayConfigurationPolicy> the_display_configuration_policy();
     virtual std::shared_ptr<graphics::nested::HostConnection> the_host_connection();
     virtual std::shared_ptr<input::EventFilter> the_nested_event_filter();
+    virtual std::shared_ptr<graphics::GLConfig> the_gl_config();
     /** @} */
 
     /** @name graphics configuration - dependencies
@@ -198,12 +201,10 @@
      * configurable interfaces for modifying shell
      *  @{ */
     virtual std::shared_ptr<shell::SurfaceFactory>      the_shell_surface_factory();
-    virtual std::shared_ptr<shell::SurfaceFactory>      the_scene_surface_factory();
     virtual std::shared_ptr<shell::FocusSetter>         the_shell_focus_setter();
     virtual std::shared_ptr<shell::PlacementStrategy>   the_shell_placement_strategy();
     virtual std::shared_ptr<shell::SessionListener>     the_shell_session_listener();
     virtual std::shared_ptr<shell::DisplayLayout>       the_shell_display_layout();
-    virtual std::shared_ptr<shell::SurfaceConfigurator> the_shell_surface_configurator();
     /** @} */
 
     /** @name internal scene configuration
@@ -216,7 +217,10 @@
     virtual std::shared_ptr<scene::SessionEventSink>  the_session_event_sink();
     virtual std::shared_ptr<scene::SessionEventHandlerRegister> the_session_event_handler_register();
     virtual std::shared_ptr<scene::SurfaceStackModel> the_surface_stack_model();
-    virtual std::shared_ptr<scene::SurfaceRanker>   the_surface_ranker();
+    virtual std::shared_ptr<scene::SurfaceRanker>     the_surface_ranker();
+    virtual std::shared_ptr<scene::SurfaceFactory>    the_surface_factory();
+    virtual std::shared_ptr<scene::SurfaceCoordinator>the_surface_coordinator();
+    virtual std::shared_ptr<scene::SurfaceConfigurator> the_surface_configurator();
     /** @} */
 
     /** @name scene configuration - dependencies
@@ -284,7 +288,7 @@
     CachedPtr<scene::SceneReport> scene_report;
 
     CachedPtr<shell::SurfaceFactory> shell_surface_factory;
-    CachedPtr<shell::SurfaceFactory> scene_surface_factory;
+    CachedPtr<scene::SurfaceFactory> surface_factory;
     CachedPtr<scene::SessionContainer>  session_container;
     CachedPtr<shell::FocusSetter>       shell_focus_setter;
     CachedPtr<shell::PlacementStrategy> shell_placement_strategy;
@@ -292,7 +296,7 @@
     CachedPtr<scene::PixelBuffer>       pixel_buffer;
     CachedPtr<scene::SnapshotStrategy>  snapshot_strategy;
     CachedPtr<shell::DisplayLayout>     shell_display_layout;
-    CachedPtr<shell::SurfaceConfigurator> shell_surface_configurator;
+    CachedPtr<scene::SurfaceConfigurator> surface_configurator;
     CachedPtr<compositor::DisplayBufferCompositorFactory> display_buffer_compositor_factory;
     CachedPtr<compositor::Compositor> compositor;
     CachedPtr<compositor::CompositorReport> compositor_report;
@@ -304,6 +308,7 @@
     CachedPtr<graphics::DisplayConfigurationPolicy> display_configuration_policy;
     CachedPtr<graphics::nested::HostConnection> host_connection;
     CachedPtr<scene::MediatingDisplayChanger> mediating_display_changer;
+    CachedPtr<graphics::GLConfig> gl_config;
 
 private:
     std::shared_ptr<options::Configuration> const configuration_options;
@@ -321,7 +326,6 @@
     std::shared_ptr<scene::BroadcastingSessionEventSink> the_broadcasting_session_event_sink();
     std::shared_ptr<input::NestedInputRelay>        the_nested_input_relay();
     std::shared_ptr<scene::SessionManager>       the_session_manager();
-    std::shared_ptr<scene::SurfaceBuilder>       the_surface_builder();
     std::shared_ptr<scene::SurfaceController>    the_surface_controller();
 
     auto report_factory(char const* report_opt) -> std::unique_ptr<report::ReportFactory>;

=== modified file 'include/server/mir/frontend/display_changer.h'
--- include/server/mir/frontend/display_changer.h	2013-09-17 20:03:16 +0000
+++ include/server/mir/frontend/display_changer.h	2014-04-02 18:58:27 +0000
@@ -38,7 +38,6 @@
 
     virtual std::shared_ptr<graphics::DisplayConfiguration> active_configuration() = 0;
     virtual void configure(std::shared_ptr<Session> const&, std::shared_ptr<graphics::DisplayConfiguration> const&) = 0;
-    virtual void ensure_display_powered(std::shared_ptr<Session> const& session) = 0;
 
 protected:
     DisplayChanger() = default;

=== modified file 'include/server/mir/frontend/session_authorizer.h'
--- include/server/mir/frontend/session_authorizer.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/frontend/session_authorizer.h	2014-04-02 18:58:27 +0000
@@ -29,10 +29,12 @@
 class SessionAuthorizer
 {
 public:
-    virtual ~SessionAuthorizer() {}
+    virtual ~SessionAuthorizer() = default;
 
     virtual bool connection_is_allowed(pid_t pid) = 0;
     virtual bool configure_display_is_allowed(pid_t pid) = 0;
+    virtual bool screencast_is_allowed(pid_t pid) = 0;
+
 protected:
     SessionAuthorizer() = default;
     SessionAuthorizer(SessionAuthorizer const&) = delete;

=== modified file 'include/server/mir/input/surface.h'
--- include/server/mir/input/surface.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/input/surface.h	2014-04-02 18:58:27 +0000
@@ -30,7 +30,7 @@
 class Surface
 {
 public:
-    virtual std::string const& name() const = 0;
+    virtual std::string name() const = 0;
     virtual geometry::Point top_left() const = 0;
     virtual geometry::Size size() const = 0;
     virtual bool contains(geometry::Point const& point) const = 0;

=== added file 'include/server/mir/scene/surface.h'
--- include/server/mir/scene/surface.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/scene/surface.h	2014-04-02 18:58:27 +0000
@@ -0,0 +1,59 @@
+/*
+ * 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_SCENE_SURFACE_H_
+#define MIR_SCENE_SURFACE_H_
+
+#include "mir/graphics/renderable.h"
+#include "mir/input/surface.h"
+#include "mir/shell/surface.h"
+
+namespace mir
+{
+namespace input { class InputChannel; }
+
+namespace scene
+{
+class SurfaceObserver;
+
+class Surface :
+    public graphics::Renderable,
+    public input::Surface,
+    public shell::Surface
+{
+public:
+    // resolve ambiguous member function names
+    std::string name() const = 0;
+    geometry::Size size() const = 0;
+    geometry::Point top_left() const = 0;
+    float alpha() const = 0;
+
+    // member functions that don't exist in base classes
+    // TODO input_channel() and on_change() relate to
+    // TODO adding and removing the surface from the scene and are probably not
+    // TODO cleanest interface for this.
+    virtual std::shared_ptr<input::InputChannel> input_channel() const = 0;
+    virtual void on_change(std::function<void()> change_notification) = 0;
+
+    virtual void add_observer(std::shared_ptr<SurfaceObserver> const& observer) = 0;
+    virtual void remove_observer(std::shared_ptr<SurfaceObserver> const& observer) = 0;
+};
+}
+}
+
+#endif // MIR_SCENE_SURFACE_H_

=== renamed file 'include/server/mir/shell/surface_configurator.h' => 'include/server/mir/scene/surface_configurator.h'
--- include/server/mir/shell/surface_configurator.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/scene/surface_configurator.h	2014-04-02 18:58:27 +0000
@@ -16,8 +16,8 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
-#ifndef MIR_SHELL_SURFACE_CONFIGURATOR_H_
-#define MIR_SHELL_SURFACE_CONFIGURATOR_H_
+#ifndef MIR_SCENE_SURFACE_CONFIGURATOR_H_
+#define MIR_SCENE_SURFACE_CONFIGURATOR_H_
 
 #include "mir_toolkit/common.h"
 
@@ -26,7 +26,7 @@
 namespace mir
 {
 
-namespace shell
+namespace scene
 {
 class Surface;
 
@@ -51,4 +51,4 @@
 }
 } // namespace mir
 
-#endif // MIR_SHELL_SURFACE_CONFIGURATOR_H_
+#endif // MIR_SCENE_SURFACE_CONFIGURATOR_H_

=== renamed file 'src/server/scene/surface_builder.h' => 'include/server/mir/scene/surface_coordinator.h'
--- src/server/scene/surface_builder.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/scene/surface_coordinator.h	2014-04-02 18:58:27 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-14 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -17,8 +17,10 @@
  */
 
 
-#ifndef MIR_SCENE_SURFACE_BUILDER_H_
-#define MIR_SCENE_SURFACE_BUILDER_H_
+#ifndef MIR_SCENE_SURFACE_COORDINATOR_H_
+#define MIR_SCENE_SURFACE_COORDINATOR_H_
+
+#include "mir/scene/surface_ranker.h"
 
 #include <memory>
 
@@ -31,22 +33,25 @@
 
 namespace scene
 {
-class BasicSurface;
+class Surface;
+class SurfaceObserver;
 
-class SurfaceBuilder
+class SurfaceCoordinator : public SurfaceRanker
 {
 public:
-    virtual std::weak_ptr<BasicSurface> create_surface(shell::SurfaceCreationParameters const& params) = 0;
+    virtual std::shared_ptr<Surface> add_surface(
+        shell::SurfaceCreationParameters const& params,
+        std::shared_ptr<SurfaceObserver> const& observer) = 0;
 
-    virtual void destroy_surface(std::weak_ptr<BasicSurface> const& surface) = 0;
+    virtual void remove_surface(std::weak_ptr<Surface> const& surface) = 0;
 protected:
-    SurfaceBuilder() = default;
-    virtual ~SurfaceBuilder() = default;
-    SurfaceBuilder(SurfaceBuilder const&) = delete;
-    SurfaceBuilder& operator=(SurfaceBuilder const&) = delete;
+    SurfaceCoordinator() = default;
+    virtual ~SurfaceCoordinator() = default;
+    SurfaceCoordinator(SurfaceCoordinator const&) = delete;
+    SurfaceCoordinator& operator=(SurfaceCoordinator const&) = delete;
 };
 }
 }
 
 
-#endif /* MIR_SCENE_SURFACE_BUILDER_H_ */
+#endif /* MIR_SCENE_SURFACE_COORDINATOR_H_ */

=== added file 'include/server/mir/scene/surface_event_source.h'
--- include/server/mir/scene/surface_event_source.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/scene/surface_event_source.h	2014-04-02 18:58:27 +0000
@@ -0,0 +1,49 @@
+/*
+ * 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_SCENE_SURFACE_EVENT_SOURCE_H_
+#define MIR_SCENE_SURFACE_EVENT_SOURCE_H_
+
+#include "mir/scene/surface_observer.h"
+#include "mir/frontend/surface_id.h"
+#include "mir/frontend/event_sink.h"
+
+#include <memory>
+
+namespace mir
+{
+namespace scene
+{
+class SurfaceEventSource : public SurfaceObserver
+{
+public:
+    SurfaceEventSource(
+        frontend::SurfaceId id,
+        std::shared_ptr<frontend::EventSink> const& event_sink);
+
+    void attrib_change(MirSurfaceAttrib attrib, int value);
+    void resize(geometry::Size const& size);
+
+private:
+    frontend::SurfaceId const id;
+    std::shared_ptr<frontend::EventSink> const event_sink;
+};
+}
+}
+
+#endif // MIR_SCENE_SURFACE_EVENT_SOURCE_H_

=== renamed file 'src/server/scene/basic_surface_factory.h' => 'include/server/mir/scene/surface_factory.h'
--- src/server/scene/basic_surface_factory.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/scene/surface_factory.h	2014-04-02 18:58:27 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3,
@@ -16,33 +16,33 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#ifndef MIR_SCENE_BASIC_SURFACE_FACTORY_H_
-#define MIR_SCENE_BASIC_SURFACE_FACTORY_H_
+#ifndef MIR_SCENE_SURFACE_FACTORY_H_
+#define MIR_SCENE_SURFACE_FACTORY_H_
 
 #include "mir/shell/surface_creation_parameters.h"
 #include <memory>
-#include <functional>
 
 namespace mir
 {
 namespace scene
 {
+class Surface;
 
-class BasicSurface;
-class BasicSurfaceFactory
+class SurfaceFactory
 {
 public:
-    BasicSurfaceFactory() = default;
-    virtual ~BasicSurfaceFactory() = default;
-
-    virtual std::shared_ptr<BasicSurface> create_surface(
-        shell::SurfaceCreationParameters const&, std::function<void()> const&) = 0;
+    SurfaceFactory() = default;
+    virtual ~SurfaceFactory() = default;
+
+    virtual std::shared_ptr<Surface> create_surface(
+        shell::SurfaceCreationParameters const& params) = 0;
+
 private:
-    BasicSurfaceFactory(const BasicSurfaceFactory&) = delete;
-    BasicSurfaceFactory& operator=(const BasicSurfaceFactory&) = delete;
+    SurfaceFactory(const SurfaceFactory&) = delete;
+    SurfaceFactory& operator=(const SurfaceFactory&) = delete;
 };
 
 }
 }
 
-#endif /* MIR_SCENE_BASIC_SURFACE_FACTORY_H_ */
+#endif /* MIR_SCENE_SURFACE_FACTORY_H_ */

=== added file 'include/server/mir/scene/surface_observer.h'
--- include/server/mir/scene/surface_observer.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/scene/surface_observer.h	2014-04-02 18:58:27 +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]>
+ */
+
+#ifndef MIR_SCENE_SURFACE_OBSERVER_H_
+#define MIR_SCENE_SURFACE_OBSERVER_H_
+
+#include "mir/geometry/size.h"
+#include "mir_toolkit/common.h"
+
+namespace mir
+{
+namespace scene
+{
+// Initial cut - supporting the frontend requirement, more will follow
+class SurfaceObserver
+{
+public:
+    virtual void attrib_change(MirSurfaceAttrib attrib, int value) = 0;
+    virtual void resize(geometry::Size const& size) = 0;
+
+protected:
+    SurfaceObserver() = default;
+    virtual ~SurfaceObserver() = default;
+    SurfaceObserver(SurfaceObserver const&) = delete;
+    SurfaceObserver& operator=(SurfaceObserver const&) = delete;
+};
+}
+}
+
+#endif // MIR_SCENE_SURFACE_OBSERVER_H_

=== renamed file 'src/server/scene/surface_ranker.h' => 'include/server/mir/scene/surface_ranker.h'
--- src/server/scene/surface_ranker.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/scene/surface_ranker.h	2014-04-02 18:58:27 +0000
@@ -26,12 +26,12 @@
 {
 namespace scene
 {
-class BasicSurface;
+class Surface;
 
 class SurfaceRanker
 {
 public:
-    virtual void raise(std::weak_ptr<BasicSurface> const& surface) = 0;
+    virtual void raise(std::weak_ptr<Surface> const& surface) = 0;
 
 protected:
     SurfaceRanker() = default;

=== modified file 'include/server/mir/shell/surface.h'
--- include/server/mir/shell/surface.h	2014-03-06 06:05:17 +0000
+++ include/server/mir/shell/surface.h	2014-04-02 18:58:27 +0000
@@ -50,10 +50,8 @@
 
     virtual void allow_framedropping(bool) = 0;
 
-    virtual void raise(std::shared_ptr<scene::SurfaceRanker> const& controller) = 0;
-
     virtual void resize(geometry::Size const& size) = 0;
-    virtual void set_rotation(float degrees, glm::vec3 const& axis) = 0;
+    virtual void set_transformation(glm::mat4 const& t) = 0;
 
     virtual float alpha() const = 0;
     virtual void set_alpha(float alpha) = 0;

=== modified file 'include/server/mir/shell/surface_factory.h'
--- include/server/mir/shell/surface_factory.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/shell/surface_factory.h	2014-04-02 18:58:27 +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,
@@ -19,15 +19,12 @@
 #ifndef MIR_SHELL_SURFACE_FACTORY_H_
 #define MIR_SHELL_SURFACE_FACTORY_H_
 
-#include "mir/frontend/surface_id.h"
 #include <memory>
 
 namespace mir
 {
-namespace frontend
-{
-class EventSink;
-}
+namespace scene { class SurfaceObserver; }
+
 namespace shell
 {
 class Session;
@@ -40,8 +37,9 @@
     virtual std::shared_ptr<Surface> create_surface(
         Session* session,
         SurfaceCreationParameters const& params,
-        frontend::SurfaceId id,
-        std::shared_ptr<frontend::EventSink> const& sink) = 0;
+        std::shared_ptr<scene::SurfaceObserver> const& observer) = 0;
+
+    virtual void destroy_surface(std::shared_ptr<Surface> const& surface) = 0;
 
 protected:
     virtual ~SurfaceFactory() {}

=== added file 'include/shared/mir/geometry/length.h'
--- include/shared/mir/geometry/length.h	1970-01-01 00:00:00 +0000
+++ include/shared/mir/geometry/length.h	2014-04-02 18:58:27 +0000
@@ -0,0 +1,102 @@
+/*
+ * 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: Daniel van Vugt <[e-mail]>
+ */
+
+#ifndef MIR_GEOMETRY_LENGTH_H_
+#define MIR_GEOMETRY_LENGTH_H_
+
+namespace mir
+{
+namespace geometry
+{
+
+/// Length represents a physical length in the real world. The number of pixels
+/// this equates to can then be calculated based on a given DPI.
+class Length
+{
+public:
+    enum Units
+    {
+        micrometres = 1,
+        millimetres = 1000,
+        centimetres = 10000,
+        inches = 25400
+    };
+
+    Length() : magnitude(0) {}
+    Length(Length const&) = default;
+    Length& operator=(Length const&) = default;
+    Length(float mag, Units units) : magnitude(mag * units) {}
+
+    float as(Units units) const
+    {
+        return static_cast<float>(magnitude) / units;
+    }
+
+    float as_pixels(float dpi) const
+    {
+        return as(inches) * dpi;
+    }
+
+    bool operator==(Length const& rhs) const
+    {
+        return magnitude == rhs.magnitude;
+    }
+
+    bool operator!=(Length const& rhs) const
+    {
+        return magnitude != rhs.magnitude;
+    }
+
+private:
+    float magnitude;
+};
+
+inline Length operator"" _mm(long double mag)
+{
+    return Length(mag, Length::millimetres);
+}
+
+inline Length operator"" _mm(unsigned long long mag)
+{
+    return Length(mag, Length::millimetres);
+}
+
+inline Length operator"" _cm(long double mag)
+{
+    return Length(mag, Length::centimetres);
+}
+
+inline Length operator"" _cm(unsigned long long mag)
+{
+    return Length(mag, Length::centimetres);
+}
+
+inline Length operator"" _in(long double mag)
+{
+    return Length(mag, Length::inches);
+}
+
+inline Length operator"" _in(unsigned long long mag)
+{
+    return Length(mag, Length::inches);
+}
+
+} // namespace geometry
+} // namespace mir
+
+#endif // MIR_GEOMETRY_LENGTH_H_

=== modified file 'include/test/mir_test_doubles/fake_renderable.h'
--- include/test/mir_test_doubles/fake_renderable.h	2014-03-17 07:35:22 +0000
+++ include/test/mir_test_doubles/fake_renderable.h	2014-04-02 18:58:27 +0000
@@ -42,7 +42,7 @@
         : rect{{x, y}, {width, height}},
           opacity(opacity),
           rectangular(rectangular),
-          visible(visible),
+          visible_(visible),
           posted(posted)
     {
     }
@@ -57,9 +57,9 @@
         return glm::mat4();
     }
 
-    bool should_be_rendered_in(const mir::geometry::Rectangle &r) const override
+    bool visible() const override
     {
-        return visible && posted && rect.overlaps(r);
+        return visible_ && posted;
     }
 
     bool shaped() const override
@@ -72,7 +72,7 @@
         buf = b;
     }
 
-    std::shared_ptr<graphics::Buffer> buffer(unsigned long) const override
+    std::shared_ptr<graphics::Buffer> buffer(void const*) const override
     {
         return buf;
     }
@@ -97,7 +97,7 @@
     mir::geometry::Rectangle rect;
     float opacity;
     bool rectangular;
-    bool visible;
+    bool visible_;
     bool posted;
 };
 

=== modified file 'include/test/mir_test_doubles/mock_buffer_bundle.h'
--- include/test/mir_test_doubles/mock_buffer_bundle.h	2014-03-07 03:15:55 +0000
+++ include/test/mir_test_doubles/mock_buffer_bundle.h	2014-04-02 18:58:27 +0000
@@ -39,7 +39,7 @@
 
     MOCK_METHOD1(client_acquire,     void(std::function<void(graphics::Buffer*)>));
     MOCK_METHOD1(client_release,     void(graphics::Buffer*));
-    MOCK_METHOD1(compositor_acquire, std::shared_ptr<graphics::Buffer>(unsigned long));
+    MOCK_METHOD1(compositor_acquire, std::shared_ptr<graphics::Buffer>(void const*));
     MOCK_METHOD1(compositor_release, void(std::shared_ptr<graphics::Buffer> const&));
     MOCK_METHOD0(snapshot_acquire, std::shared_ptr<graphics::Buffer>());
     MOCK_METHOD1(snapshot_release, void(std::shared_ptr<graphics::Buffer> const&));

=== modified file 'include/test/mir_test_doubles/mock_buffer_stream.h'
--- include/test/mir_test_doubles/mock_buffer_stream.h	2014-03-07 03:15:55 +0000
+++ include/test/mir_test_doubles/mock_buffer_stream.h	2014-04-02 18:58:27 +0000
@@ -33,7 +33,7 @@
 {
     MOCK_METHOD2(swap_client_buffers, void(graphics::Buffer*, std::function<void(graphics::Buffer*)> completee));
     MOCK_METHOD1(lock_compositor_buffer,
-                 std::shared_ptr<graphics::Buffer>(unsigned long));
+                 std::shared_ptr<graphics::Buffer>(void const*));
     MOCK_METHOD0(lock_snapshot_buffer, std::shared_ptr<graphics::Buffer>());
 
     MOCK_METHOD0(get_stream_pixel_format, MirPixelFormat());

=== modified file 'include/test/mir_test_doubles/mock_display_buffer.h'
--- include/test/mir_test_doubles/mock_display_buffer.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/mock_display_buffer.h	2014-04-02 18:58:27 +0000
@@ -46,7 +46,7 @@
     MOCK_METHOD0(release_current, void());
     MOCK_METHOD0(post_update, void());
     MOCK_CONST_METHOD0(can_bypass, bool());
-    MOCK_METHOD2(render_and_post_update, void(std::list<std::shared_ptr<graphics::Renderable>> const&, 
+    MOCK_METHOD2(render_and_post_update, void(graphics::RenderableList const&, 
                                    std::function<void(graphics::Renderable const&)> const&));
     MOCK_CONST_METHOD0(orientation, MirOrientation());
 };

=== modified file 'include/test/mir_test_doubles/mock_display_changer.h'
--- include/test/mir_test_doubles/mock_display_changer.h	2013-09-17 20:03:16 +0000
+++ include/test/mir_test_doubles/mock_display_changer.h	2014-04-02 18:58:27 +0000
@@ -35,7 +35,6 @@
     MOCK_METHOD0(active_configuration, std::shared_ptr<graphics::DisplayConfiguration>());
     MOCK_METHOD2(configure,
         void(std::shared_ptr<frontend::Session> const&, std::shared_ptr<graphics::DisplayConfiguration> const&));
-    MOCK_METHOD1(ensure_display_powered, void(std::shared_ptr<frontend::Session> const&));
 };
 
 }

=== modified file 'include/test/mir_test_doubles/mock_display_device.h'
--- include/test/mir_test_doubles/mock_display_device.h	2014-03-11 13:44:57 +0000
+++ include/test/mir_test_doubles/mock_display_device.h	2014-04-02 18:58:27 +0000
@@ -38,7 +38,7 @@
     MOCK_METHOD1(render_gl, void(graphics::android::SwappingGLContext const&));
     MOCK_METHOD3(render_gl_and_overlays, void(
         graphics::android::SwappingGLContext const&,
-        std::list<std::shared_ptr<graphics::Renderable>> const&,
+        graphics::RenderableList const&,
         std::function<void(graphics::Renderable const&)> const&));
     MOCK_METHOD1(post, void(graphics::Buffer const&));
     MOCK_CONST_METHOD1(apply_orientation, bool(MirOrientation));

=== modified file 'include/test/mir_test_doubles/mock_egl.h'
--- include/test/mir_test_doubles/mock_egl.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/mock_egl.h	2014-04-02 18:58:27 +0000
@@ -53,6 +53,33 @@
     return false;
 }
 
+MATCHER_P2(EGLConfigContainsAttrib, attrib, value, "")
+{
+    bool attrib_position = true;
+    bool attrib_found = false;
+
+    while (!attrib_position || *arg != EGL_NONE)
+    {
+        if (attrib_position && *arg == attrib)
+        {
+            attrib_found = true;
+        }
+        else if (!attrib_position)
+        {
+            if (attrib_found && *arg == value)
+            {
+                return true;
+            }
+
+            attrib_found = false;
+        }
+        attrib_position = !attrib_position;
+        ++arg;
+    }
+
+    return false;
+}
+
 class MockEGL
 {
 public:

=== added file 'include/test/mir_test_doubles/mock_gl_config.h'
--- include/test/mir_test_doubles/mock_gl_config.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_gl_config.h	2014-04-02 18:58:27 +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: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_GL_CONFIG_H_
+#define MIR_TEST_DOUBLES_MOCK_GL_CONFIG_H_
+
+#include "mir/graphics/gl_config.h"
+
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct MockGLConfig : public graphics::GLConfig
+{
+    MOCK_CONST_METHOD0(depth_buffer_bits, int());
+    MOCK_CONST_METHOD0(stencil_buffer_bits, int());
+};
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_MOCK_GL_CONFIG_H_ */

=== modified file 'include/test/mir_test_doubles/mock_hwc_composer_device_1.h'
--- include/test/mir_test_doubles/mock_hwc_composer_device_1.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/mock_hwc_composer_device_1.h	2014-04-02 18:58:27 +0000
@@ -21,8 +21,6 @@
 
 #include <hardware/hwcomposer.h>
 #include <gmock/gmock.h>
-#include <vector>
-#include <memory>
 
 namespace mir
 {
@@ -37,16 +35,6 @@
     MockHWCComposerDevice1()
     {
         using namespace testing;
-
-        primary_prepare = false;
-        primary_set = false;
-        external_prepare = false;
-        external_set = false;
-        virtual_prepare = false;
-        virtual_set = false;
-        fb_fence = -1;
-        retire_fence = -1;
-
         common.version = HWC_DEVICE_API_VERSION_1_1;
 
         registerProcs = hook_registerProcs;
@@ -56,91 +44,6 @@
         blank = hook_blank;
         getDisplayConfigs = hook_getDisplayConfigs;
         getDisplayAttributes = hook_getDisplayAttributes;
-
-        ON_CALL(*this, set_interface(_,_,_))
-            .WillByDefault(Invoke(this, &MockHWCComposerDevice1::save_last_set_arguments));
-        ON_CALL(*this, prepare_interface(_,_,_))
-            .WillByDefault(Invoke(this, &MockHWCComposerDevice1::save_last_prepare_arguments));
-    }
-
-    int save_args(hwc_display_contents_1_t* out, hwc_display_contents_1_t** in)
-    {
-        if ((nullptr == in) || (nullptr == *in))
-            return -1;
-
-        hwc_display_contents_1_t* primary_display = *in;
-        memcpy(out, primary_display, sizeof(hwc_display_contents_1_t));
-        return 0;
-    }
-
-    void hwc_set_return_fence(int fence)
-    {
-        fb_fence = fence;
-    }
-
-    void hwc_set_retire_fence(int fence)
-    {
-        retire_fence = fence;
-    }
-
-    int save_last_prepare_arguments(struct hwc_composer_device_1 *, size_t size, hwc_display_contents_1_t** displays)
-    {
-        if ((size == 0) || (!displays)) 
-            return -1;
-
-        switch (size)
-        {
-            case 3:
-                virtual_prepare = (!!displays[2]);
-            case 2:
-                external_prepare = (!!displays[1]);
-            case 1:
-                primary_prepare = (!!displays[0]);
-                for(auto i = 0u; i < displays[0]->numHwLayers; i++)
-                {
-                    prepare_layerlist.push_back(displays[0]->hwLayers[i]);
-                    prepare_layerlist.back().visibleRegionScreen = {0, nullptr};
-                }
-                save_args(&display0_prepare_content, displays);
-            default:
-                break;
-        }
-        return 0;
-    }
-
-    int save_last_set_arguments(
-        struct hwc_composer_device_1 *, size_t size, hwc_display_contents_1_t** displays)
-    {
-
-        if ((size == 0) || (!displays)) 
-            return -1;
-
-        switch (size)
-        {
-            case 3:
-                virtual_set = (!!displays[2]);
-            case 2:
-                external_set = (!!displays[1]);
-            case 1:
-                primary_set = (!!displays[0]);
-                for(auto i = 0u; i < displays[0]->numHwLayers; i++)
-                {
-                    set_layerlist.push_back(displays[0]->hwLayers[i]);
-                    set_layerlist.back().visibleRegionScreen = {0, nullptr};
-                }
-
-                save_args(&display0_set_content, displays);
-
-                if (displays[0]->numHwLayers >= 2)
-                {
-                    displays[0]->hwLayers[1].releaseFenceFd = fb_fence;
-                    displays[0]->retireFenceFd = retire_fence;
-                }
-
-            default:
-                break;
-        }
-        return 0;
     }
 
     static void hook_registerProcs(struct hwc_composer_device_1* mock_hwc, hwc_procs_t const* procs)
@@ -188,14 +91,6 @@
     MOCK_METHOD3(blank_interface, int(struct hwc_composer_device_1 *, int, int));
     MOCK_METHOD4(getDisplayConfigs_interface, int(struct hwc_composer_device_1*, int, uint32_t*, size_t*));
     MOCK_METHOD5(getDisplayAttributes_interface, int(struct hwc_composer_device_1*, int, uint32_t, const uint32_t*, int32_t*));
-
-    bool primary_prepare, primary_set, external_prepare, external_set, virtual_prepare, virtual_set;
-    hwc_display_contents_1_t display0_set_content;
-    std::vector<hwc_layer_1> set_layerlist;
-    std::vector<hwc_layer_1> prepare_layerlist;
-    hwc_display_contents_1_t display0_prepare_content;
-    int fb_fence;
-    int retire_fence;
 };
 
 }

=== added file 'include/test/mir_test_doubles/mock_hwc_device_wrapper.h'
--- include/test/mir_test_doubles/mock_hwc_device_wrapper.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_hwc_device_wrapper.h	2014-04-02 18:58:27 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_HWC_DEVICE_WRAPPER_H_
+#define MIR_TEST_DOUBLES_MOCK_HWC_DEVICE_WRAPPER_H_
+
+#include "src/platform/graphics/android/hwc_wrapper.h"
+
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct MockHWCDeviceWrapper : public graphics::android::HwcWrapper
+{
+    MOCK_CONST_METHOD1(prepare, void(hwc_display_contents_1_t&));
+    MOCK_CONST_METHOD1(set, void(hwc_display_contents_1_t&));
+};
+
+}
+}
+}
+#endif /* MIR_TEST_DOUBLES_MOCK_HWC_DEVICE_WRAPPER_H_ */

=== modified file 'include/test/mir_test_doubles/mock_input_surface.h'
--- include/test/mir_test_doubles/mock_input_surface.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/mock_input_surface.h	2014-04-02 18:58:27 +0000
@@ -43,12 +43,12 @@
                 Return(geometry::Size{}));
         static std::string n;
         ON_CALL(*this, name())
-            .WillByDefault(testing::ReturnRef(n));
+            .WillByDefault(testing::Return(n));
     }
     ~MockInputSurface() noexcept {}
     MOCK_CONST_METHOD0(top_left, geometry::Point());
     MOCK_CONST_METHOD0(size, geometry::Size());
-    MOCK_CONST_METHOD0(name, std::string const&());
+    MOCK_CONST_METHOD0(name, std::string());
     MOCK_CONST_METHOD1(contains, bool(geometry::Point const&));
 };
 

=== modified file 'include/test/mir_test_doubles/mock_renderable.h'
--- include/test/mir_test_doubles/mock_renderable.h	2014-03-17 07:35:22 +0000
+++ include/test/mir_test_doubles/mock_renderable.h	2014-04-02 18:58:27 +0000
@@ -37,15 +37,24 @@
             .WillByDefault(testing::Return(geometry::Rectangle{{},{}}));
         ON_CALL(*this, buffer(testing::_))
             .WillByDefault(testing::Return(std::make_shared<StubBuffer>()));
+        ON_CALL(*this, buffers_ready_for_compositor())
+            .WillByDefault(testing::Return(1));
+        ON_CALL(*this, alpha())
+            .WillByDefault(testing::Return(1.0f));
+        ON_CALL(*this, transformation())
+            .WillByDefault(testing::Return(glm::mat4{}));
+        ON_CALL(*this, visible())
+            .WillByDefault(testing::Return(true));
     }
-    MOCK_CONST_METHOD1(buffer, std::shared_ptr<graphics::Buffer>(unsigned long));
+
+    MOCK_CONST_METHOD1(buffer, std::shared_ptr<graphics::Buffer>(void const*));
     MOCK_CONST_METHOD0(alpha_enabled, bool());
     MOCK_CONST_METHOD0(screen_position, geometry::Rectangle());
     MOCK_CONST_METHOD0(alpha, float());
     MOCK_CONST_METHOD0(transformation, glm::mat4());
-    MOCK_CONST_METHOD1(should_be_rendered_in, bool(geometry::Rectangle const& rect));
+    MOCK_CONST_METHOD0(visible, bool());
     MOCK_CONST_METHOD0(shaped, bool());
-    int buffers_ready_for_compositor() const override { return 1; }
+    MOCK_CONST_METHOD0(buffers_ready_for_compositor, int());
 };
 }
 }

=== modified file 'include/test/mir_test_doubles/mock_scene.h'
--- include/test/mir_test_doubles/mock_scene.h	2014-03-13 09:22:13 +0000
+++ include/test/mir_test_doubles/mock_scene.h	2014-04-02 18:58:27 +0000
@@ -32,10 +32,14 @@
 class MockScene : public compositor::Scene
 {
 public:
+    MockScene()
+    {
+        ON_CALL(*this, generate_renderable_list())
+            .WillByDefault(testing::Return(graphics::RenderableList{}));
+    }
+    MOCK_CONST_METHOD0(generate_renderable_list, graphics::RenderableList());
     MOCK_METHOD2(for_each_if, void(compositor::FilterForScene&,
                                    compositor::OperatorForScene&));
-    MOCK_METHOD2(reverse_for_each_if, void(compositor::FilterForScene&,
-                                           compositor::OperatorForScene&));
     MOCK_METHOD1(set_change_callback, void(std::function<void()> const&));
     MOCK_METHOD0(lock, void());
     MOCK_METHOD0(unlock, void());

=== modified file 'include/test/mir_test_doubles/mock_surface.h'
--- include/test/mir_test_doubles/mock_surface.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/mock_surface.h	2014-04-02 18:58:27 +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,
@@ -19,16 +19,11 @@
 #ifndef MIR_TEST_DOUBLES_MOCK_SURFACE_H_
 #define MIR_TEST_DOUBLES_MOCK_SURFACE_H_
 
-#include "src/server/scene/surface_impl.h"
-
-#include "mir/shell/surface_creation_parameters.h"
-#include "null_event_sink.h"
-#include "null_surface_configurator.h"
+#include "src/server/scene/basic_surface.h"
+#include "src/server/report/null_report_factory.h"
 
 #include <gmock/gmock.h>
 
-#include <memory>
-
 namespace mir
 {
 namespace test
@@ -36,10 +31,17 @@
 namespace doubles
 {
 
-struct MockSurface : public scene::SurfaceImpl
+struct MockSurface : public scene::BasicSurface
 {
-    MockSurface(std::shared_ptr<scene::SurfaceBuilder> const& builder) :
-        scene::SurfaceImpl(builder, std::make_shared<NullSurfaceConfigurator>(), shell::a_surface(), frontend::SurfaceId{}, std::make_shared<NullEventSink>())
+    MockSurface() :
+        scene::BasicSurface(
+            {},
+            {{},{}},
+            true,
+            {},
+            {},
+            {},
+            mir::report::null_scene_report())
     {
     }
 
@@ -53,7 +55,6 @@
     MOCK_METHOD0(force_requests_to_complete, void());
     MOCK_METHOD0(advance_client_buffer, std::shared_ptr<graphics::Buffer>());
 
-    MOCK_CONST_METHOD0(name, std::string());
     MOCK_CONST_METHOD0(size, geometry::Size());
     MOCK_CONST_METHOD0(pixel_format, MirPixelFormat());
 
@@ -62,6 +63,7 @@
 
     MOCK_METHOD2(configure, int(MirSurfaceAttrib, int));
     MOCK_METHOD1(take_input_focus, void(std::shared_ptr<shell::InputTargeter> const&));
+    MOCK_METHOD1(add_observer, void(std::shared_ptr<scene::SurfaceObserver> const&));
 };
 
 }

=== modified file 'include/test/mir_test_doubles/mock_surface_configurator.h'
--- include/test/mir_test_doubles/mock_surface_configurator.h	2013-07-31 23:09:53 +0000
+++ include/test/mir_test_doubles/mock_surface_configurator.h	2014-04-02 18:58:27 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_TEST_DOUBLES_MOCK_SURFACE_CONFIGURATOR_H_
 #define MIR_TEST_DOUBLES_MOCK_SURFACE_CONFIGURATOR_H_
 
-#include "mir/shell/surface_configurator.h"
+#include "mir/scene/surface_configurator.h"
 
 #include <gmock/gmock.h>
 
@@ -30,10 +30,10 @@
 namespace doubles
 {
 
-struct MockSurfaceConfigurator : public shell::SurfaceConfigurator
+struct MockSurfaceConfigurator : public scene::SurfaceConfigurator
 {
-    MOCK_METHOD3(select_attribute_value, int(shell::Surface const&, MirSurfaceAttrib, int));
-    MOCK_METHOD3(attribute_set, void(shell::Surface const&, MirSurfaceAttrib, int));
+    MOCK_METHOD3(select_attribute_value, int(scene::Surface const&, MirSurfaceAttrib, int));
+    MOCK_METHOD3(attribute_set, void(scene::Surface const&, MirSurfaceAttrib, int));
 };
 
 }

=== modified file 'include/test/mir_test_doubles/mock_surface_factory.h'
--- include/test/mir_test_doubles/mock_surface_factory.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/mock_surface_factory.h	2014-04-02 18:58:27 +0000
@@ -33,11 +33,12 @@
 
 struct MockSurfaceFactory : public shell::SurfaceFactory
 {
-    MOCK_METHOD4(create_surface, std::shared_ptr<shell::Surface>(
+    MOCK_METHOD3(create_surface, std::shared_ptr<shell::Surface>(
         shell::Session*,
         const shell::SurfaceCreationParameters&,
-        frontend::SurfaceId,
-        std::shared_ptr<frontend::EventSink> const&));
+        std::shared_ptr<scene::SurfaceObserver> const&));
+
+    void destroy_surface(std::shared_ptr<shell::Surface> const& /*surface*/) override {}
 };
 
 }

=== modified file 'include/test/mir_test_doubles/mock_surface_ranker.h'
--- include/test/mir_test_doubles/mock_surface_ranker.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/mock_surface_ranker.h	2014-04-02 18:58:27 +0000
@@ -20,7 +20,7 @@
 #ifndef MIR_TEST_DOUBLES_MOCK_SURFACE_RANKER_H_
 #define MIR_TEST_DOUBLES_MOCK_SURFACE_RANKER_H_
 
-#include "src/server/scene/surface_ranker.h"
+#include "mir/scene/surface_ranker.h"
 
 #include <gmock/gmock.h>
 
@@ -33,7 +33,7 @@
 
 struct MockSurfaceRanker : public scene::SurfaceRanker
 {
-    MOCK_METHOD1(raise, void(std::weak_ptr<scene::BasicSurface> const&));
+    MOCK_METHOD1(raise, void(std::weak_ptr<scene::Surface> const&));
 };
 
 }

=== modified file 'include/test/mir_test_doubles/null_display_buffer.h'
--- include/test/mir_test_doubles/null_display_buffer.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/null_display_buffer.h	2014-04-02 18:58:27 +0000
@@ -37,7 +37,7 @@
     void post_update() {}
     bool can_bypass() const override { return false; }
     void render_and_post_update(
-        std::list<std::shared_ptr<graphics::Renderable>> const&,
+        graphics::RenderableList const&,
         std::function<void(graphics::Renderable const&)> const&) {}
     MirOrientation orientation() const override { return mir_orientation_normal; }
 };

=== modified file 'include/test/mir_test_doubles/null_display_changer.h'
--- include/test/mir_test_doubles/null_display_changer.h	2013-09-17 20:03:16 +0000
+++ include/test/mir_test_doubles/null_display_changer.h	2014-04-02 18:58:27 +0000
@@ -39,9 +39,6 @@
     virtual void configure(std::shared_ptr<frontend::Session> const&, std::shared_ptr<graphics::DisplayConfiguration> const&)
     {
     }
-    virtual void ensure_display_powered(std::shared_ptr<frontend::Session> const&)
-    {
-    }
 };
 }
 }

=== modified file 'include/test/mir_test_doubles/null_platform.h'
--- include/test/mir_test_doubles/null_platform.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/null_platform.h	2014-04-02 18:58:27 +0000
@@ -39,7 +39,8 @@
     }
 
     std::shared_ptr<graphics::Display> create_display(
-        std::shared_ptr<graphics::DisplayConfigurationPolicy> const&)
+        std::shared_ptr<graphics::DisplayConfigurationPolicy> const&,
+        std::shared_ptr<graphics::GLConfig> const&)
     {
         return std::make_shared<NullDisplay>();
     }

=== modified file 'include/test/mir_test_doubles/null_surface_configurator.h'
--- include/test/mir_test_doubles/null_surface_configurator.h	2013-07-29 22:55:20 +0000
+++ include/test/mir_test_doubles/null_surface_configurator.h	2014-04-02 18:58:27 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_TEST_DOUBLES_NULL_SURFACE_CONFIGURATOR_H_
 #define MIR_TEST_DOUBLES_NULL_SURFACE_CONFIGURATOR_H_
 
-#include "mir/shell/surface_configurator.h"
+#include "mir/scene/surface_configurator.h"
 
 namespace mir
 {
@@ -28,14 +28,14 @@
 namespace doubles
 {
 
-struct NullSurfaceConfigurator : public shell::SurfaceConfigurator
+struct NullSurfaceConfigurator : public scene::SurfaceConfigurator
 {
-    int select_attribute_value(shell::Surface const&,
+    int select_attribute_value(scene::Surface const&,
                                MirSurfaceAttrib, int requested_value)
     {
         return requested_value;
     }
-    void attribute_set(shell::Surface const&,
+    void attribute_set(scene::Surface const&,
                        MirSurfaceAttrib, int)
     {
     }

=== modified file 'include/test/mir_test_doubles/stub_buffer_stream.h'
--- include/test/mir_test_doubles/stub_buffer_stream.h	2014-03-07 03:15:55 +0000
+++ include/test/mir_test_doubles/stub_buffer_stream.h	2014-04-02 18:58:27 +0000
@@ -40,7 +40,7 @@
     {
         complete(&stub_client_buffer);
     }
-    std::shared_ptr<graphics::Buffer> lock_compositor_buffer(unsigned long) override
+    std::shared_ptr<graphics::Buffer> lock_compositor_buffer(void const*) override
     {
         return stub_compositor_buffer;
     }

=== modified file 'include/test/mir_test_doubles/stub_display_builder.h'
--- include/test/mir_test_doubles/stub_display_builder.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/stub_display_builder.h	2014-04-02 18:58:27 +0000
@@ -43,7 +43,7 @@
     void post_update() {}
     bool can_bypass() const override { return false; }
     void render_and_post_update(
-        std::list<std::shared_ptr<graphics::Renderable>> const&,
+        graphics::RenderableList const&,
         std::function<void(graphics::Renderable const&)> const&) {}
     MirOrientation orientation() const override { return mir_orientation_normal; }
     void configure(graphics::DisplayConfigurationOutput const&) {} 

=== modified file 'include/test/mir_test_doubles/stub_display_device.h'
--- include/test/mir_test_doubles/stub_display_device.h	2014-03-11 13:44:57 +0000
+++ include/test/mir_test_doubles/stub_display_device.h	2014-04-02 18:58:27 +0000
@@ -40,7 +40,7 @@
     }
     void render_gl_and_overlays(
         graphics::android::SwappingGLContext const&,
-        std::list<std::shared_ptr<graphics::Renderable>> const&,
+        graphics::RenderableList const&,
         std::function<void(graphics::Renderable const&)> const&)
     {
     }

=== added file 'include/test/mir_test_doubles/stub_gl_config.h'
--- include/test/mir_test_doubles/stub_gl_config.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_gl_config.h	2014-04-02 18:58:27 +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: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_GL_CONFIG_H_
+#define MIR_TEST_DOUBLES_STUB_GL_CONFIG_H_
+
+#include "mir/graphics/gl_config.h"
+
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct StubGLConfig : public graphics::GLConfig
+{
+    int depth_buffer_bits() const override { return 0; }
+    int stencil_buffer_bits() const override { return 0; }
+};
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_STUB_GL_CONFIG_H_ */

=== modified file 'include/test/mir_test_doubles/stub_ipc_factory.h'
--- include/test/mir_test_doubles/stub_ipc_factory.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/stub_ipc_factory.h	2014-04-02 18:58:27 +0000
@@ -41,7 +41,7 @@
     }
 
     std::shared_ptr<protobuf::DisplayServer> make_ipc_server(
-        pid_t, std::shared_ptr<frontend::EventSink> const&, bool) override
+        pid_t, std::shared_ptr<frontend::EventSink> const&) override
     {
         return server;
     }

=== modified file 'include/test/mir_test_doubles/stub_renderable.h'
--- include/test/mir_test_doubles/stub_renderable.h	2014-03-17 07:35:22 +0000
+++ include/test/mir_test_doubles/stub_renderable.h	2014-04-02 18:58:27 +0000
@@ -33,7 +33,7 @@
 class StubRenderable : public graphics::Renderable
 {
 public:
-    std::shared_ptr<graphics::Buffer> buffer(unsigned long) const override
+    std::shared_ptr<graphics::Buffer> buffer(void const*) const override
     {
         return std::make_shared<StubBuffer>();
     }
@@ -53,7 +53,7 @@
     {
         return trans;
     }
-    bool should_be_rendered_in(geometry::Rectangle const&) const override
+    bool visible() const
     {
         return true;
     }

=== modified file 'include/test/mir_test_doubles/stub_session_authorizer.h'
--- include/test/mir_test_doubles/stub_session_authorizer.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/stub_session_authorizer.h	2014-04-02 18:58:27 +0000
@@ -38,6 +38,10 @@
     {
         return true;
     }
+    bool screencast_is_allowed(pid_t)
+    {
+        return true;
+    }
 };
 
 }

=== removed file 'include/test/mir_test_doubles/stub_surface_builder.h'
--- include/test/mir_test_doubles/stub_surface_builder.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/stub_surface_builder.h	1970-01-01 00:00:00 +0000
@@ -1,69 +0,0 @@
-/*
- * Copyright © 2013-2014 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Alan Griffiths <[e-mail]>
- */
-
-
-#ifndef MIR_TEST_DOUBLES_STUB_SURFACE_BUILDER_H_
-#define MIR_TEST_DOUBLES_STUB_SURFACE_BUILDER_H_
-
-#include "src/server/scene/surface_builder.h"
-#include "src/server/scene/basic_surface.h"
-#include "src/server/report/null_report_factory.h"
-#include "mir/shell/surface_creation_parameters.h"
-
-#include "mir_test_doubles/stub_buffer_stream.h"
-#include <memory>
-namespace mir
-{
-namespace test
-{
-namespace doubles
-{
-
-class StubSurfaceBuilder : public scene::SurfaceBuilder
-{
-public:
-    StubSurfaceBuilder() :
-        dummy_surface(std::make_shared<scene::BasicSurface>(
-            std::string("stub"),
-            geometry::Rectangle{{},{}},
-            [](){},
-            false,
-            std::make_shared<StubBufferStream>(),
-            std::shared_ptr<input::InputChannel>(),
-            mir::report::null_scene_report()))
-    {
-    }
-
-    std::weak_ptr<scene::BasicSurface> create_surface(shell::SurfaceCreationParameters const&)
-    {
-        return dummy_surface;
-    }
-
-    void destroy_surface(std::weak_ptr<scene::BasicSurface> const& )
-    {
-    }
-
-private:
-    std::shared_ptr<scene::BasicSurface> dummy_surface;
-};
-}
-}
-}
-
-
-#endif /* MIR_TEST_DOUBLES_STUB_SURFACE_BUILDER_H_ */

=== removed file 'include/test/mir_test_doubles/stub_surface_ranker.h'
--- include/test/mir_test_doubles/stub_surface_ranker.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_doubles/stub_surface_ranker.h	1970-01-01 00:00:00 +0000
@@ -1,44 +0,0 @@
-/*
- * Copyright © 2013 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Robert Carr <[e-mail]>
- */
-
-
-#ifndef MIR_TEST_DOUBLES_STUB_SURFACE_RANKER_H_
-#define MIR_TEST_DOUBLES_STUB_SURFACE_RANKER_H_
-
-#include "src/server/scene/surface_ranker.h"
-
-namespace mir
-{
-namespace test
-{
-namespace doubles
-{
-
-struct StubSurfaceRanker : public scene::SurfaceRanker
-{
-    void raise(std::weak_ptr<scene::BasicSurface> const&) override
-    {
-    }
-};
-
-}
-}
-}
-
-
-#endif /* MIR_TEST_DOUBLES_STUB_SURFACE_RANKER_H_ */

=== added file 'include/test/mir_test_framework/declarative_placement_strategy.h'
--- include/test/mir_test_framework/declarative_placement_strategy.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_framework/declarative_placement_strategy.h	2014-04-02 18:58:27 +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 MIR_TEST_FRAMEWORK_DECLARATIVE_PLACEMENT_STRATEGY_H_
+#define MIR_TEST_FRAMEWORK_DECLARATIVE_PLACEMENT_STRATEGY_H_
+
+#include "mir/shell/placement_strategy.h"
+#include "mir/geometry/rectangle.h"
+#include "mir/scene/depth_id.h"
+
+#include <memory>
+#include <map>
+#include <string>
+
+namespace mir_test_framework
+{
+typedef std::map<std::string, mir::geometry::Rectangle> SurfaceGeometries;
+typedef std::map<std::string, mir::scene::DepthId> SurfaceDepths;
+
+/// DeclarativePlacementStrategy is a test utility server component for specifying
+/// a static list of surface geometries and relative depths. Used, for example,
+/// in input tests where it is necessary to set up scenarios depending on
+/// multiple surfaces geometry and stacking.
+class DeclarativePlacementStrategy : public mir::shell::PlacementStrategy
+{
+ public:
+    // Placement requests will be passed through to default strategy, and then overriden if the surface appears
+    // in the geometry or depth map. This allows for the convenience of leaving some surfaces geometries unspecified
+    // and receiving the default behavior.
+    DeclarativePlacementStrategy(std::shared_ptr<mir::shell::PlacementStrategy> const& default_strategy,
+        SurfaceGeometries const& positions_by_name, SurfaceDepths const& depths_by_name);
+
+    virtual ~DeclarativePlacementStrategy() = default;
+    
+    mir::shell::SurfaceCreationParameters place(mir::shell::Session const& session, mir::shell::SurfaceCreationParameters const& request_parameters) override;
+
+protected:
+    DeclarativePlacementStrategy(const DeclarativePlacementStrategy&) = delete;
+    DeclarativePlacementStrategy& operator=(const DeclarativePlacementStrategy&) = delete;
+
+private:
+    std::shared_ptr<mir::shell::PlacementStrategy> const default_strategy;
+
+    SurfaceGeometries surface_geometries_by_name;
+    SurfaceDepths surface_depths_by_name;
+};
+}
+
+#endif // MIR_TEST_FRAMEWORK_DECLARATIVE_PLACEMENT_STRATEGY_H_

=== modified file 'include/test/mir_test_framework/udev_environment.h'
--- include/test/mir_test_framework/udev_environment.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_framework/udev_environment.h	2014-04-02 18:58:27 +0000
@@ -56,6 +56,7 @@
     void add_standard_device(std::string const& name);
 
     UMockdevTestbed *testbed;
+    std::string const recordings_path;
 };
 
 }

=== modified file 'src/client/default_connection_configuration.cpp'
--- src/client/default_connection_configuration.cpp	2014-03-06 06:05:17 +0000
+++ src/client/default_connection_configuration.cpp	2014-04-02 18:58:27 +0000
@@ -103,7 +103,7 @@
         {
             auto const val_raw = getenv("MIR_CLIENT_PLATFORM_LIB");
             std::string const val{val_raw ? val_raw : default_platform_lib};
-            auto const platform_lib = load_library(val);
+            auto const platform_lib = ::load_library(val);
 
             auto const create_client_platform_factory =
                 platform_lib->load_function<mcl::CreateClientPlatformFactory>(

=== modified file 'src/client/lttng/input_receiver_report_tp.h'
--- src/client/lttng/input_receiver_report_tp.h	2014-02-03 11:44:32 +0000
+++ src/client/lttng/input_receiver_report_tp.h	2014-04-02 18:58:27 +0000
@@ -26,6 +26,7 @@
 #define MIR_CLIENT_LTTNG_INPUT_RECEIVER_REPORT_TP_H_
 
 #include <lttng/tracepoint.h>
+#include <stdint.h>
 
 #ifdef __clang__
 /*

=== modified file 'src/client/lttng/rpc_report_tp.h'
--- src/client/lttng/rpc_report_tp.h	2014-03-06 06:05:17 +0000
+++ src/client/lttng/rpc_report_tp.h	2014-04-02 18:58:27 +0000
@@ -26,6 +26,7 @@
 #define MIR_CLIENT_LTTNG_RPC_REPORT_TP_H_
 
 #include <lttng/tracepoint.h>
+#include <stdint.h>
 
 #ifdef __clang__
 /*

=== modified file 'src/client/mir_client_library.cpp'
--- src/client/mir_client_library.cpp	2014-03-06 06:05:17 +0000
+++ src/client/mir_client_library.cpp	2014-04-02 18:58:27 +0000
@@ -120,8 +120,17 @@
 {
     if (!error_connections.contains(connection))
     {
-        auto wait_handle = connection->disconnect();
-        wait_handle->wait_for_all();
+        try
+        {
+            auto wait_handle = connection->disconnect();
+            wait_handle->wait_for_all();
+        }
+        catch (std::exception const&)
+        {
+            // We're implementing a C API so no exceptions are to be
+            // propagated. And that's OK because if disconnect() fails,
+            // we don't care why. We're finished with the connection anyway.
+        }
     }
     else
     {

=== modified file 'src/client/rpc/mir_basic_rpc_channel.cpp'
--- src/client/rpc/mir_basic_rpc_channel.cpp	2014-03-06 06:05:17 +0000
+++ src/client/rpc/mir_basic_rpc_channel.cpp	2014-04-02 18:58:27 +0000
@@ -34,7 +34,7 @@
 }
 
 void mclrd::PendingCallCache::save_completion_details(
-    mir::protobuf::wire::Invocation& invoke,
+    mir::protobuf::wire::Invocation const& invoke,
     google::protobuf::Message* response,
     std::shared_ptr<google::protobuf::Closure> const& complete)
 {
@@ -102,8 +102,8 @@
 
 
 mir::protobuf::wire::Invocation mclr::MirBasicRpcChannel::invocation_for(
-    const google::protobuf::MethodDescriptor* method,
-    const google::protobuf::Message* request)
+    google::protobuf::MethodDescriptor const* method,
+    google::protobuf::Message const* request)
 {
     char buffer[mir::frontend::serialization_buffer_size];
 

=== modified file 'src/client/rpc/mir_basic_rpc_channel.h'
--- src/client/rpc/mir_basic_rpc_channel.h	2014-03-06 06:05:17 +0000
+++ src/client/rpc/mir_basic_rpc_channel.h	2014-04-02 18:58:27 +0000
@@ -55,7 +55,7 @@
     PendingCallCache(std::shared_ptr<RpcReport> const& rpc_report);
 
     void save_completion_details(
-        mir::protobuf::wire::Invocation& invoke,
+        mir::protobuf::wire::Invocation const& invoke,
         google::protobuf::Message* response,
         std::shared_ptr<google::protobuf::Closure> const& complete);
 
@@ -95,8 +95,9 @@
     ~MirBasicRpcChannel();
 
 protected:
-    mir::protobuf::wire::Invocation invocation_for(const google::protobuf::MethodDescriptor* method,
-        const google::protobuf::Message* request);
+    mir::protobuf::wire::Invocation invocation_for(
+        google::protobuf::MethodDescriptor const* method,
+        google::protobuf::Message const* request);
     int next_id();
 
 private:

=== modified file 'src/client/rpc/mir_socket_rpc_channel.cpp'
--- src/client/rpc/mir_socket_rpc_channel.cpp	2014-03-06 06:05:17 +0000
+++ src/client/rpc/mir_socket_rpc_channel.cpp	2014-04-02 18:58:27 +0000
@@ -142,8 +142,39 @@
 {
     if (!disconnected.load())
     {
-        auto surface = dynamic_cast<mir::protobuf::Surface*>(response);
-        mir::protobuf::Screencast* screencast{nullptr};
+        auto const message_type = response->GetTypeName();
+
+        mir::protobuf::Surface* surface = nullptr;
+        mir::protobuf::Buffer* buffer = nullptr;
+        mir::protobuf::Platform* platform = nullptr;
+
+        if (message_type == "mir.protobuf.Buffer")
+        {
+            buffer = static_cast<mir::protobuf::Buffer*>(response);
+        }
+        else if (message_type == "mir.protobuf.Surface")
+        {
+            surface = static_cast<mir::protobuf::Surface*>(response);
+            if (surface && surface->has_buffer())
+                buffer = surface->mutable_buffer();
+        }
+        else if (message_type == "mir.protobuf.Screencast")
+        {
+            auto screencast = static_cast<mir::protobuf::Screencast*>(response);
+            if (screencast && screencast->has_buffer())
+                buffer = screencast->mutable_buffer();
+        }
+        else if (message_type == "mir.protobuf.Platform")
+        {
+            platform = static_cast<mir::protobuf::Platform*>(response);
+        }
+        else if (message_type == "mir.protobuf.Connection")
+        {
+            auto connection = static_cast<mir::protobuf::Connection*>(response);
+            if (connection && connection->has_platform())
+                platform = connection->mutable_platform();
+        }
+
         if (surface)
         {
             surface->clear_fd();
@@ -158,19 +189,6 @@
                 rpc_report->file_descriptors_received(*response, fds);
             }
         }
-        else
-        {
-            screencast = dynamic_cast<mir::protobuf::Screencast*>(response);
-        }
-
-        auto buffer = dynamic_cast<mir::protobuf::Buffer*>(response);
-        if (!buffer)
-        {
-            if (surface && surface->has_buffer())
-                buffer = surface->mutable_buffer();
-            else if (screencast && screencast->has_buffer())
-                buffer = screencast->mutable_buffer();
-        }
 
         if (buffer)
         {
@@ -187,14 +205,6 @@
             }
         }
 
-        auto platform = dynamic_cast<mir::protobuf::Platform*>(response);
-        if (!platform)
-        {
-            auto connection = dynamic_cast<mir::protobuf::Connection*>(response);
-            if (connection && connection->has_platform())
-                platform = connection->mutable_platform();
-        }
-
         if (platform)
         {
             platform->clear_fd();
@@ -266,7 +276,7 @@
     google::protobuf::Message* response,
     google::protobuf::Closure* complete)
 {
-    mir::protobuf::wire::Invocation invocation = invocation_for(method, parameters);
+    auto const& invocation = invocation_for(method, parameters);
 
     rpc_report->invocation_requested(invocation);
 
@@ -345,7 +355,7 @@
     {
         const size_t body_size = read_message_header();
 
-        result = read_message_body(body_size);
+        read_message_body(result, body_size);
 
         rpc_report->result_receipt_succeeded(result);
     }
@@ -431,18 +441,17 @@
     return body_size;
 }
 
-mir::protobuf::wire::Result mclr::MirSocketRpcChannel::read_message_body(const size_t body_size)
+void mclr::MirSocketRpcChannel::read_message_body(
+    mir::protobuf::wire::Result& result,
+    size_t const body_size)
 {
     boost::system::error_code error;
-    boost::asio::streambuf message;
-    boost::asio::read(socket, message, boost::asio::transfer_exactly(body_size), error);
+    body_bytes.resize(body_size);
+    boost::asio::read(socket, boost::asio::buffer(body_bytes), error);
     if (error)
     {
         BOOST_THROW_EXCEPTION(std::runtime_error("Failed to read message body: " + error.message()));
     }
 
-    std::istream in(&message);
-    mir::protobuf::wire::Result result;
-    result.ParseFromIstream(&in);
-    return result;
+    result.ParseFromArray(body_bytes.data(), body_size);
 }

=== modified file 'src/client/rpc/mir_socket_rpc_channel.h'
--- src/client/rpc/mir_socket_rpc_channel.h	2014-03-06 06:05:17 +0000
+++ src/client/rpc/mir_socket_rpc_channel.h	2014-04-02 18:58:27 +0000
@@ -80,6 +80,7 @@
 
     static size_t const size_of_header = 2;
     unsigned char header_bytes[size_of_header];
+    std::vector<char> body_bytes;
 
     void receive_file_descriptors(google::protobuf::Message* response, google::protobuf::Closure* complete);
     void receive_file_descriptors(std::vector<int> &fds);
@@ -92,7 +93,8 @@
 
     size_t read_message_header();
 
-    mir::protobuf::wire::Result read_message_body(const size_t body_size);
+    void read_message_body(mir::protobuf::wire::Result& result,
+                           size_t const body_size);
     void notify_disconnected();
 
     std::shared_ptr<SurfaceMap> surface_map;

=== modified file 'src/platform/CMakeLists.txt'
--- src/platform/CMakeLists.txt	2014-03-06 06:05:17 +0000
+++ src/platform/CMakeLists.txt	2014-04-02 18:58:27 +0000
@@ -3,13 +3,14 @@
 
 add_library(
   mirplatform SHARED
-
+  shared_library_loader.cpp
   udev_wrapper.cpp
 )
 
 target_link_libraries(
   mirplatform
   mirplatformgraphicscommon
+  mirsharedsharedlibrary
 
   ${UDEV_LDFLAGS} ${UDEV_LIBRARIES}
 )

=== modified file 'src/platform/graphics/android/CMakeLists.txt'
--- src/platform/graphics/android/CMakeLists.txt	2014-03-11 13:44:57 +0000
+++ src/platform/graphics/android/CMakeLists.txt	2014-04-02 18:58:27 +0000
@@ -20,6 +20,7 @@
   hwc_layerlist.cpp
   hwc_layers.cpp
   hwc_fb_device.cpp
+  hwc_formatted_logger.cpp
   hwc_device.cpp
   hwc_common_device.cpp
   hwc_vsync.cpp
@@ -44,9 +45,12 @@
 target_link_libraries(
   mirplatformgraphicsandroid
 
+  miroptions
   mirplatform
   mirsharedandroid
+  mirsharedenv
 
+  ${Boost_LIBRARIES}
   ${LIBHARDWARE_LIBRARIES}
   ${EGL_LDFLAGS} ${EGL_LIBRARIES}
   ${GLESv2_LDFLAGS} ${GLESv2_LIBRARIES}

=== modified file 'src/platform/graphics/android/android_display.cpp'
--- src/platform/graphics/android/android_display.cpp	2014-03-17 07:35:22 +0000
+++ src/platform/graphics/android/android_display.cpp	2014-04-02 18:58:27 +0000
@@ -33,9 +33,10 @@
 namespace geom=mir::geometry;
 
 mga::AndroidDisplay::AndroidDisplay(std::shared_ptr<mga::DisplayBuilder> const& display_builder,
+                                    std::shared_ptr<GLConfig> const& gl_config,
                                     std::shared_ptr<DisplayReport> const& display_report)
     : display_builder{display_builder},
-      gl_context{display_builder->display_format(), *display_report},
+      gl_context{display_builder->display_format(), *gl_config, *display_report},
       display_buffer{display_builder->create_display_buffer(gl_context)}
 {
     display_report->report_successful_setup_of_native_resources();

=== modified file 'src/platform/graphics/android/android_display.h'
--- src/platform/graphics/android/android_display.h	2014-03-06 06:05:17 +0000
+++ src/platform/graphics/android/android_display.h	2014-04-02 18:58:27 +0000
@@ -30,6 +30,7 @@
 {
 
 class DisplayReport;
+class GLConfig;
 
 namespace android
 {
@@ -41,6 +42,7 @@
 {
 public:
     explicit AndroidDisplay(std::shared_ptr<DisplayBuilder> const& display_builder,
+                            std::shared_ptr<GLConfig> const& gl_config,
                             std::shared_ptr<DisplayReport> const& display_report);
 
     void for_each_display_buffer(std::function<void(graphics::DisplayBuffer&)> const& f);

=== modified file 'src/platform/graphics/android/android_platform.cpp'
--- src/platform/graphics/android/android_platform.cpp	2014-03-06 06:05:17 +0000
+++ src/platform/graphics/android/android_platform.cpp	2014-04-02 18:58:27 +0000
@@ -31,6 +31,8 @@
 #include "mir/graphics/buffer_ipc_packer.h"
 #include "mir/graphics/display_report.h"
 #include "mir/options/option.h"
+#include "mir/options/configuration.h"
+#include "mir/abnormal_exit.h"
 
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
@@ -40,6 +42,26 @@
 namespace mf=mir::frontend;
 namespace mo = mir::options;
 
+namespace
+{
+char const* const hwc_log_opt = "hwc-report";
+bool should_log_hwc(mo::Option const& options)
+{
+    if (!options.is_set(hwc_log_opt))
+        return false;
+
+    auto opt = options.get<std::string>(hwc_log_opt);
+    if (opt == mo::log_opt_value)
+        return true;
+    else if (opt == mo::off_opt_value)
+        return false;
+    else
+        throw mir::AbnormalExit(
+            std::string("Invalid hwc-report option: " + opt + " (valid options are: \"" +
+            mo::off_opt_value + "\" and \"" + mo::log_opt_value + "\")"));
+}
+}
+
 mga::AndroidPlatform::AndroidPlatform(
     std::shared_ptr<mga::DisplayBuilder> const& display_builder,
     std::shared_ptr<mg::DisplayReport> const& display_report)
@@ -61,9 +83,11 @@
 }
 
 std::shared_ptr<mg::Display> mga::AndroidPlatform::create_display(
-    std::shared_ptr<graphics::DisplayConfigurationPolicy> const&)
+    std::shared_ptr<graphics::DisplayConfigurationPolicy> const&,
+    std::shared_ptr<mg::GLConfig> const& gl_config)
 {
-    return std::make_shared<mga::AndroidDisplay>(display_builder, display_report);
+    return std::make_shared<mga::AndroidDisplay>(
+        display_builder, gl_config, display_report);
 }
 
 std::shared_ptr<mg::PlatformIPCPackage> mga::AndroidPlatform::get_ipc_package()
@@ -105,10 +129,10 @@
     return std::make_shared<mga::InternalClient>();
 }
 
-extern "C" std::shared_ptr<mg::Platform> mg::create_platform(std::shared_ptr<mo::Option> const& /*options*/, std::shared_ptr<DisplayReport> const& display_report)
+extern "C" std::shared_ptr<mg::Platform> mg::create_platform(std::shared_ptr<mo::Option> const& options, std::shared_ptr<DisplayReport> const& display_report)
 {
     auto buffer_initializer = std::make_shared<mg::NullBufferInitializer>();
-    auto display_resource_factory = std::make_shared<mga::ResourceFactory>();
+    auto display_resource_factory = std::make_shared<mga::ResourceFactory>(should_log_hwc(*options));
     auto fb_allocator = std::make_shared<mga::AndroidGraphicBufferAllocator>(buffer_initializer);
     auto display_builder = std::make_shared<mga::OutputBuilder>(
         fb_allocator, display_resource_factory, display_report);
@@ -121,3 +145,12 @@
     //      mg::NativePlatform cannot create a display anyways, so it doesnt need a  display builder
     return std::make_shared<mga::AndroidPlatform>(nullptr, display_report);
 }
+
+extern "C" void add_platform_options(
+    boost::program_options::options_description& config)
+{
+    config.add_options()
+        (hwc_log_opt,
+         boost::program_options::value<std::string>()->default_value(std::string{mo::off_opt_value}),
+         "[platform-specific] How to handle the HWC logging report. [{log,off}]");
+}

=== modified file 'src/platform/graphics/android/android_platform.h'
--- src/platform/graphics/android/android_platform.h	2014-03-06 06:05:17 +0000
+++ src/platform/graphics/android/android_platform.h	2014-04-02 18:58:27 +0000
@@ -44,7 +44,8 @@
     std::shared_ptr<graphics::GraphicBufferAllocator> create_buffer_allocator(
             std::shared_ptr<BufferInitializer> const& buffer_initializer);
     std::shared_ptr<Display> create_display(
-        std::shared_ptr<graphics::DisplayConfigurationPolicy> const&);
+        std::shared_ptr<graphics::DisplayConfigurationPolicy> const&,
+        std::shared_ptr<graphics::GLConfig> const& /*gl_config*/);
     std::shared_ptr<PlatformIPCPackage> get_ipc_package();
     std::shared_ptr<InternalClient> create_internal_client();
     void fill_ipc_package(BufferIPCPacker* packer, graphics::Buffer const* buffer) const;

=== modified file 'src/platform/graphics/android/display_buffer.cpp'
--- src/platform/graphics/android/display_buffer.cpp	2014-03-11 13:44:57 +0000
+++ src/platform/graphics/android/display_buffer.cpp	2014-04-02 18:58:27 +0000
@@ -85,7 +85,7 @@
 }
 
 void mga::DisplayBuffer::render_and_post_update(
-    std::list<std::shared_ptr<Renderable>> const& renderlist,
+    RenderableList const& renderlist,
     std::function<void(Renderable const&)> const& render_fn)
 {
     if (renderlist.empty())

=== modified file 'src/platform/graphics/android/display_buffer.h'
--- src/platform/graphics/android/display_buffer.h	2014-03-11 13:44:57 +0000
+++ src/platform/graphics/android/display_buffer.h	2014-04-02 18:58:27 +0000
@@ -50,7 +50,7 @@
     bool can_bypass() const override;
 
     void render_and_post_update(
-        std::list<std::shared_ptr<Renderable>> const& renderlist,
+        RenderableList const& renderlist,
         std::function<void(Renderable const&)> const& render_fn);
     MirOrientation orientation() const override;
 

=== modified file 'src/platform/graphics/android/display_device.h'
--- src/platform/graphics/android/display_device.h	2014-03-11 13:44:57 +0000
+++ src/platform/graphics/android/display_device.h	2014-04-02 18:58:27 +0000
@@ -44,7 +44,7 @@
     virtual void render_gl(SwappingGLContext const& context) = 0;
     virtual void render_gl_and_overlays(
         SwappingGLContext const& context,
-        std::list<std::shared_ptr<Renderable>> const& list,
+        RenderableList const& list,
         std::function<void(Renderable const&)> const& render_fn) = 0;
     virtual void post(Buffer const& buffer) = 0;
     virtual bool apply_orientation(MirOrientation orientation) const = 0;

=== modified file 'src/platform/graphics/android/fb_device.cpp'
--- src/platform/graphics/android/fb_device.cpp	2014-03-11 13:44:57 +0000
+++ src/platform/graphics/android/fb_device.cpp	2014-04-02 18:58:27 +0000
@@ -51,7 +51,7 @@
 
 void mga::FBDevice::render_gl_and_overlays(
     SwappingGLContext const& context,
-    std::list<std::shared_ptr<Renderable>> const& renderables,
+    RenderableList const& renderables,
     std::function<void(Renderable const&)> const& render_fn) 
 {
     for(auto const& renderable : renderables)

=== modified file 'src/platform/graphics/android/fb_device.h'
--- src/platform/graphics/android/fb_device.h	2014-03-11 13:44:57 +0000
+++ src/platform/graphics/android/fb_device.h	2014-04-02 18:58:27 +0000
@@ -40,7 +40,7 @@
     virtual void render_gl(SwappingGLContext const& context);
     virtual void render_gl_and_overlays(
         SwappingGLContext const& context,
-        std::list<std::shared_ptr<Renderable>> const& list,
+        RenderableList const& list,
         std::function<void(Renderable const&)> const& render_fn);
     void post(Buffer const& buffer);
 

=== modified file 'src/platform/graphics/android/gl_context.cpp'
--- src/platform/graphics/android/gl_context.cpp	2014-03-12 02:46:58 +0000
+++ src/platform/graphics/android/gl_context.cpp	2014-04-02 18:58:27 +0000
@@ -19,6 +19,7 @@
 #include "gl_context.h"
 #include "android_format_conversion-inl.h"
 #include "mir/graphics/display_report.h"
+#include "mir/graphics/gl_config.h"
 
 #include <algorithm>
 #include <boost/throw_exception.hpp>
@@ -31,13 +32,6 @@
 namespace
 {
 
-static EGLint const required_egl_config_attr [] =
-{
-    EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
-    EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
-    EGL_NONE
-};
-
 static EGLint const default_egl_context_attr[] =
 {
     EGL_CONTEXT_CLIENT_VERSION, 2,
@@ -69,8 +63,19 @@
 
 /* the minimum requirement is to have EGL_WINDOW_BIT and EGL_OPENGL_ES2_BIT, and to select a config
    whose pixel format matches that of the framebuffer. */
-static EGLConfig select_egl_config_with_format(EGLDisplay egl_display, MirPixelFormat display_format)
+EGLConfig select_egl_config_with_format(
+    EGLDisplay egl_display, MirPixelFormat display_format,
+    mg::GLConfig const& gl_config)
 {
+    EGLint const required_egl_config_attr [] =
+    {
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+        EGL_DEPTH_SIZE, gl_config.depth_buffer_bits(),
+        EGL_STENCIL_SIZE, gl_config.stencil_buffer_bits(),
+        EGL_NONE
+    };
+
     int required_visual_id = mga::to_android_format(display_format);
     int num_potential_configs;
     EGLint num_match_configs;
@@ -107,10 +112,12 @@
     return eglCreateWindowSurface(disp, config, native, NULL);
 }
 
-mga::GLContext::GLContext(MirPixelFormat display_format, mg::DisplayReport& report)
+mga::GLContext::GLContext(MirPixelFormat display_format,
+                          mg::GLConfig const& gl_config,
+                          mg::DisplayReport& report)
     : egl_display(create_and_initialize_display()),
       own_display(true),
-      egl_config(select_egl_config_with_format(egl_display, display_format)),
+      egl_config(select_egl_config_with_format(egl_display, display_format, gl_config)),
       egl_context{egl_display,
                   eglCreateContext(egl_display, egl_config, EGL_NO_CONTEXT, default_egl_context_attr)},
       egl_surface{egl_display,

=== modified file 'src/platform/graphics/android/gl_context.h'
--- src/platform/graphics/android/gl_context.h	2014-03-12 02:46:58 +0000
+++ src/platform/graphics/android/gl_context.h	2014-04-02 18:58:27 +0000
@@ -29,6 +29,7 @@
 namespace graphics
 {
 class DisplayReport;
+class GLConfig;
 namespace android
 {
 
@@ -53,7 +54,9 @@
 {
 public:
     //For creating a gl context
-    GLContext(MirPixelFormat display_format, DisplayReport& report);
+    GLContext(MirPixelFormat display_format,
+              GLConfig const& gl_config,
+              DisplayReport& report);
 
     //For creating a gl context shared with another GLContext
     GLContext(GLContext const& shared_gl_context,

=== modified file 'src/platform/graphics/android/hwc_common_device.cpp'
--- src/platform/graphics/android/hwc_common_device.cpp	2014-03-11 13:44:57 +0000
+++ src/platform/graphics/android/hwc_common_device.cpp	2014-04-02 18:58:27 +0000
@@ -44,8 +44,8 @@
 
 mga::HWCCommonDevice::HWCCommonDevice(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
                                       std::shared_ptr<mga::HWCVsyncCoordinator> const& coordinator)
-    : hwc_device(hwc_device),
-      coordinator(coordinator),
+    : coordinator(coordinator),
+      hwc_device(hwc_device),
       current_mode(mir_power_mode_on)
 {
     callbacks.hooks.invalidate = invalidate_hook;

=== modified file 'src/platform/graphics/android/hwc_common_device.h'
--- src/platform/graphics/android/hwc_common_device.h	2014-03-06 06:05:17 +0000
+++ src/platform/graphics/android/hwc_common_device.h	2014-04-02 18:58:27 +0000
@@ -54,7 +54,6 @@
     HWCCommonDevice(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
                     std::shared_ptr<HWCVsyncCoordinator> const& coordinator);
 
-    std::shared_ptr<hwc_composer_device_1> const hwc_device;
     std::shared_ptr<HWCVsyncCoordinator> const coordinator;
     std::unique_lock<std::mutex> lock_unblanked();
 
@@ -64,6 +63,8 @@
 
     HWCCallbacks callbacks;
 
+    std::shared_ptr<hwc_composer_device_1> const hwc_device;
+
     std::mutex blanked_mutex;
     std::condition_variable blanked_cond;
     MirPowerMode current_mode;

=== modified file 'src/platform/graphics/android/hwc_device.cpp'
--- src/platform/graphics/android/hwc_device.cpp	2014-03-11 13:44:57 +0000
+++ src/platform/graphics/android/hwc_device.cpp	2014-04-02 18:58:27 +0000
@@ -21,6 +21,7 @@
 #include "hwc_device.h"
 #include "hwc_layerlist.h"
 #include "hwc_vsync_coordinator.h"
+#include "hwc_wrapper.h"
 #include "framebuffer_bundle.h"
 #include "buffer.h"
 #include "mir/graphics/buffer.h"
@@ -89,7 +90,7 @@
 
 void mga::HwcDevice::render_gl_and_overlays(
     SwappingGLContext const& context,
-    std::list<std::shared_ptr<Renderable>> const& renderables,
+    RenderableList const& renderables,
     std::function<void(Renderable const&)> const& render_fn)
 {
     if (!(list_needs_commit = hwc_list.update_list_and_check_if_changed(renderables, fbtarget_size)))

=== modified file 'src/platform/graphics/android/hwc_device.h'
--- src/platform/graphics/android/hwc_device.h	2014-03-11 13:44:57 +0000
+++ src/platform/graphics/android/hwc_device.h	2014-04-02 18:58:27 +0000
@@ -35,20 +35,7 @@
 {
 class HWCVsyncCoordinator;
 class SyncFileOps;
-
-class HwcWrapper
-{
-public:
-    virtual ~HwcWrapper() = default;
-
-    virtual void prepare(hwc_display_contents_1_t&) const = 0;
-    virtual void set(hwc_display_contents_1_t&) const = 0;
-
-protected:
-    HwcWrapper() = default;
-    HwcWrapper& operator=(HwcWrapper const&) = delete;
-    HwcWrapper(HwcWrapper const&) = delete;
-};
+class HwcWrapper;
 
 class HwcDevice : public HWCCommonDevice
 {
@@ -63,7 +50,7 @@
     virtual void render_gl(SwappingGLContext const& context);
     virtual void render_gl_and_overlays(
         SwappingGLContext const& context,
-        std::list<std::shared_ptr<Renderable>> const& list,
+        RenderableList const& list,
         std::function<void(Renderable const&)> const& render_fn);
     void post(Buffer const& buffer);
 

=== modified file 'src/platform/graphics/android/hwc_fb_device.cpp'
--- src/platform/graphics/android/hwc_fb_device.cpp	2014-03-11 13:44:57 +0000
+++ src/platform/graphics/android/hwc_fb_device.cpp	2014-04-02 18:58:27 +0000
@@ -21,6 +21,7 @@
 #include "hwc_vsync_coordinator.h"
 #include "framebuffer_bundle.h"
 #include "android_format_conversion-inl.h"
+#include "hwc_wrapper.h"
 #include "mir/graphics/buffer.h"
 #include "mir/graphics/android/native_buffer.h"
 
@@ -33,9 +34,11 @@
 namespace geom = mir::geometry;
 
 mga::HwcFbDevice::HwcFbDevice(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
+                              std::shared_ptr<HwcWrapper> const& hwc_wrapper,
                               std::shared_ptr<framebuffer_device_t> const& fb_device,
                               std::shared_ptr<HWCVsyncCoordinator> const& coordinator)
     : HWCCommonDevice(hwc_device, coordinator),
+      hwc_wrapper(hwc_wrapper), 
       fb_device(fb_device),
       layer_list{{},1}
 {
@@ -44,41 +47,33 @@
 
 void mga::HwcFbDevice::gpu_render()
 {
-    auto rc = 0; 
-    auto display_list = layer_list.native_list().lock();
-    if (display_list)
+    if (auto display_list = layer_list.native_list().lock())
     {
         display_list->dpy = eglGetCurrentDisplay();
         display_list->sur = eglGetCurrentSurface(EGL_DRAW);
 
         //set() may affect EGL state by calling eglSwapBuffers.
         //HWC 1.0 is the only version of HWC that can do this.
-        hwc_display_contents_1_t* displays[num_displays] {display_list.get()};
-        rc = hwc_device->set(hwc_device.get(), num_displays, displays);
+        hwc_wrapper->set(*display_list);
     }
-
-    if ((rc != 0) || (!display_list))
+    else
     {
         std::stringstream ss;
-        ss << "error during hwc set(). rc = " << std::hex << rc;
+        ss << "error locking list during hwc set()";
         BOOST_THROW_EXCEPTION(std::runtime_error(ss.str()));
     }
 }
 
 void mga::HwcFbDevice::prepare()
 {
-    auto rc = 0;
-    auto display_list = layer_list.native_list().lock();
-    if (display_list)
+    if (auto display_list = layer_list.native_list().lock())
     {
-        hwc_display_contents_1_t* displays[num_displays] {display_list.get()};
-        rc = hwc_device->prepare(hwc_device.get(), num_displays, displays);
+        hwc_wrapper->prepare(*display_list);
     }
-
-    if ((rc != 0) || (!display_list))
+    else
     {
         std::stringstream ss;
-        ss << "error during hwc prepare(). rc = " << std::hex << rc;
+        ss << "error accessing list during hwc prepare()";
         BOOST_THROW_EXCEPTION(std::runtime_error(ss.str()));
     }
 }
@@ -91,7 +86,7 @@
 
 void mga::HwcFbDevice::render_gl_and_overlays(
     SwappingGLContext const&,
-    std::list<std::shared_ptr<Renderable>> const& renderables,
+    RenderableList const& renderables,
     std::function<void(Renderable const&)> const& render_fn)
 {
     prepare();

=== modified file 'src/platform/graphics/android/hwc_fb_device.h'
--- src/platform/graphics/android/hwc_fb_device.h	2014-03-11 13:44:57 +0000
+++ src/platform/graphics/android/hwc_fb_device.h	2014-04-02 18:58:27 +0000
@@ -30,24 +30,28 @@
 {
 namespace android
 {
+class HwcWrapper;
 
 class HwcFbDevice : public HWCCommonDevice
 {
 public:
     HwcFbDevice(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
+                std::shared_ptr<HwcWrapper> const& hwc_wrapper,
                 std::shared_ptr<framebuffer_device_t> const& fb_device,
                 std::shared_ptr<HWCVsyncCoordinator> const& coordinator);
 
     virtual void render_gl(SwappingGLContext const& context);
     virtual void render_gl_and_overlays(
         SwappingGLContext const& context,
-        std::list<std::shared_ptr<Renderable>> const& list,
+        RenderableList const& list,
         std::function<void(Renderable const&)> const& render_fn);
     void post(Buffer const& buffer);
 
 private:
     void prepare();
     void gpu_render();
+
+    std::shared_ptr<HwcWrapper> const hwc_wrapper;
     std::shared_ptr<framebuffer_device_t> const fb_device;
     static int const num_displays{1};
     LayerList layer_list;

=== added file 'src/platform/graphics/android/hwc_formatted_logger.cpp'
--- src/platform/graphics/android/hwc_formatted_logger.cpp	1970-01-01 00:00:00 +0000
+++ src/platform/graphics/android/hwc_formatted_logger.cpp	2014-04-02 18:58:27 +0000
@@ -0,0 +1,177 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "hwc_formatted_logger.h"
+#include <iostream>
+#include <iomanip>
+
+namespace mga=mir::graphics::android;
+
+namespace
+{
+std::string const separator{" | "};
+int const layer_num_column_size{2};
+int const blending_column_size{8};
+int const rotation_column_size{9};
+int const rect_entry_column_size{4};
+int const type_column_size{9};
+
+class StreamFormatter
+{
+public:
+    StreamFormatter(std::ostream& str, unsigned int const width, std::ios_base::fmtflags flags)
+    : stream(str),
+      old_width(stream.width(width)),
+      old_flags(stream.setf(flags,std::ios::adjustfield))
+    {
+    }
+
+   ~StreamFormatter()
+    {
+        stream.setf(old_flags, std::ios::adjustfield);
+        stream.width(old_width);
+    }
+private:
+    std::ostream& stream;
+    unsigned int const old_width;
+    std::ios_base::fmtflags const old_flags;
+};
+
+struct LayerNumber{ unsigned int const num; };
+std::ostream& operator<<(std::ostream& str, LayerNumber l)
+{
+    StreamFormatter stream_format(str, layer_num_column_size, std::ios_base::right);
+    return str << l.num % 100;
+}
+
+struct HwcRotation{ unsigned int const key; };
+std::ostream& operator<<(std::ostream& str, HwcRotation rotation_key)
+{
+    StreamFormatter stream_format(str, rotation_column_size, std::ios_base::left);
+    switch(rotation_key.key)
+    {
+        case 0:
+            return str << std::string{"NONE"};
+        case HWC_TRANSFORM_ROT_90:
+            return str << std::string{"ROT_90"}; 
+        case HWC_TRANSFORM_ROT_180:
+            return str << std::string{"ROT_180"}; 
+        case HWC_TRANSFORM_ROT_270:
+            return str << std::string{"ROT_270"};
+        default:
+            return str << std::string{"UNKNOWN"};
+    }
+}
+
+struct HwcBlending{ int const key; };
+std::ostream& operator<<(std::ostream& str, HwcBlending blending_key)
+{
+    StreamFormatter stream_format(str, blending_column_size, std::ios_base::left);
+    switch(blending_key.key)
+    {
+        case HWC_BLENDING_NONE:
+            return str << std::string{"NONE"};
+        case HWC_BLENDING_PREMULT:
+            return str << std::string{"PREMULT"};
+        case HWC_BLENDING_COVERAGE:
+            return str << std::string{"COVERAGE"};
+        default:
+            return str << std::string{"UNKNOWN"};
+    }
+}
+
+struct HwcType{ int const type; unsigned int const flags; };
+std::ostream& operator<<(std::ostream& str, HwcType type)
+{
+    StreamFormatter stream_format(str, type_column_size, std::ios_base::left);
+    switch(type.type)
+    {
+        case HWC_OVERLAY:
+            return str << std::string{"OVERLAY"};
+        case HWC_FRAMEBUFFER:
+            if (type.flags == HWC_SKIP_LAYER)
+                return str << std::string{"FORCE_GL"};
+            else
+                return str << std::string{"GL_RENDER"};
+        case HWC_FRAMEBUFFER_TARGET:
+            return str << std::string{"FB_TARGET"};
+        default:
+            return str << std::string{"UNKNOWN"};
+    }
+}
+
+struct HwcRectMember { int member; };
+std::ostream& operator<<(std::ostream& str, HwcRectMember rect) 
+{
+    StreamFormatter stream_format(str, rect_entry_column_size, std::ios_base::right);
+    return str << rect.member; 
+}
+
+struct HwcRect { hwc_rect_t const& rect; };
+std::ostream& operator<<(std::ostream& str, HwcRect r)
+{
+    return str << "{"
+               << HwcRectMember{r.rect.left} << ","
+               << HwcRectMember{r.rect.top} << ","
+               << HwcRectMember{r.rect.right} << ","
+               << HwcRectMember{r.rect.bottom} << "}";
+}
+}
+
+void mga::HwcFormattedLogger::log_list_submitted_to_prepare(hwc_display_contents_1_t const& list) const
+{
+    std::cout << "before prepare():" << std::endl
+              << " # | pos {l,t,r,b}         | crop {l,t,r,b}        | transform | blending | "
+              << std::endl;
+    for(auto i = 0u; i < list.numHwLayers; i++)
+        std::cout << LayerNumber{i}
+                  << separator
+                  << HwcRect{list.hwLayers[i].displayFrame}
+                  << separator
+                  << HwcRect{list.hwLayers[i].sourceCrop}
+                  << separator
+                  << HwcRotation{list.hwLayers[i].transform}
+                  << separator
+                  << HwcBlending{list.hwLayers[i].blending}
+                  << separator
+                  << std::endl;
+}
+
+void mga::HwcFormattedLogger::log_prepare_done(hwc_display_contents_1_t const& list) const
+{
+    std::cout << "after prepare():" << std::endl
+              << " # | Type      | " << std::endl;
+    for(auto i = 0u; i < list.numHwLayers; i++)
+        std::cout << LayerNumber{i}
+                  << separator
+                  << HwcType{list.hwLayers[i].compositionType,list.hwLayers[i].flags}
+                  << separator
+                  << std::endl;
+}
+
+void mga::HwcFormattedLogger::log_set_list(hwc_display_contents_1_t const& list) const
+{
+    std::cout << "set list():" << std::endl
+              << " # | handle" << std::endl;
+
+    for(auto i = 0u; i < list.numHwLayers; i++)
+        std::cout << LayerNumber{i}
+                  << separator
+                  << list.hwLayers[i].handle
+                  << std::endl;
+}

=== added file 'src/platform/graphics/android/hwc_formatted_logger.h'
--- src/platform/graphics/android/hwc_formatted_logger.h	1970-01-01 00:00:00 +0000
+++ src/platform/graphics/android/hwc_formatted_logger.h	2014-04-02 18:58:27 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_ANDROID_HWC_FORMATTED_LOGGER_H_
+#define MIR_GRAPHICS_ANDROID_HWC_FORMATTED_LOGGER_H_
+
+#include "hwc_logger.h"
+
+namespace mir
+{
+namespace graphics
+{
+namespace android
+{
+class HwcFormattedLogger : public HwcLogger
+{
+public:
+    HwcFormattedLogger() = default;
+    void log_list_submitted_to_prepare(hwc_display_contents_1_t const& list) const override;
+    void log_prepare_done(hwc_display_contents_1_t const& list) const override;
+    void log_set_list(hwc_display_contents_1_t const& list) const override;
+};
+}
+}
+}
+#endif /* MIR_GRAPHICS_ANDROID_HWC_FORMATTED_LOGGER_H_ */

=== modified file 'src/platform/graphics/android/hwc_layerlist.cpp'
--- src/platform/graphics/android/hwc_layerlist.cpp	2014-03-17 07:35:22 +0000
+++ src/platform/graphics/android/hwc_layerlist.cpp	2014-04-02 18:58:27 +0000
@@ -52,7 +52,7 @@
 }
 
 bool mga::LayerList::update_list_and_check_if_changed(
-    std::list<std::shared_ptr<mg::Renderable>> const& renderlist,
+    RenderableList const& renderlist,
     size_t additional_layers)
 {
     size_t needed_size = renderlist.size() + additional_layers; 
@@ -70,7 +70,7 @@
         {
             layers_it->set_render_parameters(
                 renderable->screen_position(), renderable->alpha_enabled());
-            layers_it->set_buffer(*renderable->buffer(1));// TODO: remove needing to know about frameno
+            layers_it->set_buffer(*renderable->buffer(this));
             any_buffer_updated |= layers_it->needs_hwc_commit(); 
             layers_it++;
         }
@@ -88,7 +88,7 @@
                     renderable->screen_position(),
                     renderable->alpha_enabled(),
                     hwc_representation, i++));
-            new_layers.back().set_buffer(*renderable->buffer(1));// TODO: remove needing to know about frameno
+            new_layers.back().set_buffer(*renderable->buffer(this));
         }
 
         for(; i < needed_size; i++)
@@ -137,7 +137,7 @@
 }
 
 mga::LayerList::LayerList(
-    std::list<std::shared_ptr<mg::Renderable>> const& renderlist,
+    RenderableList const& renderlist,
     size_t additional_layers)
 {
     update_list_and_check_if_changed(renderlist, additional_layers);

=== modified file 'src/platform/graphics/android/hwc_layerlist.h'
--- src/platform/graphics/android/hwc_layerlist.h	2014-03-11 13:44:57 +0000
+++ src/platform/graphics/android/hwc_layerlist.h	2014-04-02 18:58:27 +0000
@@ -48,9 +48,9 @@
 class LayerList
 {
 public:
-    LayerList(std::list<std::shared_ptr<Renderable>> const& renderlist, size_t additional_layers);
+    LayerList(RenderableList const& renderlist, size_t additional_layers);
     bool update_list_and_check_if_changed(
-        std::list<std::shared_ptr<Renderable>> const& renderlist,
+        RenderableList const& renderlist,
         size_t additional_layers);
 
     std::list<HWCLayer>::iterator begin();

=== added file 'src/platform/graphics/android/hwc_logger.h'
--- src/platform/graphics/android/hwc_logger.h	1970-01-01 00:00:00 +0000
+++ src/platform/graphics/android/hwc_logger.h	2014-04-02 18:58:27 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_ANDROID_HWC_LOGGER_H_
+#define MIR_GRAPHICS_ANDROID_HWC_LOGGER_H_
+
+#include <hardware/hwcomposer.h>
+
+namespace mir
+{
+namespace graphics
+{
+namespace android
+{
+class HwcLogger
+{
+public:
+    virtual ~HwcLogger() = default;
+
+    virtual void log_list_submitted_to_prepare(hwc_display_contents_1_t const& list) const = 0;
+    virtual void log_prepare_done(hwc_display_contents_1_t const& list) const = 0;
+    virtual void log_set_list(hwc_display_contents_1_t const& list) const = 0;
+protected:
+    HwcLogger() = default;
+    HwcLogger& operator=(HwcLogger const&) = delete;
+    HwcLogger(HwcLogger const&) = delete;
+};
+}
+}
+}
+#endif /* MIR_GRAPHICS_ANDROID_HWC_LOGGER_H_ */

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

=== modified file 'src/platform/graphics/android/real_hwc_wrapper.cpp'
--- src/platform/graphics/android/real_hwc_wrapper.cpp	2014-02-26 22:22:15 +0000
+++ src/platform/graphics/android/real_hwc_wrapper.cpp	2014-04-02 18:58:27 +0000
@@ -17,14 +17,18 @@
  */
 
 #include "real_hwc_wrapper.h"
+#include "hwc_logger.h"
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
 #include <sstream>
 
 namespace mga=mir::graphics::android;
 
-mga::RealHwcWrapper::RealHwcWrapper(std::shared_ptr<hwc_composer_device_1> const& hwc_device)
-    : hwc_device(hwc_device)
+mga::RealHwcWrapper::RealHwcWrapper(
+    std::shared_ptr<hwc_composer_device_1> const& hwc_device,
+    std::shared_ptr<mga::HwcLogger> const& logger)
+    : hwc_device(hwc_device),
+      logger(logger)
 {
 }
 
@@ -33,17 +37,22 @@
     //note, although we only have a primary display right now,
     //      set the external and virtual displays to null as some drivers check for that
     hwc_display_contents_1_t* displays[num_displays] {&display_list, nullptr, nullptr};
+
+    logger->log_list_submitted_to_prepare(display_list);
     if (auto rc = hwc_device->prepare(hwc_device.get(), 1, displays))
     {
         std::stringstream ss;
         ss << "error during hwc prepare(). rc = " << std::hex << rc;
         BOOST_THROW_EXCEPTION(std::runtime_error(ss.str()));
     }
+    logger->log_prepare_done(display_list);
 }
 
 void mga::RealHwcWrapper::set(hwc_display_contents_1_t& display_list) const
 {
     hwc_display_contents_1_t* displays[num_displays] {&display_list, nullptr, nullptr};
+
+    logger->log_set_list(display_list);
     if (auto rc = hwc_device->set(hwc_device.get(), 1, displays))
     {
         std::stringstream ss;

=== modified file 'src/platform/graphics/android/real_hwc_wrapper.h'
--- src/platform/graphics/android/real_hwc_wrapper.h	2014-02-20 22:20:34 +0000
+++ src/platform/graphics/android/real_hwc_wrapper.h	2014-04-02 18:58:27 +0000
@@ -19,7 +19,7 @@
 #ifndef MIR_GRAPHICS_ANDROID_REAL_HWC_WRAPPER_H_
 #define MIR_GRAPHICS_ANDROID_REAL_HWC_WRAPPER_H_
 
-#include "hwc_device.h"
+#include "hwc_wrapper.h"
 #include <memory>
 #include <hardware/hwcomposer.h>
 
@@ -29,17 +29,20 @@
 {
 namespace android
 {
-
+class HwcLogger;
 class RealHwcWrapper : public HwcWrapper
 {
 public:
-    RealHwcWrapper(std::shared_ptr<hwc_composer_device_1> const& hwc_device);
+    RealHwcWrapper(
+        std::shared_ptr<hwc_composer_device_1> const& hwc_device,
+        std::shared_ptr<HwcLogger> const& logger);
 
     void prepare(hwc_display_contents_1_t&) const override;
     void set(hwc_display_contents_1_t&) const override;
 private:
     static size_t const num_displays{3}; //primary, external, virtual
     std::shared_ptr<hwc_composer_device_1> const hwc_device;
+    std::shared_ptr<HwcLogger> const logger;
 };
 
 }

=== modified file 'src/platform/graphics/android/resource_factory.cpp'
--- src/platform/graphics/android/resource_factory.cpp	2014-03-11 13:44:57 +0000
+++ src/platform/graphics/android/resource_factory.cpp	2014-04-02 18:58:27 +0000
@@ -31,6 +31,7 @@
 #include "hwc_vsync.h"
 #include "android_display.h"
 #include "real_hwc_wrapper.h"
+#include "hwc_formatted_logger.h"
 
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
@@ -39,6 +40,11 @@
 namespace mg = mir::graphics;
 namespace mga=mir::graphics::android;
 
+mga::ResourceFactory::ResourceFactory(bool should_log_hwc)
+    : should_log_hwc{should_log_hwc}
+{
+}
+
 std::shared_ptr<framebuffer_device_t> mga::ResourceFactory::create_fb_native_device() const
 {
     hw_module_t const* module;
@@ -89,12 +95,37 @@
     return std::make_shared<mga::FBDevice>(fb_native_device);
 }
 
+namespace
+{
+struct NullHwcLogger : public mga::HwcLogger
+{
+    void log_list_submitted_to_prepare(hwc_display_contents_1_t const&) const override
+    {
+    }
+    void log_prepare_done(hwc_display_contents_1_t const&) const override
+    {
+    }
+    void log_set_list(hwc_display_contents_1_t const&) const override
+    {
+    }
+};
+
+std::shared_ptr<mga::HwcLogger> make_logger(bool should_log)
+{
+    if (should_log)
+        return std::make_shared<mga::HwcFormattedLogger>();
+    else
+        return std::make_shared<NullHwcLogger>();
+}
+
+}
+
 std::shared_ptr<mga::DisplayDevice> mga::ResourceFactory::create_hwc_device(
     std::shared_ptr<hwc_composer_device_1> const& hwc_native_device) const
 {
     auto syncer = std::make_shared<mga::HWCVsync>();
     auto file_ops = std::make_shared<mga::RealSyncFileOps>();
-    auto wrapper = std::make_shared<mga::RealHwcWrapper>(hwc_native_device); 
+    auto wrapper = std::make_shared<mga::RealHwcWrapper>(hwc_native_device, make_logger(should_log_hwc));
     return std::make_shared<mga::HwcDevice>(hwc_native_device, wrapper, syncer, file_ops);
 }
 
@@ -103,5 +134,7 @@
     std::shared_ptr<framebuffer_device_t> const& fb_native_device) const
 {
     auto syncer = std::make_shared<mga::HWCVsync>();
-    return std::make_shared<mga::HwcFbDevice>(hwc_native_device, fb_native_device, syncer);
+    auto logger = std::make_shared<NullHwcLogger>();
+    auto wrapper = std::make_shared<mga::RealHwcWrapper>(hwc_native_device, make_logger(should_log_hwc));
+    return std::make_shared<mga::HwcFbDevice>(hwc_native_device, wrapper, fb_native_device, syncer);
 }

=== modified file 'src/platform/graphics/android/resource_factory.h'
--- src/platform/graphics/android/resource_factory.h	2014-03-06 06:05:17 +0000
+++ src/platform/graphics/android/resource_factory.h	2014-04-02 18:58:27 +0000
@@ -31,6 +31,8 @@
 class ResourceFactory : public DisplayResourceFactory
 {
 public:
+    ResourceFactory(bool should_log_hwc);
+
     //native allocations
     std::shared_ptr<hwc_composer_device_1> create_hwc_native_device() const;
     std::shared_ptr<framebuffer_device_t> create_fb_native_device() const;
@@ -46,6 +48,8 @@
 
     std::shared_ptr<ANativeWindow> create_native_window(
         std::shared_ptr<FramebufferBundle> const& fb_bundle) const;
+private:
+    bool const should_log_hwc;
 };
 
 }

=== modified file 'src/platform/graphics/mesa/display.cpp'
--- src/platform/graphics/mesa/display.cpp	2014-03-17 07:35:22 +0000
+++ src/platform/graphics/mesa/display.cpp	2014-04-02 18:58:27 +0000
@@ -54,7 +54,10 @@
 class GBMGLContext : public mg::GLContext
 {
 public:
-    GBMGLContext(mgm::helpers::GBMHelper const& gbm, EGLContext shared_context)
+    GBMGLContext(mgm::helpers::GBMHelper const& gbm,
+                 mg::GLConfig const& gl_config,
+                 EGLContext shared_context)
+        : egl{gl_config}
     {
         egl.setup(gbm, shared_context);
     }
@@ -77,13 +80,16 @@
 
 mgm::Display::Display(std::shared_ptr<Platform> const& platform,
                       std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy,
+                      std::shared_ptr<GLConfig> const& gl_config,
                       std::shared_ptr<DisplayReport> const& listener)
     : platform(platform),
       listener(listener),
       monitor(mir::udev::Context()),
+      shared_egl{*gl_config},
       output_container{platform->drm.fd,
                        std::make_shared<KMSPageFlipper>(platform->drm.fd)},
-      current_display_configuration{platform->drm.fd}
+      current_display_configuration{platform->drm.fd},
+      gl_config{gl_config}
 {
     platform->vt->set_graphics_mode();
 
@@ -203,6 +209,7 @@
                                   std::move(surface),
                                   bounding_rect,
                                   orientation,
+                                  *gl_config,
                                   shared_egl.context()}};
 
             display_buffers_new.push_back(std::move(db));
@@ -320,7 +327,10 @@
 std::unique_ptr<mg::GLContext> mgm::Display::create_gl_context()
 {
     return std::unique_ptr<GBMGLContext>{
-        new GBMGLContext{platform->gbm, shared_egl.context()}};
+        new GBMGLContext{
+            platform->gbm,
+            *gl_config,
+            shared_egl.context()}};
 }
 
 void mgm::Display::clear_connected_unused_outputs()

=== modified file 'src/platform/graphics/mesa/display.h'
--- src/platform/graphics/mesa/display.h	2014-03-06 06:05:17 +0000
+++ src/platform/graphics/mesa/display.h	2014-04-02 18:58:27 +0000
@@ -41,6 +41,7 @@
 class DisplayBuffer;
 class DisplayConfigurationPolicy;
 class EventHandlerRegister;
+class GLConfig;
 
 namespace mesa
 {
@@ -54,8 +55,9 @@
 {
 public:
     Display(std::shared_ptr<Platform> const& platform,
-               std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy,
-               std::shared_ptr<DisplayReport> const& listener);
+            std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy,
+            std::shared_ptr<GLConfig> const& gl_config,
+            std::shared_ptr<DisplayReport> const& listener);
     ~Display();
 
     geometry::Rectangle view_area() const;
@@ -92,6 +94,7 @@
     RealKMSOutputContainer output_container;
     mutable RealKMSDisplayConfiguration current_display_configuration;
     std::shared_ptr<Cursor> cursor;
+    std::shared_ptr<GLConfig> const gl_config;
 };
 
 }

=== modified file 'src/platform/graphics/mesa/display_buffer.cpp'
--- src/platform/graphics/mesa/display_buffer.cpp	2014-03-06 06:05:17 +0000
+++ src/platform/graphics/mesa/display_buffer.cpp	2014-04-02 18:58:27 +0000
@@ -101,6 +101,7 @@
     GBMSurfaceUPtr surface_gbm_param,
     geom::Rectangle const& area,
     MirOrientation rot,
+    GLConfig const& gl_config,
     EGLContext shared_context)
     : last_flipped_bufobj{nullptr},
       scheduled_bufobj{nullptr},
@@ -109,6 +110,7 @@
       drm(platform->drm),
       outputs(outputs),
       surface_gbm{std::move(surface_gbm_param)},
+      egl{gl_config},
       area(area),
       rotation(rot),
       needs_set_crtc{false},
@@ -196,7 +198,7 @@
 }
 
 void mgm::DisplayBuffer::render_and_post_update(
-    std::list<std::shared_ptr<Renderable>> const&,
+    RenderableList const&,
     std::function<void(Renderable const&)> const&)
 {
     post_update(nullptr); 

=== modified file 'src/platform/graphics/mesa/display_buffer.h'
--- src/platform/graphics/mesa/display_buffer.h	2014-03-06 06:05:17 +0000
+++ src/platform/graphics/mesa/display_buffer.h	2014-04-02 18:58:27 +0000
@@ -32,6 +32,7 @@
 {
 
 class DisplayReport;
+class GLConfig;
 
 namespace mesa
 {
@@ -49,6 +50,7 @@
                   GBMSurfaceUPtr surface_gbm,
                   geometry::Rectangle const& area,
                   MirOrientation rot,
+                  GLConfig const& gl_config,
                   EGLContext shared_context);
     ~DisplayBuffer();
 
@@ -59,7 +61,7 @@
 
     bool can_bypass() const override;
     void post_update(std::shared_ptr<graphics::Buffer> bypass_buf) override;
-    void render_and_post_update(std::list<std::shared_ptr<Renderable>> const& renderlist,
+    void render_and_post_update(RenderableList const& renderlist,
                                 std::function<void(Renderable const&)> const& render_fn);
     MirOrientation orientation() const override;
     void schedule_set_crtc();

=== modified file 'src/platform/graphics/mesa/display_helpers.cpp'
--- src/platform/graphics/mesa/display_helpers.cpp	2014-03-12 02:46:58 +0000
+++ src/platform/graphics/mesa/display_helpers.cpp	2014-04-02 18:58:27 +0000
@@ -19,6 +19,7 @@
 #include "display_helpers.h"
 #include "drm_close_threadsafe.h"
 
+#include "mir/graphics/gl_config.h"
 #include "mir/udev/wrapper.h"
 
 #include <boost/exception/errinfo_errno.hpp>
@@ -219,7 +220,7 @@
         sv.drm_dd_major = -1;     /* Don't care */
         sv.drm_dd_minor = -1;     /* Don't care */
 
-        if ((error = drmSetInterfaceVersion(tmp_fd, &sv)))
+        if ((error = -drmSetInterfaceVersion(tmp_fd, &sv)))
         {
             close(tmp_fd);
             tmp_fd = -1;
@@ -238,7 +239,7 @@
     {
         BOOST_THROW_EXCEPTION(
             boost::enable_error_info(
-                std::runtime_error("Error opening DRM device")) << boost::errinfo_errno(-error));
+                std::runtime_error("Error opening DRM device")) << boost::errinfo_errno(error));
     }
 
     return tmp_fd;
@@ -295,6 +296,15 @@
  * EGLHelper *
  *************/
 
+mgmh::EGLHelper::EGLHelper(GLConfig const& gl_config)
+    : depth_buffer_bits{gl_config.depth_buffer_bits()},
+      stencil_buffer_bits{gl_config.stencil_buffer_bits()},
+      egl_display{EGL_NO_DISPLAY}, egl_config{0},
+      egl_context{EGL_NO_CONTEXT}, egl_surface{EGL_NO_SURFACE},
+      should_terminate_egl{false}
+{
+}
+
 void mgmh::EGLHelper::setup(GBMHelper const& gbm)
 {
     static const EGLint context_attr[] = {
@@ -378,12 +388,14 @@
 
 void mgmh::EGLHelper::setup_internal(GBMHelper const& gbm, bool initialize)
 {
-    static const EGLint config_attr[] = {
+    EGLint const config_attr[] = {
         EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
         EGL_RED_SIZE, 8,
         EGL_GREEN_SIZE, 8,
         EGL_BLUE_SIZE, 8,
         EGL_ALPHA_SIZE, 0,
+        EGL_DEPTH_SIZE, depth_buffer_bits,
+        EGL_STENCIL_SIZE, stencil_buffer_bits,
         EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
         EGL_NONE
     };

=== modified file 'src/platform/graphics/mesa/display_helpers.h'
--- src/platform/graphics/mesa/display_helpers.h	2014-03-12 02:46:58 +0000
+++ src/platform/graphics/mesa/display_helpers.h	2014-04-02 18:58:27 +0000
@@ -37,6 +37,8 @@
 {
 namespace graphics
 {
+class GLConfig;
+
 namespace mesa
 {
 
@@ -92,11 +94,7 @@
 class EGLHelper
 {
 public:
-    EGLHelper()
-        : egl_display{EGL_NO_DISPLAY}, egl_config{0},
-          egl_context{EGL_NO_CONTEXT}, egl_surface{EGL_NO_SURFACE},
-          should_terminate_egl{false} {}
-
+    EGLHelper(GLConfig const& gl_config);
     ~EGLHelper() noexcept;
 
     EGLHelper(const EGLHelper&) = delete;
@@ -117,6 +115,8 @@
 private:
     void setup_internal(GBMHelper const& gbm, bool initialize);
 
+    EGLint const depth_buffer_bits;
+    EGLint const stencil_buffer_bits;
     EGLDisplay egl_display;
     EGLConfig egl_config;
     EGLContext egl_context;

=== modified file 'src/platform/graphics/mesa/platform.cpp'
--- src/platform/graphics/mesa/platform.cpp	2014-03-13 07:47:55 +0000
+++ src/platform/graphics/mesa/platform.cpp	2014-04-02 18:58:27 +0000
@@ -147,11 +147,13 @@
 }
 
 std::shared_ptr<mg::Display> mgm::Platform::create_display(
-    std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy)
+    std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy,
+    std::shared_ptr<GLConfig> const& gl_config)
 {
     return std::make_shared<mgm::Display>(
         this->shared_from_this(),
         initial_conf_policy,
+        gl_config,
         listener);
 }
 
@@ -219,3 +221,11 @@
         return (display == mgm::NativePlatform::internal_native_display().get());
     return 0;
 }
+
+extern "C" void add_platform_options(boost::program_options::options_description& config)
+{
+    config.add_options()
+        ("vt",
+         boost::program_options::value<int>()->default_value(0),
+         "[platform-specific] VT to run on or 0 to use current.");
+}

=== modified file 'src/platform/graphics/mesa/platform.h'
--- src/platform/graphics/mesa/platform.h	2014-03-06 06:05:17 +0000
+++ src/platform/graphics/mesa/platform.h	2014-04-02 18:58:27 +0000
@@ -47,7 +47,8 @@
     std::shared_ptr<graphics::GraphicBufferAllocator> create_buffer_allocator(
             const std::shared_ptr<BufferInitializer>& buffer_initializer);
     std::shared_ptr<graphics::Display> create_display(
-        std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy);
+        std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy,
+        std::shared_ptr<GLConfig> const& gl_config);
     std::shared_ptr<PlatformIPCPackage> get_ipc_package();
     std::shared_ptr<InternalClient> create_internal_client();
 

=== modified file 'src/platform/options/default_configuration.cpp'
--- src/platform/options/default_configuration.cpp	2014-03-17 07:35:22 +0000
+++ src/platform/options/default_configuration.cpp	2014-04-02 18:58:27 +0000
@@ -16,7 +16,10 @@
  * Authored by: Alan Griffiths <[e-mail]>
  */
 
+#include "mir/shared_library.h"
+#include "mir/shared_library_loader.h"
 #include "mir/options/default_configuration.h"
+#include "mir/graphics/platform.h"
 #include "mir/default_configuration.h"
 #include "mir/abnormal_exit.h"
 
@@ -114,9 +117,35 @@
         (name_opt, po::value<std::string>(),
             "When nested, the name Mir uses when registering with the host.")
         (offscreen_opt,
-            "Render to offscreen buffers instead of the real outputs.")
-        ("vt", po::value<int>()->default_value(0), // TODO this not applicable on all graphics platforms
-            "VT to run on or 0 to use current.");
+            "Render to offscreen buffers instead of the real outputs.");
+
+        add_platform_options();
+}
+
+void mo::DefaultConfiguration::add_platform_options()
+{
+    namespace po = boost::program_options;
+    po::options_description program_options;
+    program_options.add_options()
+        (platform_graphics_lib,
+         po::value<std::string>()->default_value(default_platform_graphics_lib), "");
+    mo::ProgramOption options;
+    options.parse_arguments(program_options, argc, argv);
+
+    std::string graphics_libname;
+    auto env_libname = ::getenv("MIR_SERVER_PLATFORM_GRAPHICS_LIB");
+    if (!options.is_set(platform_graphics_lib) && env_libname)
+    {
+        graphics_libname = std::string{env_libname};
+    }
+    else
+    {
+        graphics_libname = options.get<std::string>(platform_graphics_lib);
+    }
+
+    auto graphics_lib = load_library(graphics_libname);
+    auto add_platform_options = graphics_lib->load_function<mir::graphics::AddPlatformOptions>(std::string("add_platform_options"));
+    add_platform_options(*this->program_options);
 }
 
 boost::program_options::options_description_easy_init mo::DefaultConfiguration::add_options()

=== added file 'src/platform/shared_library_loader.cpp'
--- src/platform/shared_library_loader.cpp	1970-01-01 00:00:00 +0000
+++ src/platform/shared_library_loader.cpp	2014-04-02 18:58:27 +0000
@@ -0,0 +1,38 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#include "mir/shared_library_loader.h"
+#include "mir/shared_library.h"
+#include <memory>
+#include <map>
+
+mir::SharedLibrary const* mir::load_library(std::string const& libname)
+{
+    // There's no point in loading twice, and it isn't safe to unload...
+    static std::map<std::string, std::shared_ptr<mir::SharedLibrary>> libraries_cache;
+
+    if (auto& ptr = libraries_cache[libname])
+    {
+        return ptr.get();
+    }
+    else
+    {
+        ptr = std::make_shared<mir::SharedLibrary>(libname);
+        return ptr.get();
+    }
+}

=== modified file 'src/server/CMakeLists.txt'
--- src/server/CMakeLists.txt	2014-03-12 06:41:13 +0000
+++ src/server/CMakeLists.txt	2014-04-02 18:58:27 +0000
@@ -94,7 +94,7 @@
   )
 endif()
 
-set(MIRSERVER_ABI 17)
+set(MIRSERVER_ABI 18)
 
 set_target_properties(
   mirserver

=== modified file 'src/server/compositor/buffer_bundle.h'
--- src/server/compositor/buffer_bundle.h	2014-03-07 03:15:55 +0000
+++ src/server/compositor/buffer_bundle.h	2014-04-02 18:58:27 +0000
@@ -36,8 +36,20 @@
     virtual ~BufferBundle() noexcept {}
     virtual void client_acquire(std::function<void(graphics::Buffer* buffer)> complete) = 0;
     virtual void client_release(graphics::Buffer*) = 0;
+
+    /**
+     * Acquire the next buffer that's ready to display/composite.
+     *
+     * \param [in] user_id A unique identifier of who is going to use the
+     *                     buffer, to ensure that separate users representing
+     *                     separate monitors who need the same frame will get
+     *                     the same buffer. However consecutive calls for the
+     *                     same user will get different buffers. To avoid
+     *                     collisions, all callers should determine user_id
+     *                     in the same way (e.g. always use "this" pointer).
+     */
     virtual std::shared_ptr<graphics::Buffer>
-        compositor_acquire(unsigned long frameno) = 0;
+        compositor_acquire(void const* user_id) = 0;
     virtual void compositor_release(std::shared_ptr<graphics::Buffer> const&) = 0;
     virtual std::shared_ptr<graphics::Buffer> snapshot_acquire() = 0;
     virtual void snapshot_release(std::shared_ptr<graphics::Buffer> const&) = 0;

=== modified file 'src/server/compositor/buffer_stream_surfaces.cpp'
--- src/server/compositor/buffer_stream_surfaces.cpp	2014-03-07 03:15:55 +0000
+++ src/server/compositor/buffer_stream_surfaces.cpp	2014-04-02 18:58:27 +0000
@@ -38,10 +38,10 @@
 }
 
 std::shared_ptr<mg::Buffer> mc::BufferStreamSurfaces::lock_compositor_buffer(
-    unsigned long frameno)
+    void const* user_id)
 {
     return std::make_shared<mc::TemporaryCompositorBuffer>(
-        buffer_bundle, frameno);
+        buffer_bundle, user_id);
 }
 
 std::shared_ptr<mg::Buffer> mc::BufferStreamSurfaces::lock_snapshot_buffer()

=== modified file 'src/server/compositor/buffer_stream_surfaces.h'
--- src/server/compositor/buffer_stream_surfaces.h	2014-03-07 03:15:55 +0000
+++ src/server/compositor/buffer_stream_surfaces.h	2014-04-02 18:58:27 +0000
@@ -42,7 +42,7 @@
     void swap_client_buffers(graphics::Buffer* old_buffer, std::function<void(graphics::Buffer* new_buffer)> complete) override;
 
     std::shared_ptr<graphics::Buffer>
-        lock_compositor_buffer(unsigned long frameno) override;
+        lock_compositor_buffer(void const* user_id) override;
     std::shared_ptr<graphics::Buffer> lock_snapshot_buffer() override;
 
     MirPixelFormat get_stream_pixel_format() override;

=== modified file 'src/server/compositor/bypass.cpp'
--- src/server/compositor/bypass.cpp	2014-03-17 07:35:22 +0000
+++ src/server/compositor/bypass.cpp	2014-04-02 18:58:27 +0000
@@ -44,9 +44,14 @@
 
     auto const& view_area = display_buffer.view_area();
 
+    //TODO: remove this check, why are we getting a non visible renderable 
+    //      in the list of surfaces?
+    if (!renderable.visible())
+        return false; 
+
     // Not weirdly transformed but also not on this monitor? Don't care...
     // This will also check the surface is not hidden and has been posted.
-    if (!renderable.should_be_rendered_in(view_area))
+    if (!view_area.contains(renderable.screen_position()))
         return false;
 
     topmost_fits = false;

=== modified file 'src/server/compositor/default_display_buffer_compositor.cpp'
--- src/server/compositor/default_display_buffer_compositor.cpp	2014-03-17 07:35:22 +0000
+++ src/server/compositor/default_display_buffer_compositor.cpp	2014-04-02 18:58:27 +0000
@@ -29,41 +29,35 @@
 #include "occlusion.h"
 #include <mutex>
 #include <cstdlib>
-#include <vector>
+#include <algorithm>
 
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
 
+//TODO remove VisibilityFilter once we don't need filters/operators for rendering
 namespace
 {
-
-struct FilterForVisibleSceneInRegion : public mc::FilterForScene
+struct VisibilityFilter : public mc::FilterForScene
 {
-    FilterForVisibleSceneInRegion(
-        mir::geometry::Rectangle const& enclosing_region,
-        mc::OcclusionMatch const& occlusions)
-        : enclosing_region(enclosing_region),
-          occlusions(occlusions)
+public:
+    VisibilityFilter(
+        mg::RenderableList const& renderable_list)
+        : list(renderable_list)
     {
     }
+
     bool operator()(mg::Renderable const& r)
     {
-        return r.should_be_rendered_in(enclosing_region) &&
-               !occlusions.occluded(r);
+        auto matcher = [&r](std::shared_ptr<mg::Renderable> const& renderable)
+        {
+            return (renderable.get() == &r);
+        };
+        return (std::find_if(list.begin(), list.end(), matcher) != list.end());
     }
 
-    mir::geometry::Rectangle const& enclosing_region;
-    mc::OcclusionMatch const& occlusions;
+private:
+    mg::RenderableList const& list;
 };
-
-std::mutex global_frameno_lock;
-unsigned long global_frameno = 0;
-
-bool wrapped_greater_or_equal(unsigned long a, unsigned long b)
-{
-    return (a - b) < (~0UL / 2UL);
-}
-
 }
 
 mc::DefaultDisplayBufferCompositor::DefaultDisplayBufferCompositor(
@@ -75,29 +69,14 @@
       scene{scene},
       renderer{renderer},
       report{report},
-      local_frameno{global_frameno}
+      last_pass_rendered_anything{false}
 {
 }
 
-
 bool mc::DefaultDisplayBufferCompositor::composite()
 {
     report->began_frame(this);
 
-    /*
-     * Increment frame counts for each tick of the fastest instance of
-     * DefaultDisplayBufferCompositor. This means for the fastest refresh
-     * rate of all attached outputs.
-     */
-    local_frameno++;
-    {
-        std::lock_guard<std::mutex> lock(global_frameno_lock);
-        if (wrapped_greater_or_equal(local_frameno, global_frameno))
-            global_frameno = local_frameno;
-        else
-            local_frameno = global_frameno;
-    }
-
     static bool const bypass_env{[]
     {
         auto const env = getenv("MIR_BYPASS");
@@ -123,8 +102,13 @@
 
         if (filter.fullscreen_on_top())
         {
-            auto bypass_buf =
-                match.topmost_fullscreen()->buffer(local_frameno);
+            /*
+             * Notice the user_id we pass to buffer() here has to be
+             * different to the one used in the Renderer. This is in case
+             * the below if() fails we want to complete the frame using the
+             * same buffer (different user_id required).
+             */
+            auto bypass_buf = match.topmost_fullscreen()->buffer(this);
 
             if (bypass_buf->can_bypass())
             {
@@ -140,41 +124,32 @@
 
     if (!bypassed)
     {
-        // preserves buffers used in rendering until after post_update()
-        std::vector<std::shared_ptr<void>> saved_resources;
-        auto save_resource = [&](std::shared_ptr<void> const& r)
-        {
-            saved_resources.push_back(r);
-        };
-
         display_buffer.make_current();
 
         auto const& view_area = display_buffer.view_area();
+        auto renderable_list = scene->generate_renderable_list();
+        mc::filter_occlusions_from(renderable_list, view_area);
 
-        mc::OcclusionFilter occlusion_search(view_area);
-        mc::OcclusionMatch occlusion_match;
-        scene->reverse_for_each_if(occlusion_search, occlusion_match);
+        for(auto const& renderable : renderable_list)
+            uncomposited_buffers |= (renderable->buffers_ready_for_compositor() > 1);
 
         renderer->set_rotation(display_buffer.orientation());
         renderer->begin();
-        mc::RenderingOperator applicator(*renderer, save_resource, local_frameno, uncomposited_buffers);
-        FilterForVisibleSceneInRegion selector(view_area, occlusion_match);
+        mc::RenderingOperator applicator(*renderer);
+        VisibilityFilter selector(renderable_list);
         scene->for_each_if(selector, applicator);
         renderer->end();
 
         display_buffer.post_update();
 
         // This is a frig to avoid lp:1286190
-        if (size_of_last_pass)
-        {
-            uncomposited_buffers |= saved_resources.empty();
-        }
+        if (last_pass_rendered_anything && renderable_list.empty())
+            uncomposited_buffers = true;
 
-        size_of_last_pass = saved_resources.size();
+        last_pass_rendered_anything = !renderable_list.empty();
         // End of frig
     }
 
     report->finished_frame(bypassed, this);
     return uncomposited_buffers;
 }
-

=== modified file 'src/server/compositor/default_display_buffer_compositor.h'
--- src/server/compositor/default_display_buffer_compositor.h	2014-03-07 03:15:55 +0000
+++ src/server/compositor/default_display_buffer_compositor.h	2014-04-02 18:58:27 +0000
@@ -53,8 +53,7 @@
     std::shared_ptr<Renderer> const renderer;
     std::shared_ptr<CompositorReport> const report;
 
-    int size_of_last_pass = 0;
-    unsigned long local_frameno;
+    bool last_pass_rendered_anything;
 };
 
 }

=== modified file 'src/server/compositor/gl_renderer.cpp'
--- src/server/compositor/gl_renderer.cpp	2014-03-17 07:35:22 +0000
+++ src/server/compositor/gl_renderer.cpp	2014-04-02 18:58:27 +0000
@@ -48,7 +48,6 @@
     "void main() {\n"
     "   vec4 mid = vec4(centre, 0.0, 0.0);\n"
     "   vec4 transformed = (transform * (vec4(position, 1.0) - mid)) + mid;\n"
-    "   transformed.z = 0.0;\n" // avoid clipping while we lack depth/perspective
     "   gl_Position = display_transform * screen_to_gl_coords * transformed;\n"
     "   v_texcoord = texcoord;\n"
     "}\n"
@@ -184,8 +183,9 @@
         glDeleteTextures(1, &t.second.id);
 }
 
-GLenum mc::GLRenderer::tessellate(graphics::Renderable const& renderable,
-                                  std::vector<Vertex>& vertices) const
+void mc::GLRenderer::tessellate(std::vector<Primitive>& primitives,
+                                graphics::Renderable const& renderable,
+                                geometry::Size const& buf_size) const
 {
     auto const& rect = renderable.screen_position();
     GLfloat left = rect.top_left.x.as_int();
@@ -193,12 +193,22 @@
     GLfloat top = rect.top_left.y.as_int();
     GLfloat bottom = top + rect.size.height.as_int();
 
+    primitives.resize(1);
+    auto& client = primitives[0];
+    client.tex_id = 0;
+    client.type = GL_TRIANGLE_STRIP;
+
+    GLfloat tex_right = static_cast<GLfloat>(rect.size.width.as_int()) /
+                        buf_size.width.as_int();
+    GLfloat tex_bottom = static_cast<GLfloat>(rect.size.height.as_int()) /
+                         buf_size.height.as_int();
+
+    auto& vertices = client.vertices;
     vertices.resize(4);