Merge lp:~thomas-voss/mir/explicit-gcc-version into lp:mir/ubuntu

[Thomas Voß]

Explicitly select g++-4.9 to prevent from ABI breaks.

Explicitly select g++-4.9 to prevent from ABI breaks.

[Alan Griffiths (alan-griffiths)]

Lots of unrelated change. (Looks like development-branch may be the intended target.)

review: Needs Resubmitting

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1728
http://jenkins.qa.ubuntu.com/job/mir-ci/1666/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/728/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/734
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-utopic-amd64-ci/4/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-utopic-armhf-ci/4
        deb: http://jenkins.qa.ubuntu.com/job/mir-utopic-armhf-ci/4/artifact/work/output/*zip*/output.zip

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

review: Needs Fixing (continuous-integration)

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp	2014-05-21 02:24:48 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp	2014-06-27 09:18:41 +0000
@@ -922,7 +922,7 @@
     mMappers.add(mapper);
 }
 
-void InputDevice::configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes) {
+void InputDevice::configure(nsecs_t when, InputReaderConfiguration const* config, uint32_t changes) {
     mSources = 0;
 
     if (!isIgnored()) {
@@ -1760,7 +1760,7 @@
 void InputMapper::dump(String8& dump) {
 }
 
-void InputMapper::configure(nsecs_t when,
+void InputMapper::configure(nsecs_t when, 
         const InputReaderConfiguration* config, uint32_t changes) {
 }
 
@@ -1998,8 +1998,7 @@
 }
 
 
-void KeyboardInputMapper::configure(nsecs_t when,
-        const InputReaderConfiguration* config, uint32_t changes) {
+void KeyboardInputMapper::configure(nsecs_t when, InputReaderConfiguration const* config, uint32_t changes) {
     InputMapper::configure(when, config, changes);
 
     if (!changes) { // first time only
@@ -2284,8 +2283,7 @@
     appendFormat(dump, INDENT3 "DownTime: %lld\n", mDownTime);
 }
 
-void CursorInputMapper::configure(nsecs_t when,
-        const InputReaderConfiguration* config, uint32_t changes) {
+void CursorInputMapper::configure(nsecs_t when, InputReaderConfiguration const* config, uint32_t changes) {
     InputMapper::configure(when, config, changes);
 
     if (!changes) { // first time only
@@ -2694,8 +2692,8 @@
     }
 }
 
-void TouchInputMapper::configure(nsecs_t when,
-        const InputReaderConfiguration* config, uint32_t changes) {
+void TouchInputMapper::configure(nsecs_t when, const InputReaderConfiguration* config,
+    uint32_t changes) {
     InputMapper::configure(when, config, changes);
 
     mConfig = *config;
@@ -2792,16 +2790,9 @@
     getDevice()->getConfiguration().tryGetProperty(String8("touch.orientationAware"),
             mParameters.orientationAware);
 
-    mParameters.associatedDisplayId = -1;
-    mParameters.associatedDisplayIsExternal = false;
-    if (mParameters.orientationAware
-            || mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN
-            || mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER) {
-        mParameters.associatedDisplayIsExternal =
-                mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN
-                        && getDevice()->isExternal();
-        mParameters.associatedDisplayId = 0;
-    }
+    mContext->getPolicy()->getAssociatedDisplayInfo(getDevice()->getIdentifier(),
+        mParameters.associatedDisplayId, mParameters.associatedDisplayIsExternal);
+    
 }
 
 void TouchInputMapper::dumpParameters(String8& dump) {
@@ -6055,8 +6046,7 @@
     }
 }
 
-void JoystickInputMapper::configure(nsecs_t when,
-        const InputReaderConfiguration* config, uint32_t changes) {
+void JoystickInputMapper::configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes) {
     InputMapper::configure(when, config, changes);
 
     if (!changes) { // first time only

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputReader.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputReader.h	2014-05-21 02:24:48 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputReader.h	2014-06-27 09:18:41 +0000
@@ -240,6 +240,10 @@
 
     /* Gets a user-supplied alias for a particular input device, or an empty string if none. */
     virtual String8 getDeviceAlias(const InputDeviceIdentifier& identifier) = 0;
+
+    /* Retrieve the display association for a given device. */
+    virtual void getAssociatedDisplayInfo(InputDeviceIdentifier const& identifier,
+        int& out_associated_display_id, bool& out_associated_display_is_external) = 0;
 };
 
 
@@ -472,6 +476,7 @@
     inline const String8& getName() { return mIdentifier.name; }
     inline uint32_t getClasses() { return mClasses; }
     inline uint32_t getSources() { return mSources; }
+    inline InputDeviceIdentifier const& getIdentifier() { return mIdentifier; }
 
     inline bool isExternal() { return mIsExternal; }
     inline void setExternal(bool external) { mIsExternal = external; }
@@ -480,7 +485,7 @@
 
     void dump(String8& dump);
     void addMapper(InputMapper* mapper);
-    void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
+    void configure(nsecs_t when, InputReaderConfiguration const* config, uint32_t changes);
     void reset(nsecs_t when);
     void process(const RawEvent* rawEvents, size_t count);
     void timeoutExpired(nsecs_t when);
@@ -892,7 +897,7 @@
     virtual uint32_t getSources() = 0;
     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
     virtual void dump(String8& dump);
-    virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
+    virtual void configure(nsecs_t when, InputReaderConfiguration const* config, uint32_t changes);
     virtual void reset(nsecs_t when);
     virtual void process(const RawEvent* rawEvent) = 0;
     virtual void timeoutExpired(nsecs_t when);
@@ -974,7 +979,8 @@
     virtual uint32_t getSources();
     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
     virtual void dump(String8& dump);
-    virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
+    virtual void configure(nsecs_t when, 
+        InputReaderConfiguration const* config, uint32_t changes);
     virtual void reset(nsecs_t when);
     virtual void process(const RawEvent* rawEvent);
 
@@ -1042,7 +1048,8 @@
     virtual uint32_t getSources();
     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
     virtual void dump(String8& dump);
-    virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
+    virtual void configure(nsecs_t when, 
+        InputReaderConfiguration const* config, uint32_t changes);
     virtual void reset(nsecs_t when);
     virtual void process(const RawEvent* rawEvent);
 
@@ -1107,7 +1114,8 @@
     virtual uint32_t getSources();
     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
     virtual void dump(String8& dump);
-    virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
+    virtual void configure(nsecs_t when, 
+        InputReaderConfiguration const* config, uint32_t changes);
     virtual void reset(nsecs_t when);
     virtual void process(const RawEvent* rawEvent);
 
@@ -1679,7 +1687,8 @@
     virtual uint32_t getSources();
     virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo);
     virtual void dump(String8& dump);
-    virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
+    virtual void configure(nsecs_t when,
+        InputReaderConfiguration const* config, uint32_t changes);
     virtual void reset(nsecs_t when);
     virtual void process(const RawEvent* rawEvent);
 

=== modified file 'benchmarks/android-input/input_reader_perf.cpp'
--- benchmarks/android-input/input_reader_perf.cpp	2014-05-21 02:24:48 +0000
+++ benchmarks/android-input/input_reader_perf.cpp	2014-06-27 09:18:41 +0000
@@ -61,6 +61,12 @@
         return mInputDevices;
     }
 
+    void getAssociatedDisplayInfo(InputDeviceIdentifier const& /* identifier */,
+        int& out_associated_display_id, bool& out_associated_display_is_external) {
+        out_associated_display_id = 0;
+        out_associated_display_is_external = false;
+    }
+
 private:
     virtual void getReaderConfiguration(InputReaderConfiguration* outConfig) {
         *outConfig = mConfig;

=== modified file 'debian/changelog'
--- debian/changelog	2014-06-18 17:51:53 +0000
+++ debian/changelog	2014-06-27 09:18:41 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 mir (0.3.0+14.10.20140618.1-0ubuntu1) utopic; urgency=medium
 
   [ Cemil Azizoglu ]
@@ -48,6 +49,11 @@
 mir (0.2.0+14.10.20140605-0ubuntu1) utopic; urgency=medium
 
   [ Daniel van Vugt ]
+=======
+mir (0.2.0-0ubuntu2) UNRELEASED; urgency=medium
+
+  [ Daniel van Vugt ]
+>>>>>>> MERGE-SOURCE
   * New upstream release 0.2.0 (https://launchpad.net/mir/+milestone/0.2.0)
     - mirclient ABI unchanged, still at 7. Clients do not need rebuilding.
     - mirserver ABI bumped to 20. Shells need rebuilding.
@@ -173,7 +179,14 @@
   [ Ubuntu daily release ]
   * New rebuild forced
 
+<<<<<<< TREE
  -- Ubuntu daily release <[e-mail]>  Thu, 05 Jun 2014 14:02:57 +0000
+=======
+  [ Thomas Voß ]
+  * Explicitly select g++-4.9 to prevent from ABI breaks.
+
+ -- Thomas Voß <[e-mail]>  Fri, 27 Jun 2014 11:16:47 +0200
+>>>>>>> MERGE-SOURCE
 
 mir (0.1.9+14.10.20140430.1-0ubuntu1) utopic; urgency=medium
 

=== modified file 'debian/control'
--- debian/control	2014-06-18 12:50:31 +0000
+++ debian/control	2014-06-27 09:18:41 +0000
@@ -10,6 +10,10 @@
                doxygen,
                xsltproc,
                graphviz,
+# We rely on C++11 features, and to prevent from ABI breaks
+# in libstdc++ causing us issues, we explicitly select a G++
+# version.
+               g++-4.9,
                libboost-dev,
                libboost-chrono-dev,
                libboost-date-time-dev,
@@ -27,7 +31,7 @@
                libglm-dev,
                libprotobuf-dev,
                pkg-config,
-               android-headers (>=4.2.2) [i386 amd64 armhf],
+               android-headers (>=4.4.2) [i386 amd64 armhf],
                libhardware-dev [i386 amd64 armhf],
                libandroid-properties-dev [i386 amd64 armhf],
                libgoogle-glog-dev,

=== modified file 'debian/rules'
--- debian/rules	2014-04-15 17:11:14 +0000
+++ debian/rules	2014-06-27 09:18:41 +0000
@@ -6,6 +6,13 @@
 
 export DPKG_GENSYMBOLS_CHECK_LEVEL = 4
 
+include /usr/share/dpkg/default.mk
+
+# Explicitly selecting a G{CC,++}-version here to avoid accidental
+# ABI breaks introduced by toolchain updates.
+export CC=$(DEB_HOST_GNU_TYPE)-gcc-4.9
+export CXX=$(DEB_HOST_GNU_TYPE)-g++-4.9
+
 %:
 	dh $@ --parallel --fail-missing
 

=== modified file 'examples/eglapp.c'
--- examples/eglapp.c	2014-06-12 15:35:08 +0000
+++ examples/eglapp.c	2014-06-27 09:18:41 +0000
@@ -127,6 +127,14 @@
          */
         printf("Resized to %dx%d\n", ev->resize.width, ev->resize.height);
     }
+    else if (ev->type == mir_event_type_surface &&
+             ev->surface.attrib == mir_surface_attrib_visibility)
+    {
+        if (ev->surface.value == mir_surface_visibility_exposed)
+            printf("Surface exposed\n");
+        else if (ev->surface.value == mir_surface_visibility_occluded)
+            printf("Surface occluded\n");
+    }
 }
 
 static const MirDisplayOutput *find_active_output(
@@ -179,6 +187,7 @@
     EGLBoolean ok;
     EGLint swapinterval = 1;
     char *mir_socket = NULL;
+    char const* cursor_name = mir_default_cursor_name;
 
     if (argc > 1)
     {
@@ -263,6 +272,9 @@
                 case 'm':
                     mir_socket = argv[++i];
                     break;
+                case 'c':
+                    cursor_name = argv[++i];
+                    break;
                 case 'q':
                     {
                         FILE *unused = freopen("/dev/null", "a", stdout);
@@ -290,6 +302,7 @@
                        "  -n               Don't sync to vblank\n"
                        "  -m socket        Mir server socket\n"
                        "  -s WIDTHxHEIGHT  Force surface size\n"
+                       "  -c name          Request cursor image by name\n"
                        "  -q               Quiet mode (no messages output)\n"
                        , argv[0]);
                 return 0;
@@ -361,6 +374,10 @@
     CHECK(mir_surface_is_valid(surface), "Can't create a surface");
 
     mir_surface_set_event_handler(surface, &delegate);
+    
+    MirCursorConfiguration *conf = mir_cursor_configuration_from_name(cursor_name);
+    mir_surface_configure_cursor(surface, conf);
+    mir_cursor_configuration_destroy(conf);
 
     egldisplay = eglGetDisplay(
                     mir_connection_get_egl_native_display(connection));

=== modified file 'include/client/mir_toolkit/mir_cursor_configuration.h'
--- include/client/mir_toolkit/mir_cursor_configuration.h	2014-05-14 16:50:03 +0000
+++ include/client/mir_toolkit/mir_cursor_configuration.h	2014-06-27 09:18:41 +0000
@@ -18,6 +18,8 @@
 #ifndef MIR_TOOLKIT_MIR_CURSOR_H_
 #define MIR_TOOLKIT_MIR_CURSOR_H_
 
+#include <mir_toolkit/common.h>
+
 /**
  * Opaque structure containing cursor parameterization. Create with mir_cursor* family.
  * Used with mir_surface_configure_cursor.
@@ -33,17 +35,6 @@
 #endif
 
 /**
- * A special cursor name for use with mir_cursor_configuration_from_name
- * representing the system default cursor.
- */
-extern char const *const mir_default_cursor_name;
-/**
- * A special cursor name for use with mir_cursor_configuration_from_name
- * representing a disabled cursor image.
- */
-extern char const *const mir_disabled_cursor_name;
-
-/**
  * Release resources assosciated with cursor parameters
  *     \param [in] parameters The operand
  */

=== modified file 'include/client/mir_toolkit/mir_surface.h'
--- include/client/mir_toolkit/mir_surface.h	2014-06-12 15:35:08 +0000
+++ include/client/mir_toolkit/mir_surface.h	2014-06-27 09:18:41 +0000
@@ -266,6 +266,13 @@
  */
 MirWaitHandle* mir_surface_configure_cursor(MirSurface *surface, MirCursorConfiguration const* parameters);
 
+/**
+ * Get the orientation of a surface.
+ *   \param [in] surface  The surface to query
+ *   \return              The orientation of the surface
+ */
+MirOrientation mir_surface_get_orientation(MirSurface *surface);
+
 #ifdef __cplusplus
 }
 /**@}*/

=== modified file 'include/platform/mir/graphics/event_handler_register.h'
--- include/platform/mir/graphics/event_handler_register.h	2013-08-28 03:41:48 +0000
+++ include/platform/mir/graphics/event_handler_register.h	2014-06-27 09:18:41 +0000
@@ -37,8 +37,11 @@
 
     virtual void register_fd_handler(
         std::initializer_list<int> fds,
+        void const* owner,
         std::function<void(int)> const& handler) = 0;
 
+    virtual void unregister_fd_handler(void const* owner) = 0;
+
 protected:
     EventHandlerRegister() = default;
     virtual ~EventHandlerRegister() = default;

=== modified file 'include/platform/mir/graphics/native_platform.h'
--- include/platform/mir/graphics/native_platform.h	2014-03-06 06:05:17 +0000
+++ include/platform/mir/graphics/native_platform.h	2014-06-27 09:18:41 +0000
@@ -18,6 +18,7 @@
 #ifndef MIR_GRAPHICS_NATIVE_PLATFORM_H_
 #define MIR_GRAPHICS_NATIVE_PLATFORM_H_
 
+#include "mir/graphics/platform.h"
 #include <memory>
 #include <functional>
 
@@ -52,7 +53,10 @@
 
     virtual std::shared_ptr<InternalClient> create_internal_client() = 0;
 
-    virtual void fill_ipc_package(BufferIPCPacker* packer, Buffer const* buffer) const = 0;
+    virtual void fill_buffer_package(
+        BufferIPCPacker* packer,
+        Buffer const* buffer,
+        BufferIpcMsgType msg_type) const = 0;
 
     virtual ~NativePlatform() = default;
     NativePlatform(NativePlatform const&) = delete;

=== modified file 'include/platform/mir/graphics/platform.h'
--- include/platform/mir/graphics/platform.h	2014-06-10 14:40:23 +0000
+++ include/platform/mir/graphics/platform.h	2014-06-27 09:18:41 +0000
@@ -54,6 +54,11 @@
 class GLConfig;
 class GLProgramFactory;
 
+enum class BufferIpcMsgType
+{
+    full_msg, //pack the full ipc representation of the buffer
+    update_msg //assume the client has a full representation, and pack only updates to the buffer 
+};
 /**
  * \defgroup platform_enablement Mir platform enablement
  *
@@ -98,15 +103,21 @@
     virtual std::shared_ptr<PlatformIPCPackage> get_ipc_package() = 0;
 
     /**
-     * Fills the IPC package for a buffer.
+     * Arranges the IPC package for a buffer that is to be sent through
+     * the frontend. This should be called every time a buffer is to be
+     * sent cross-process.
      *
      * The Buffer IPC package will be sent to clients when receiving a buffer.
      * The implementation must use the provided packer object to perform the packing.
      *
-     * \param [in] packer the object providing the packing functionality
-     * \param [in] buffer the buffer to fill the IPC package for
+     * \param [in] packer   the object providing the packing functionality
+     * \param [in] buffer   the buffer to fill the IPC package for
+     * \param [in] ipc_type what sort of ipc message is needed
      */
-    virtual void fill_ipc_package(BufferIPCPacker* packer, Buffer const* buffer) const = 0;
+    virtual void fill_buffer_package(
+        BufferIPCPacker* packer,
+        Buffer const* buffer,
+        BufferIpcMsgType msg_type) const = 0;
 
     /**
      * Creates the in-process client support object.

=== modified file 'include/server/mir/asio_main_loop.h'
--- include/server/mir/asio_main_loop.h	2014-06-12 15:35:08 +0000
+++ include/server/mir/asio_main_loop.h	2014-06-27 09:18:41 +0000
@@ -22,8 +22,10 @@
 #include "mir/main_loop.h"
 
 #include <boost/asio.hpp>
+#include <boost/optional.hpp>
 #include <memory>
 #include <vector>
+#include <thread>
 #include <mutex>
 #include <utility>
 #include <deque>
@@ -52,7 +54,10 @@
 
     void register_fd_handler(
         std::initializer_list<int> fd,
-        std::function<void(int)> const& handler);
+        void const* owner,
+        std::function<void(int)> const& handler) override;
+
+    void unregister_fd_handler(void const* owner) override;
 
     std::unique_ptr<time::Alarm> notify_in(std::chrono::milliseconds delay,
                                            std::function<void()> callback) override;
@@ -72,8 +77,10 @@
 
     boost::asio::io_service io;
     boost::asio::io_service::work work;
+    boost::optional<std::thread::id> main_loop_thread;
     std::vector<std::unique_ptr<SignalHandler>> signal_handlers;
-    std::vector<std::unique_ptr<FDHandler>> fd_handlers;
+    std::vector<std::shared_ptr<FDHandler>> fd_handlers;
+    std::mutex fd_handlers_mutex;
     std::mutex server_actions_mutex;
     std::deque<std::pair<void const*,ServerAction>> server_actions;
     std::set<void const*> do_not_process;

=== added file 'include/server/mir/compositor/compositor_id.h'
--- include/server/mir/compositor/compositor_id.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/compositor/compositor_id.h	2014-06-27 09:18:41 +0000
@@ -0,0 +1,32 @@
+/*
+ * 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_COMPOSITOR_COMPOSITOR_ID_H_
+#define MIR_COMPOSITOR_COMPOSITOR_ID_H_
+
+namespace mir
+{
+namespace compositor
+{
+
+using CompositorID = void const*;
+
+}
+}
+
+#endif

=== modified file 'include/server/mir/compositor/scene.h'
--- include/server/mir/compositor/scene.h	2014-06-02 17:07:02 +0000
+++ include/server/mir/compositor/scene.h	2014-06-27 09:18:41 +0000
@@ -19,11 +19,10 @@
 #ifndef MIR_COMPOSITOR_SCENE_H_
 #define MIR_COMPOSITOR_SCENE_H_
 
-#include "mir/geometry/forward.h"
-#include "mir/graphics/renderable.h"
+#include "compositor_id.h"
 
 #include <memory>
-#include <functional>
+#include <vector>
 
 namespace mir
 {
@@ -35,24 +34,29 @@
 namespace compositor
 {
 
+class SceneElement;
+using SceneElementSequence = std::vector<std::shared_ptr<SceneElement>>;
+
 class Scene
 {
 public:
     virtual ~Scene() {}
 
     /**
-     * Generate a valid list of renderables based on the current state of the Scene.
+     * Generate a valid sequence of scene elements based on the current state of the Scene.
      * \param [in] id      An arbitrary unique identifier used to distinguish
-     *                     separate compositors which need to receive a list
+     *                     separate compositors which need to receive a sequence
      *                     for rendering. Calling with the same id will return
-     *                     a new (different) list to that user each time. For
+     *                     a new (different) sequence to that user each time. For
      *                     consistency, all callers need to determine their id
      *                     in the same way (e.g. always use "this" pointer).
-     * \returns a list of mg::Renderables for the compositor id. The list is in
-     *          stacking order from back to front.
+     * \returns a sequence of mc::SceneElements for the compositor id. The
+     *          sequence is in stacking order from back to front.
      */
-    typedef void const* CompositorID;
-    virtual graphics::RenderableList renderable_list_for(CompositorID id) const = 0;
+    virtual SceneElementSequence scene_elements_for(CompositorID id) = 0;
+
+    virtual void register_compositor(CompositorID id) = 0;
+    virtual void unregister_compositor(CompositorID id) = 0;
 
     virtual void add_observer(std::shared_ptr<scene::Observer> const& observer) = 0;
     virtual void remove_observer(std::weak_ptr<scene::Observer> const& observer) = 0;

=== added file 'include/server/mir/compositor/scene_element.h'
--- include/server/mir/compositor/scene_element.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/compositor/scene_element.h	2014-06-27 09:18:41 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_COMPOSITOR_SCENE_ELEMENT_H_
+#define MIR_COMPOSITOR_SCENE_ELEMENT_H_
+
+#include "compositor_id.h"
+#include <memory>
+
+namespace mir
+{
+namespace graphics
+{
+class Renderable;
+}
+namespace compositor
+{
+
+class SceneElement
+{
+public:
+    virtual ~SceneElement() = default;
+
+    virtual std::shared_ptr<graphics::Renderable> renderable() const = 0;
+    virtual void rendered_in(CompositorID cid) = 0;
+    virtual void occluded_in(CompositorID cid) = 0;
+
+protected:
+    SceneElement() = default;
+    SceneElement(SceneElement const&) = delete;
+    SceneElement& operator=(SceneElement const&) = delete;
+};
+
+}
+}
+
+#endif // MIR_COMPOSITOR_SCENE_ELEMENT_H_

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2014-06-12 15:35:08 +0000
+++ include/server/mir/default_server_configuration.h	2014-06-27 09:18:41 +0000
@@ -120,6 +120,8 @@
 class InputConfiguration;
 class CursorListener;
 class InputRegion;
+class InputSender;
+class InputSendObserver;
 class NestedInputRelay;
 class EventHandler;
 namespace android
@@ -164,6 +166,8 @@
     virtual std::shared_ptr<graphics::Platform>     the_graphics_platform();
     virtual std::shared_ptr<input::InputConfiguration> the_input_configuration();
     virtual std::shared_ptr<input::InputDispatcher> the_input_dispatcher();
+    virtual std::shared_ptr<input::InputSender>     the_input_sender();
+    virtual std::shared_ptr<input::InputSendObserver> the_input_send_observer();
     virtual std::shared_ptr<EmergencyCleanup>  the_emergency_cleanup();
     /** @} */
 
@@ -321,6 +325,8 @@
     CachedPtr<input::CompositeEventFilter> composite_event_filter;
     CachedPtr<input::InputManager>    input_manager;
     CachedPtr<input::InputDispatcher> input_dispatcher;
+    CachedPtr<input::InputSender>     input_sender;
+    CachedPtr<input::InputSendObserver> input_send_observer;
     CachedPtr<input::InputRegion>     input_region;
     CachedPtr<shell::InputTargeter> input_targeter;
     CachedPtr<input::CursorListener> cursor_listener;

=== modified file 'include/server/mir/input/android/default_android_input_configuration.h'
--- include/server/mir/input/android/default_android_input_configuration.h	2014-06-02 17:07:02 +0000
+++ include/server/mir/input/android/default_android_input_configuration.h	2014-06-27 09:18:41 +0000
@@ -56,7 +56,6 @@
                               std::shared_ptr<input::InputReport> const& input_report);
     virtual ~DefaultInputConfiguration();
 
-    std::shared_ptr<input::InputChannelFactory> the_input_channel_factory() override;
     std::shared_ptr<input::InputManager> the_input_manager() override;
 
 protected:

=== modified file 'include/server/mir/input/input_configuration.h'
--- include/server/mir/input/input_configuration.h	2014-06-02 17:07:02 +0000
+++ include/server/mir/input/input_configuration.h	2014-06-27 09:18:41 +0000
@@ -26,14 +26,12 @@
 namespace input
 {
 class InputManager;
-class InputChannelFactory;
 
 class InputConfiguration
 {
 public:
     virtual ~InputConfiguration() = default;
 
-    virtual std::shared_ptr<InputChannelFactory> the_input_channel_factory() = 0;
     virtual std::shared_ptr<InputManager> the_input_manager() = 0;
 
 protected:

=== added file 'include/server/mir/input/input_send_observer.h'
--- include/server/mir/input/input_send_observer.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/input/input_send_observer.h	2014-06-27 09:18:41 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_INPUT_SEND_OBSERVER_H_
+#define MIR_INPUT_INPUT_SEND_OBSERVER_H_
+
+#include <mir_toolkit/event.h>
+
+#include <memory>
+
+namespace mir
+{
+namespace input
+{
+class Surface;
+
+class InputSendObserver
+{
+public:
+    InputSendObserver() = default;
+    virtual ~InputSendObserver() = default;
+
+    enum FailureReason
+    {
+        surface_disappeared,
+        no_response_received,
+        socket_error
+    };
+    /*!
+     * \brief An attempt to send an input event to a destination failed.
+     *
+     * Reasons for failure could be the surface disappearing from the scene, before the response
+     * was received. Or the client not responding in time.
+     */
+    virtual void send_failed(MirEvent const& event, input::Surface* surface, FailureReason reason) = 0;
+
+    enum InputResponse
+    {
+        consumed,
+        not_consumed
+    };
+    /*!
+     * \brief Client responded to an input event.
+     */
+    virtual void send_suceeded(MirEvent const& event, input::Surface* surface, InputResponse response) = 0;
+
+    /*!
+     * \brief Called when client is temporary blocked because input events are still in
+     * the queue.
+     */
+    virtual void client_blocked(MirEvent const& event, input::Surface* client) = 0;
+
+protected:
+    InputSendObserver& operator=(InputSendObserver const&) = delete;
+    InputSendObserver(InputSendObserver const&) = delete;
+};
+
+}
+}
+
+#endif

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

=== modified file 'include/server/mir/input/input_targets.h'
--- include/server/mir/input/input_targets.h	2014-04-24 08:42:12 +0000
+++ include/server/mir/input/input_targets.h	2014-06-27 09:18:41 +0000
@@ -26,6 +26,11 @@
 
 namespace mir
 {
+namespace scene
+{
+class Observer;
+}
+
 namespace input
 {
 class Surface;
@@ -37,6 +42,9 @@
 
     virtual void for_each(std::function<void(std::shared_ptr<input::Surface> const&)> const& callback) = 0;
 
+    virtual void add_observer(std::shared_ptr<scene::Observer> const& observer) = 0;
+    virtual void remove_observer(std::weak_ptr<scene::Observer> const& observer) = 0;
+
 protected:
     InputTargets() = default;
     InputTargets(InputTargets const&) = delete;

=== modified file 'include/server/mir/input/surface.h'
--- include/server/mir/input/surface.h	2014-06-03 11:04:15 +0000
+++ include/server/mir/input/surface.h	2014-06-27 09:18:41 +0000
@@ -23,11 +23,23 @@
 #include "mir/geometry/rectangle.h"
 #include "mir/input/input_reception_mode.h"
 
+#include "mir_toolkit/event.h"
+
 #include <string>
 #include <memory>
 
 namespace mir
 {
+namespace graphics
+{
+class CursorImage;
+}
+
+namespace scene
+{
+class SurfaceObserver;
+}
+
 namespace input
 {
 class InputChannel;
@@ -39,7 +51,9 @@
     virtual geometry::Rectangle input_bounds() const = 0;
     virtual bool input_area_contains(geometry::Point const& point) const = 0;
     virtual std::shared_ptr<input::InputChannel> input_channel() const = 0;
+    virtual std::shared_ptr<graphics::CursorImage> cursor_image() const = 0;
     virtual InputReceptionMode reception_mode() const = 0;
+    virtual void consume(MirEvent const& event) = 0;
 
 protected:
     Surface() = default;

=== modified file 'include/server/mir/scene/null_surface_observer.h'
--- include/server/mir/scene/null_surface_observer.h	2014-06-12 15:35:08 +0000
+++ include/server/mir/scene/null_surface_observer.h	2014-06-27 09:18:41 +0000
@@ -37,6 +37,7 @@
     void hidden_set_to(bool hide);
     void frame_posted(int frames_available);
     void alpha_set_to(float alpha);
+    void orientation_set_to(MirOrientation orientation) override;
     void transformation_set_to(glm::mat4 const& t);
     void cursor_image_set_to(graphics::CursorImage const& image);
     void reception_mode_set_to(input::InputReceptionMode mode);

=== modified file 'include/server/mir/scene/surface.h'
--- include/server/mir/scene/surface.h	2014-06-05 14:38:50 +0000
+++ include/server/mir/scene/surface.h	2014-06-27 09:18:41 +0000
@@ -70,10 +70,11 @@
     virtual void resize(geometry::Size const& size) = 0;
     virtual void set_transformation(glm::mat4 const& t) = 0;
     virtual void set_alpha(float alpha) = 0;
+    virtual void set_orientation(MirOrientation orientation) = 0;
     virtual void force_requests_to_complete() = 0;
     
     virtual void set_cursor_image(std::shared_ptr<graphics::CursorImage> const& image) = 0;
-    virtual std::shared_ptr<graphics::CursorImage> cursor_image() = 0;
+    virtual std::shared_ptr<graphics::CursorImage> cursor_image() const = 0;
 
     virtual void add_observer(std::shared_ptr<SurfaceObserver> const& observer) = 0;
     virtual void remove_observer(std::weak_ptr<SurfaceObserver> const& observer) = 0;

=== modified file 'include/server/mir/scene/surface_event_source.h'
--- include/server/mir/scene/surface_event_source.h	2014-06-02 17:07:02 +0000
+++ include/server/mir/scene/surface_event_source.h	2014-06-27 09:18:41 +0000
@@ -38,6 +38,7 @@
 
     void attrib_changed(MirSurfaceAttrib attrib, int value) override;
     void resized_to(geometry::Size const& size) override;
+    void orientation_set_to(MirOrientation orientation) override;
 
 private:
     frontend::SurfaceId const id;

=== modified file 'include/server/mir/scene/surface_observer.h'
--- include/server/mir/scene/surface_observer.h	2014-06-12 15:35:08 +0000
+++ include/server/mir/scene/surface_observer.h	2014-06-27 09:18:41 +0000
@@ -48,6 +48,7 @@
     virtual void hidden_set_to(bool hide) = 0;
     virtual void frame_posted(int frames_available) = 0;
     virtual void alpha_set_to(float alpha) = 0;
+    virtual void orientation_set_to(MirOrientation orientation) = 0;
     virtual void transformation_set_to(glm::mat4 const& t) = 0;
     virtual void reception_mode_set_to(input::InputReceptionMode mode) = 0;
     virtual void cursor_image_set_to(graphics::CursorImage const& image) = 0;

=== modified file 'include/shared/mir/graphics/android/android_native_buffer.h'
--- include/shared/mir/graphics/android/android_native_buffer.h	2013-10-11 22:03:04 +0000
+++ include/shared/mir/graphics/android/android_native_buffer.h	2014-06-27 09:18:41 +0000
@@ -33,18 +33,21 @@
 
 struct AndroidNativeBuffer : public graphics::NativeBuffer
 {
-    AndroidNativeBuffer(std::shared_ptr<ANativeWindowBuffer> const& handle,
-        std::shared_ptr<Fence> const& fence);
+    AndroidNativeBuffer(
+        std::shared_ptr<ANativeWindowBuffer> const& handle,
+        std::shared_ptr<Fence> const& fence,
+        BufferAccess fence_access);
 
     ANativeWindowBuffer* anwb() const;
     buffer_handle_t handle() const;
     NativeFence copy_fence() const;
 
-    void wait_for_content();
-    void update_fence(NativeFence& merge_fd);
+    void ensure_available_for(BufferAccess);
+    void update_usage(NativeFence& merge_fd, BufferAccess);
 
 private:
     std::shared_ptr<Fence> fence;
+    BufferAccess access;
     std::shared_ptr<ANativeWindowBuffer> native_window_buffer;
 };
 

=== modified file 'include/shared/mir/graphics/android/native_buffer.h'
--- include/shared/mir/graphics/android/native_buffer.h	2014-03-06 06:05:17 +0000
+++ include/shared/mir/graphics/android/native_buffer.h	2014-06-27 09:18:41 +0000
@@ -27,6 +27,15 @@
 namespace graphics
 {
 
+namespace android
+{
+enum class BufferAccess
+{
+    read,
+    write
+};
+}
+
 class NativeBuffer
 {
 public:
@@ -36,8 +45,8 @@
     virtual buffer_handle_t handle() const = 0;
     virtual android::NativeFence copy_fence() const = 0;
 
-    virtual void wait_for_content() = 0;
-    virtual void update_fence(android::NativeFence& fence) = 0;
+    virtual void ensure_available_for(android::BufferAccess intent) = 0;
+    virtual void update_usage(android::NativeFence& fence, android::BufferAccess current_usage) = 0;
 
 protected:
     NativeBuffer() = default;

=== modified file 'include/shared/mir_toolkit/common.h'
--- include/shared/mir_toolkit/common.h	2014-06-12 15:35:08 +0000
+++ include/shared/mir_toolkit/common.h	2014-06-27 09:18:41 +0000
@@ -1,7 +1,7 @@
 /*
  * Simple definitions common to client and server.
  *
- * 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 Lesser General Public License version 3 as
@@ -38,6 +38,7 @@
     mir_surface_attrib_swapinterval,
     mir_surface_attrib_focus,
     mir_surface_attrib_dpi,
+    mir_surface_attrib_visibility,
     mir_surface_attribs
 } MirSurfaceAttrib;
 
@@ -73,6 +74,12 @@
     mir_surface_focused
 } MirSurfaceFocusState;
 
+typedef enum MirSurfaceVisibility
+{
+    mir_surface_visibility_occluded = 0,
+    mir_surface_visibility_exposed
+} MirSurfaceVisibility;
+
 typedef enum MirLifecycleState
 {
     mir_lifecycle_state_will_suspend,
@@ -117,6 +124,7 @@
 /* This could be improved... https://bugs.launchpad.net/mir/+bug/1236254 */
 #define MIR_BYTES_PER_PIXEL(f) (((f) == mir_pixel_format_bgr_888) ? 3 : 4)
 
+/** Direction relative to the "natural" orientation of the display */
 typedef enum MirOrientation
 {
     mir_orientation_normal = 0,
@@ -125,6 +133,17 @@
     mir_orientation_right = 270
 } MirOrientation;
 
+/**
+ * A special cursor name for use with mir_cursor_configuration_from_name
+ * representing the system default cursor.
+ */
+extern char const *const mir_default_cursor_name;
+/**
+ * A special cursor name for use with mir_cursor_configuration_from_name
+ * representing a disabled cursor image.
+ */
+extern char const *const mir_disabled_cursor_name;
+
 /**@}*/
 
 #endif

=== modified file 'include/shared/mir_toolkit/event.h'
--- include/shared/mir_toolkit/event.h	2014-06-11 16:11:32 +0000
+++ include/shared/mir_toolkit/event.h	2014-06-27 09:18:41 +0000
@@ -41,7 +41,8 @@
     mir_event_type_motion,
     mir_event_type_surface,
     mir_event_type_resize,
-    mir_event_type_prompt_session_state_change
+    mir_event_type_prompt_session_state_change,
+    mir_event_type_orientation
 } MirEventType;
 
 typedef enum {
@@ -212,6 +213,14 @@
     MirPromptSessionState new_state;
 } MirPromptSessionEvent;
 
+typedef struct MirOrientationEvent
+{
+    MirEventType type;
+
+    int surface_id;
+    MirOrientation direction;
+} MirOrientationEvent;
+
 typedef union
 {
     MirEventType    type;
@@ -220,6 +229,7 @@
     MirSurfaceEvent surface;
     MirResizeEvent  resize;
     MirPromptSessionEvent  prompt_session;
+    MirOrientationEvent orientation;
 } MirEvent;
 
 #ifdef __cplusplus

=== modified file 'include/test/mir_test/client_event_matchers.h'
--- include/test/mir_test/client_event_matchers.h	2014-06-02 17:07:02 +0000
+++ include/test/mir_test/client_event_matchers.h	2014-06-27 09:18:41 +0000
@@ -201,6 +201,19 @@
     return true;
 }
 
+MATCHER_P2(TouchEvent, x, y, "")
+{
+    if (to_ref(arg).type != mir_event_type_motion)
+        return false;
+    if (to_ref(arg).motion.action != mir_motion_action_down)
+        return false;
+    if (to_ref(arg).motion.pointer_coordinates[0].x != x)
+        return false;
+    if (to_ref(arg).motion.pointer_coordinates[0].y != y)
+        return false;
+    return true;
+}
+
 MATCHER_P2(MotionEventWithPosition, x, y, "")
 {
     if (to_ref(arg).type != mir_event_type_motion)

=== modified file 'include/test/mir_test/event_factory.h'
--- include/test/mir_test/event_factory.h	2013-04-24 23:59:52 +0000
+++ include/test/mir_test/event_factory.h	2014-06-27 09:18:41 +0000
@@ -75,6 +75,19 @@
 };
 MotionParameters a_motion_event();
 
+class TouchParameters
+{
+public:
+    TouchParameters();
+    TouchParameters& from_device(int device_id);
+    TouchParameters& at_position(int abs_x, int abs_y);
+    
+    int device_id;
+    int abs_x;
+    int abs_y;
+};
+TouchParameters a_touch_event();
+
 }
 }
 }

=== modified file 'include/test/mir_test/fake_event_hub.h'
--- include/test/mir_test/fake_event_hub.h	2014-06-02 17:07:02 +0000
+++ include/test/mir_test/fake_event_hub.h	2014-06-27 09:18:41 +0000
@@ -75,6 +75,10 @@
     // special meaning) will do. There is no notion of a builtin
     // cursor device in the android input stack.
     static const int BuiltInCursorID = droidinput::BUILT_IN_KEYBOARD_ID + 1;
+    static const int USBTouchscreenID;
+
+    static const int TouchScreenMinAxisValue;
+    static const int TouchScreenMaxAxisValue;
 
     // From EventHubInterface
     uint32_t getDeviceClasses(int32_t deviceId) const override;
@@ -114,11 +118,13 @@
 
     void synthesize_builtin_keyboard_added();
     void synthesize_builtin_cursor_added();
+    void synthesize_usb_touchscreen_added();
     void synthesize_device_scan_complete();
 
-    void synthesize_event(const synthesis::KeyParameters &parameters);
-    void synthesize_event(const synthesis::ButtonParameters &parameters);
-    void synthesize_event(const synthesis::MotionParameters &parameters);
+    void synthesize_event(synthesis::KeyParameters const& parameters);
+    void synthesize_event(synthesis::ButtonParameters const& parameters);
+    void synthesize_event(synthesis::MotionParameters const& parameters);
+    void synthesize_event(synthesis::TouchParameters const& parameters);
     void synthesize_event(nsecs_t when, int32_t deviceId, int32_t type, int32_t code, int32_t value);
 
     void addDevice(int32_t deviceId, const std::string& name, uint32_t classes);

=== modified file 'include/test/mir_test_doubles/mock_android_native_buffer.h'
--- include/test/mir_test_doubles/mock_android_native_buffer.h	2014-03-11 13:44:57 +0000
+++ include/test/mir_test_doubles/mock_android_native_buffer.h	2014-06-27 09:18:41 +0000
@@ -54,8 +54,8 @@
     MOCK_CONST_METHOD0(handle, buffer_handle_t());
     MOCK_CONST_METHOD0(copy_fence, graphics::android::NativeFence());
 
-    MOCK_METHOD0(wait_for_content, void());
-    MOCK_METHOD1(update_fence, void(graphics::android::NativeFence&));
+    MOCK_METHOD1(ensure_available_for, void(graphics::android::BufferAccess));
+    MOCK_METHOD2(update_usage, void(graphics::android::NativeFence&, graphics::android::BufferAccess));
 
     ANativeWindowBuffer stub_anwb;
     native_handle_t native_handle;

=== added file 'include/test/mir_test_doubles/mock_input_send_observer.h'
--- include/test/mir_test_doubles/mock_input_send_observer.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_input_send_observer.h	2014-06-27 09:18:41 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_INPUT_SEND_OBSERVER_H_
+#define MIR_TEST_DOUBLES_MOCK_INPUT_SEND_OBSERVER_H_
+
+#include "mir/input/input_send_observer.h"
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct MockInputSendObserver : public mir::input::InputSendObserver
+{
+    MockInputSendObserver() = default;
+    MOCK_METHOD3(send_failed, void(MirEvent const&, mir::input::Surface*, FailureReason));
+    MOCK_METHOD3(send_suceeded, void(MirEvent const&, mir::input::Surface*, InputResponse));
+    MOCK_METHOD2(client_blocked, void(MirEvent const&, mir::input::Surface*));
+};
+
+}
+}
+}
+
+#endif

=== added file 'include/test/mir_test_doubles/mock_input_sender.h'
--- include/test/mir_test_doubles/mock_input_sender.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_input_sender.h	2014-06-27 09:18:41 +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: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_INPUT_SENDER_H_
+#define MIR_TEST_DOUBLES_MOCK_INPUT_SENDER_H_
+
+#include "mir/input/input_sender.h"
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct MockInputSender : mir::input::InputSender
+{
+    MOCK_METHOD1(set_send_observer, void(mir::input::InputSendObserver *));
+    MOCK_METHOD2(send_event, void(MirEvent const& ev, std::shared_ptr<mir::input::InputChannel> const& channel));
+};
+
+}
+}
+}
+
+#endif

=== modified file 'include/test/mir_test_doubles/mock_input_surface.h'
--- include/test/mir_test_doubles/mock_input_surface.h	2014-06-03 11:04:15 +0000
+++ include/test/mir_test_doubles/mock_input_surface.h	2014-06-27 09:18:41 +0000
@@ -32,26 +32,14 @@
 class MockInputSurface : public input::Surface
 {
 public:
-    MockInputSurface()
-    {
-        using namespace ::testing;
-        ON_CALL(*this, input_bounds())
-            .WillByDefault(Return(geometry::Rectangle()));
-        static std::string n;
-        ON_CALL(*this, name())
-            .WillByDefault(Return(n));
-        static std::shared_ptr<input::InputChannel> c{nullptr};
-        ON_CALL(*this, input_channel())
-            .WillByDefault(Return(c));
-        ON_CALL(*this, reception_mode())
-            .WillByDefault(Return(input::InputReceptionMode::normal));
-    }
     ~MockInputSurface() noexcept {}
     MOCK_CONST_METHOD0(name, std::string());
     MOCK_CONST_METHOD0(input_bounds, geometry::Rectangle());
     MOCK_CONST_METHOD1(input_area_contains, bool(geometry::Point const&));
     MOCK_CONST_METHOD0(input_channel, std::shared_ptr<input::InputChannel>());
+    MOCK_CONST_METHOD0(cursor_image, std::shared_ptr<graphics::CursorImage>());
     MOCK_CONST_METHOD0(reception_mode, input::InputReceptionMode());
+    MOCK_METHOD1(consume, void(MirEvent const&));
 };
 
 }

=== added file 'include/test/mir_test_doubles/mock_main_loop.h'
--- include/test/mir_test_doubles/mock_main_loop.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_main_loop.h	2014-06-27 09:18:41 +0000
@@ -0,0 +1,66 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_MAIN_LOOP_H_
+#define MIR_TEST_DOUBLES_MOCK_MAIN_LOOP_H_
+
+#include "mir/main_loop.h"
+#include "mir_test/gmock_fixes.h"
+
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+class MockMainLoop : public MainLoop
+{
+public:
+    ~MockMainLoop() noexcept {}
+
+    void run() override {}
+    void stop() override {}
+
+    MOCK_METHOD2(register_signal_handler,
+                 void(std::initializer_list<int>,
+                      std::function<void(int)> const&));
+
+    MOCK_METHOD3(register_fd_handler,
+                 void(std::initializer_list<int>, void const*,
+                      std::function<void(int)> const&));
+
+    MOCK_METHOD1(unregister_fd_handler, void(void const*));
+
+    MOCK_METHOD2(enqueue, void(void const*, ServerAction const&));
+    MOCK_METHOD1(pause_processing_for,void (void const*));
+    MOCK_METHOD1(resume_processing_for,void (void const*));
+
+    MOCK_METHOD2(notify_in, std::unique_ptr<time::Alarm>(std::chrono::milliseconds delay,
+                                           std::function<void(void)> callback));
+    MOCK_METHOD2(notify_at, std::unique_ptr<time::Alarm>(time::Timestamp time_point,
+                                           std::function<void(void)> callback));
+    MOCK_METHOD1(create_alarm, std::unique_ptr<time::Alarm>(std::function<void ()> callback));
+};
+
+}
+}
+}
+
+#endif

=== modified file 'include/test/mir_test_doubles/mock_scene.h'
--- include/test/mir_test_doubles/mock_scene.h	2014-06-03 11:04:15 +0000
+++ include/test/mir_test_doubles/mock_scene.h	2014-06-27 09:18:41 +0000
@@ -34,11 +34,13 @@
 public:
     MockScene()
     {
-        ON_CALL(*this, renderable_list_for(testing::_))
-            .WillByDefault(testing::Return(graphics::RenderableList{}));
+        ON_CALL(*this, scene_elements_for(testing::_))
+            .WillByDefault(testing::Return(compositor::SceneElementSequence{}));
     }
 
-    MOCK_CONST_METHOD1(renderable_list_for, graphics::RenderableList(void const*));
+    MOCK_METHOD1(scene_elements_for, compositor::SceneElementSequence(compositor::CompositorID));
+    MOCK_METHOD1(register_compositor, void(compositor::CompositorID));
+    MOCK_METHOD1(unregister_compositor, void(compositor::CompositorID));
 
     MOCK_METHOD1(add_observer, void(std::shared_ptr<scene::Observer> const&));
     MOCK_METHOD1(remove_observer, void(std::weak_ptr<scene::Observer> const&));

=== modified file 'include/test/mir_test_doubles/mock_surface.h'
--- include/test/mir_test_doubles/mock_surface.h	2014-06-03 16:43:38 +0000
+++ include/test/mir_test_doubles/mock_surface.h	2014-06-27 09:18:41 +0000
@@ -42,6 +42,7 @@
             {},
             {},
             {},
+            {},
             mir::report::null_scene_report())
     {
     }

=== modified file 'include/test/mir_test_doubles/null_platform.h'
--- include/test/mir_test_doubles/null_platform.h	2014-06-02 17:07:02 +0000
+++ include/test/mir_test_doubles/null_platform.h	2014-06-27 09:18:41 +0000
@@ -56,7 +56,8 @@
         return std::shared_ptr<graphics::InternalClient>();
     }
 
-    void fill_ipc_package(graphics::BufferIPCPacker*, graphics::Buffer const*) const
+    void fill_buffer_package(
+        graphics::BufferIPCPacker*, graphics::Buffer const*, graphics::BufferIpcMsgType) const
     {
     }
 

=== modified file 'include/test/mir_test_doubles/stub_buffer.h'
--- include/test/mir_test_doubles/stub_buffer.h	2014-06-06 22:52:52 +0000
+++ include/test/mir_test_doubles/stub_buffer.h	2014-06-27 09:18:41 +0000
@@ -22,8 +22,7 @@
 #ifdef ANDROID
 #include "mock_android_native_buffer.h"
 #else
-#include "src/platform/graphics/mesa/gbm_buffer.h"
-#include "mock_gbm.h"
+#include "stub_gbm_native_buffer.h"
 #endif
 
 #include "mir/graphics/buffer_basic.h"
@@ -43,33 +42,46 @@
 public:
     StubBuffer()
         : StubBuffer{
+              create_native_buffer(),
               graphics::BufferProperties{
                   geometry::Size{},
                   mir_pixel_format_abgr_8888,
-                  graphics::BufferUsage::hardware}}
-
+                  graphics::BufferUsage::hardware},
+              geometry::Stride{}}
+
+    {
+    }
+
+    StubBuffer(std::shared_ptr<graphics::NativeBuffer> const& native_buffer, geometry::Size const& size)
+        : StubBuffer{
+              native_buffer,
+              graphics::BufferProperties{
+                  size,
+                  mir_pixel_format_abgr_8888,
+                  graphics::BufferUsage::hardware},
+             geometry::Stride{}}
+
+    {
+    }
+
+    StubBuffer(std::shared_ptr<graphics::NativeBuffer> const& native_buffer)
+        : StubBuffer{native_buffer, {}}
     {
     }
 
     StubBuffer(graphics::BufferProperties const& properties)
-        : StubBuffer{properties, geometry::Stride{}}
+        : StubBuffer{create_native_buffer(), properties, geometry::Stride{}}
     {
     }
 
-    StubBuffer(graphics::BufferProperties const& properties,
+    StubBuffer(std::shared_ptr<graphics::NativeBuffer> const& native_buffer,
+               graphics::BufferProperties const& properties,
                geometry::Stride stride)
-        : buf_size{properties.size},
+        : native_buffer(native_buffer),
+          buf_size{properties.size},
           buf_pixel_format{properties.format},
           buf_stride{stride}
     {
-#ifndef ANDROID
-        auto buffer = std::make_shared<graphics::mesa::GBMNativeBuffer>();
-        int fake_bo{0}; 
-        buffer->bo = reinterpret_cast<gbm_bo*>(&fake_bo); //gbm_bo is opaque, so test code shouldn't dereference.
-        native_buffer = buffer;
-#else
-        native_buffer = std::make_shared<StubAndroidNativeBuffer>();
-#endif
     }
 
     virtual geometry::Size size() const { return buf_size; }
@@ -83,10 +95,19 @@
 
     virtual bool can_bypass() const override { return true; }
 
-    std::shared_ptr<graphics::NativeBuffer> native_buffer;
+    std::shared_ptr<graphics::NativeBuffer> const native_buffer;
     geometry::Size const buf_size;
     MirPixelFormat const buf_pixel_format;
     geometry::Stride const buf_stride;
+
+    std::shared_ptr<graphics::NativeBuffer> create_native_buffer()
+    {
+#ifndef ANDROID
+        return std::make_shared<StubGBMNativeBuffer>(geometry::Size{0,0});
+#else
+        return std::make_shared<StubAndroidNativeBuffer>();
+#endif
+    }
 };
 }
 }

=== added file 'include/test/mir_test_doubles/stub_display.h'
--- include/test/mir_test_doubles/stub_display.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_display.h	2014-06-27 09:18:41 +0000
@@ -0,0 +1,69 @@
+/*
+ * 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_DISPLAY_H_
+#define MIR_TEST_DOUBLES_STUB_DISPLAY_H_
+
+#include "null_display.h"
+#include "stub_display_buffer.h"
+#include "stub_display_configuration.h"
+
+#include "mir/geometry/rectangle.h"
+
+#include <vector>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class StubDisplay : public NullDisplay
+{
+public:
+    StubDisplay(std::vector<geometry::Rectangle> const& output_rects)
+        : output_rects{output_rects}
+    {
+        for (auto const& output_rect : output_rects)
+            display_buffers.emplace_back(output_rect);
+    }
+
+    void for_each_display_buffer(std::function<void(graphics::DisplayBuffer&)> const& f) override
+    {
+        for (auto& db : display_buffers)
+            f(db);
+    }
+
+    std::unique_ptr<graphics::DisplayConfiguration> configuration() const override
+    {
+        return std::unique_ptr<graphics::DisplayConfiguration>(
+            new StubDisplayConfig(output_rects)
+        );
+    }
+
+private:
+    std::vector<geometry::Rectangle> const output_rects;
+    std::vector<StubDisplayBuffer> display_buffers;
+};
+
+}
+}
+}
+
+#endif

=== added file 'include/test/mir_test_doubles/stub_gbm_native_buffer.h'
--- include/test/mir_test_doubles/stub_gbm_native_buffer.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_gbm_native_buffer.h	2014-06-27 09:18:41 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_GBM_NATIVE_BUFFER_H_
+#define MIR_TEST_DOUBLES_STUB_GBM_NATIVE_BUFFER_H_
+
+#include "src/platform/graphics/mesa/gbm_buffer.h"
+#include "mir/geometry/size.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct StubGBMNativeBuffer : public graphics::mesa::GBMNativeBuffer
+{
+    StubGBMNativeBuffer(geometry::Size const& size)
+    {
+        data_items = 4;
+        fd_items = 2;
+        width = size.width.as_int();
+        height = size.height.as_int();
+        flags = 0x66;
+        stride = 4390;
+        bo = reinterpret_cast<gbm_bo*>(&fake_bo); //gbm_bo is opaque, so test code shouldn't dereference.
+        for(auto i = 0; i < data_items; i++)
+            data[i] = i;
+        for(auto i = 0; i < fd_items; i++)
+            fd[i] = i;
+    }
+    int fake_bo{0}; 
+};
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_STUB_GBM_NATIVE_BUFFER_H_ */

=== added file 'include/test/mir_test_doubles/stub_input_sender.h'
--- include/test/mir_test_doubles/stub_input_sender.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_input_sender.h	2014-06-27 09:18:41 +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: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_INPUT_SENDER_H_
+#define MIR_TEST_DOUBLES_STUB_INPUT_SENDER_H_
+
+#include "mir/input/input_sender.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct StubInputSender : mir::input::InputSender
+{
+    void send_event(MirEvent const& /*event*/, std::shared_ptr<mir::input::InputChannel> const& /*channel*/) override
+    {
+    }
+};
+
+}
+}
+}
+
+#endif

=== modified file 'include/test/mir_test_doubles/stub_input_surface.h'
--- include/test/mir_test_doubles/stub_input_surface.h	2014-05-14 16:50:03 +0000
+++ include/test/mir_test_doubles/stub_input_surface.h	2014-06-27 09:18:41 +0000
@@ -47,9 +47,12 @@
     }
 
     mir::input::InputReceptionMode reception_mode() const { return mir::input::InputReceptionMode::normal; }
+    void consume(MirEvent const&) override  {}
     std::string name() const { return {}; }
     mir::geometry::Rectangle input_bounds() const override { return {{},{}}; }
     bool input_area_contains(mir::geometry::Point const&) const { return false; }
+    
+    std::shared_ptr<graphics::CursorImage> cursor_image() const { return nullptr; }
 
     std::shared_ptr<mir::input::InputChannel> const channel;
 };

=== modified file 'include/test/mir_test_doubles/stub_input_targets.h'
--- include/test/mir_test_doubles/stub_input_targets.h	2014-04-01 22:48:55 +0000
+++ include/test/mir_test_doubles/stub_input_targets.h	2014-06-27 09:18:41 +0000
@@ -33,6 +33,12 @@
     void for_each(std::function<void(std::shared_ptr<input::Surface> const&)> const& ) override
     {
     }
+    void add_observer(std::shared_ptr<scene::Observer> const& /* observer */)
+    {
+    }
+    void remove_observer(std::weak_ptr<scene::Observer> const& /* observer */)
+    {
+    }
 };
 
 }

=== modified file 'include/test/mir_test_doubles/stub_renderable.h'
--- include/test/mir_test_doubles/stub_renderable.h	2014-06-13 23:30:22 +0000
+++ include/test/mir_test_doubles/stub_renderable.h	2014-06-27 09:18:41 +0000
@@ -43,6 +43,10 @@
           stub_buffer(buffer)
     {}
 
+    StubRenderable(std::shared_ptr<graphics::Buffer> const& buffer)
+        : StubRenderable(buffer, {{},{}})
+    {}
+
     StubRenderable(geometry::Rectangle const& rect)
         : StubRenderable(make_stub_buffer(rect), rect)
     {}
@@ -130,6 +134,18 @@
     }
 };
 
+struct PlaneAlphaRenderable : public StubRenderable
+{
+    bool alpha_enabled() const override
+    {
+        return true;
+    }
+    float alpha() const override
+    {
+        //approx 99% alpha 
+        return 1.0f - ( 3.0f / 1024.0f );
+    }
+};
 }
 }
 }

=== modified file 'include/test/mir_test_doubles/stub_scene.h'
--- include/test/mir_test_doubles/stub_scene.h	2014-05-14 16:50:03 +0000
+++ include/test/mir_test_doubles/stub_scene.h	2014-06-27 09:18:41 +0000
@@ -32,10 +32,16 @@
 class StubScene : public compositor::Scene
 {
 public:
-    graphics::RenderableList renderable_list_for(void const*) const override
+    compositor::SceneElementSequence scene_elements_for(compositor::CompositorID) override
     {
           return {};
     }
+    void register_compositor(compositor::CompositorID) override
+    {
+    }
+    void unregister_compositor(compositor::CompositorID) override
+    {
+    }
     void add_observer(std::shared_ptr<scene::Observer> const&) override
     {
     }

=== added file 'include/test/mir_test_doubles/stub_scene_element.h'
--- include/test/mir_test_doubles/stub_scene_element.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_scene_element.h	2014-06-27 09:18:41 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_SCENE_ELEMENT_H_
+#define MIR_TEST_DOUBLES_STUB_SCENE_ELEMENT_H_
+
+#include "mir/compositor/scene_element.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class StubSceneElement : public compositor::SceneElement
+{
+public:
+    StubSceneElement(std::shared_ptr<graphics::Renderable> const& renderable)
+        : renderable_{renderable}
+    {
+    }
+
+    std::shared_ptr<graphics::Renderable> renderable() const
+    {
+        return renderable_;
+    }
+
+    void rendered_in(compositor::CompositorID) override
+    {
+    }
+
+    void occluded_in(compositor::CompositorID) override
+    {
+    }
+
+private:
+    std::shared_ptr<graphics::Renderable> const renderable_;
+};
+
+}
+}
+}
+
+#endif

=== modified file 'include/test/mir_test_doubles/stub_scene_surface.h'
--- include/test/mir_test_doubles/stub_scene_surface.h	2014-06-05 14:38:50 +0000
+++ include/test/mir_test_doubles/stub_scene_surface.h	2014-06-27 09:18:41 +0000
@@ -77,15 +77,17 @@
     void resize(geometry::Size const&) override {}
     void set_transformation(glm::mat4 const&) override {}
     void set_alpha(float) override {}
+    void set_orientation(MirOrientation) {}
     void force_requests_to_complete() override {}
 
     void add_observer(std::shared_ptr<scene::SurfaceObserver> const&) override {}
     void remove_observer(std::weak_ptr<scene::SurfaceObserver> const&) override {}
 
     void set_reception_mode(input::InputReceptionMode mode) override { input_mode = mode; }
+    void consume(MirEvent const&) override {}
 
     void set_cursor_image(std::shared_ptr<graphics::CursorImage> const& /* image */) {}
-    std::shared_ptr<graphics::CursorImage> cursor_image() { return {}; }
+    std::shared_ptr<graphics::CursorImage> cursor_image() const { return {}; }
 
     MirPixelFormat pixel_format() const override { return mir_pixel_format_xrgb_8888; }
 

=== modified file 'include/test/mir_test_doubles/stub_swapping_gl_context.h'
--- include/test/mir_test_doubles/stub_swapping_gl_context.h	2014-06-05 18:23:02 +0000
+++ include/test/mir_test_doubles/stub_swapping_gl_context.h	2014-06-27 09:18:41 +0000
@@ -31,11 +31,22 @@
 
 struct StubSwappingGLContext : public graphics::android::SwappingGLContext
 {
+    StubSwappingGLContext(std::shared_ptr<graphics::Buffer> const& buffer) :
+        buffer(buffer)
+    {
+    }
+
+    StubSwappingGLContext() :
+        StubSwappingGLContext(std::make_shared<StubBuffer>())
+    {
+    }
     void swap_buffers() const {}
     std::shared_ptr<graphics::Buffer> last_rendered_buffer() const
     {
-        return std::make_shared<StubBuffer>();
+        return buffer;
     }
+private:
+    std::shared_ptr<graphics::Buffer> const buffer;
 };
 
 }

=== modified file 'include/test/mir_test_doubles/stub_timer.h'
--- include/test/mir_test_doubles/stub_timer.h	2014-04-24 15:07:28 +0000
+++ include/test/mir_test_doubles/stub_timer.h	2014-06-27 09:18:41 +0000
@@ -37,7 +37,7 @@
     }
     State state() const override
     {
-        return Cancelled;
+        return cancelled;
     }
     bool reschedule_in(std::chrono::milliseconds) override
     {

=== added file 'include/test/mir_test_framework/deferred_in_process_server.h'
--- include/test/mir_test_framework/deferred_in_process_server.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_framework/deferred_in_process_server.h	2014-06-27 09:18:41 +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 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_FRAMEWORK_DEFERRED_IN_PROCESS_SERVER_H_
+#define MIR_TEST_FRAMEWORK_DEFERRED_IN_PROCESS_SERVER_H_
+
+#include "mir_test_framework/server_runner.h"
+
+#include <gtest/gtest.h>
+
+namespace mir_test_framework
+{
+/** Fixture for running Mir server in test process.
+ * The server startup is deferred until start_server() is called, to allows the
+ * test code to initialize the server environment with expectations or stubs.
+ */
+struct DeferredInProcessServer : testing::Test, private ServerRunner
+{
+    void TearDown() override { ServerRunner::stop_server(); }
+
+    using ServerRunner::start_server;
+    using ServerRunner::new_connection;
+};
+}
+
+#endif /* MIR_TEST_FRAMEWORK_DEFERRED_IN_PROCESS_SERVER_H_ */

=== modified file 'include/test/mir_test_framework/in_process_server.h'
--- include/test/mir_test_framework/in_process_server.h	2014-06-10 12:28:03 +0000
+++ include/test/mir_test_framework/in_process_server.h	2014-06-27 09:18:41 +0000
@@ -23,16 +23,6 @@
 
 #include <gtest/gtest.h>
 
-#include <string>
-#include <thread>
-
-namespace mir
-{
-class DisplayServer;
-class DefaultServerConfiguration;
-}
-
-
 namespace mir_test_framework
 {
 /// Fixture for running Mir server in test process

=== modified file 'include/test/mir_test_framework/input_testing_server_configuration.h'
--- include/test/mir_test_framework/input_testing_server_configuration.h	2014-06-02 17:07:02 +0000
+++ include/test/mir_test_framework/input_testing_server_configuration.h	2014-06-27 09:18:41 +0000
@@ -56,6 +56,7 @@
 {
 public:
     InputTestingServerConfiguration();
+    explicit InputTestingServerConfiguration(std::vector<geometry::Rectangle> const& display_rects);
 
     void exec();
     void on_exit();
@@ -63,6 +64,7 @@
     std::shared_ptr<mir::input::InputConfiguration> the_input_configuration() override;
     std::shared_ptr<mir::input::InputDispatcher> the_input_dispatcher() override;
     std::shared_ptr<mir::shell::InputTargeter> the_input_targeter() override;
+    std::shared_ptr<mir::input::InputSender> the_input_sender() override;
 
     mir::input::android::FakeEventHub* fake_event_hub;
 

=== modified file 'include/test/mir_test_framework/stubbed_server_configuration.h'
--- include/test/mir_test_framework/stubbed_server_configuration.h	2014-06-02 17:07:02 +0000
+++ include/test/mir_test_framework/stubbed_server_configuration.h	2014-06-27 09:18:41 +0000
@@ -20,6 +20,9 @@
 #define MIR_TEST_FRAMEWORK_STUBBED_SERVER_CONFIGURATION_H_
 
 #include "mir/default_server_configuration.h"
+#include "mir/geometry/rectangle.h"
+
+#include <vector>
 
 namespace mir_test_framework
 {
@@ -33,6 +36,7 @@
 {
 public:
     StubbedServerConfiguration();
+    explicit StubbedServerConfiguration(std::vector<geometry::Rectangle> const& display_rects);
 
     std::shared_ptr<graphics::Platform> the_graphics_platform() override;
     std::shared_ptr<compositor::RendererFactory> the_renderer_factory() override;
@@ -42,9 +46,13 @@
     std::shared_ptr<input::InputConfiguration> the_input_configuration() override;
     std::shared_ptr<input::InputDispatcher> the_input_dispatcher() override;
     std::shared_ptr<shell::InputTargeter> the_input_targeter() override;
+    std::shared_ptr<input::InputSender> the_input_sender() override;
+
+    std::shared_ptr<graphics::Cursor> the_cursor() override;
 
 private:
     std::shared_ptr<graphics::Platform> graphics_platform;
+    std::vector<geometry::Rectangle> const display_rects;
 };
 }
 

=== modified file 'include/test/mir_test_framework/testing_server_configuration.h'
--- include/test/mir_test_framework/testing_server_configuration.h	2014-03-06 06:05:17 +0000
+++ include/test/mir_test_framework/testing_server_configuration.h	2014-06-27 09:18:41 +0000
@@ -31,6 +31,7 @@
 {
 public:
     TestingServerConfiguration();
+    explicit TestingServerConfiguration(std::vector<geometry::Rectangle> const& display_rects);
 
     // Code to run in server process
     virtual void exec();

=== modified file 'src/client/android/android_client_buffer.cpp'
--- src/client/android/android_client_buffer.cpp	2014-03-06 06:05:17 +0000
+++ src/client/android/android_client_buffer.cpp	2014-06-27 09:18:41 +0000
@@ -52,7 +52,7 @@
     anwb->usage = GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER;
     anwb->handle = native_handle.get();
 
-    native_window_buffer = std::make_shared<mga::AndroidNativeBuffer>(anwb, fence);
+    native_window_buffer = std::make_shared<mga::AndroidNativeBuffer>(anwb, fence, mga::BufferAccess::read);
 }
 
 mcla::AndroidClientBuffer::~AndroidClientBuffer() noexcept

=== modified file 'src/client/cursor_configuration.h'
--- src/client/cursor_configuration.h	2014-05-14 16:50:03 +0000
+++ src/client/cursor_configuration.h	2014-06-27 09:18:41 +0000
@@ -25,6 +25,8 @@
 // Will grow to include cursors specified by raw RGBA data, hotspots, etc...
 struct MirCursorConfiguration 
 {
+    MirCursorConfiguration(char const* name);
+
     std::string name;
 };
 

=== modified file 'src/client/mir_cursor_api.cpp'
--- src/client/mir_cursor_api.cpp	2014-05-14 16:50:03 +0000
+++ src/client/mir_cursor_api.cpp	2014-06-27 09:18:41 +0000
@@ -19,9 +19,15 @@
 #include "mir_toolkit/mir_cursor_configuration.h"
 #include "cursor_configuration.h"
 
+#include <memory>
+
 char const *const mir_default_cursor_name = "default";
-char const *const mir_disabled_cursor_name = nullptr;
+char const *const mir_disabled_cursor_name = "disabled";
 
+MirCursorConfiguration::MirCursorConfiguration(char const* name) :
+    name{name ? name : std::string()}
+{
+}
 
 void mir_cursor_configuration_destroy(MirCursorConfiguration *cursor)
 {
@@ -32,10 +38,7 @@
 {
     try 
     {
-        auto c = new MirCursorConfiguration;
-        c->name = std::string(name);
-    
-        return c;
+        return new MirCursorConfiguration(name);
     }
     catch (...)
     {

=== modified file 'src/client/mir_surface.cpp'
--- src/client/mir_surface.cpp	2014-06-16 21:41:08 +0000
+++ src/client/mir_surface.cpp	2014-06-27 09:18:41 +0000
@@ -326,7 +326,7 @@
     {
         std::unique_lock<decltype(mutex)> lock(mutex);
         setting.mutable_surfaceid()->CopyFrom(surface.id());
-        if (cursor->name != "")
+        if (cursor && cursor->name != mir_disabled_cursor_name)
             setting.set_name(cursor->name.c_str());
     }
     
@@ -427,12 +427,22 @@
 {
     std::unique_lock<decltype(mutex)> lock(mutex);
 
-    if (e.type == mir_event_type_surface)
+    switch (e.type)
+    {
+    case mir_event_type_surface:
     {
         MirSurfaceAttrib a = e.surface.attrib;
         if (a < mir_surface_attribs)
             attrib_cache[a] = e.surface.value;
+        break;
     }
+    case mir_event_type_orientation:
+        orientation = e.orientation.direction;
+        break;
+
+    default:
+        break;
+    };
 
     if (handle_event_callback)
     {
@@ -459,3 +469,8 @@
 {
     configure(a, value)->wait_for_all();
 }
+
+MirOrientation MirSurface::get_orientation() const
+{
+    return orientation;
+}

=== modified file 'src/client/mir_surface.h'
--- src/client/mir_surface.h	2014-06-05 14:38:50 +0000
+++ src/client/mir_surface.h	2014-06-27 09:18:41 +0000
@@ -87,6 +87,7 @@
 
     MirWaitHandle* configure(MirSurfaceAttrib a, int value);
     int attrib(MirSurfaceAttrib a) const;
+    MirOrientation get_orientation() const;
     
     MirWaitHandle* configure_cursor(MirCursorConfiguration const* cursor);
 
@@ -131,6 +132,7 @@
 
     // Cache of latest SurfaceSettings returned from the server
     int attrib_cache[mir_surface_attribs];
+    MirOrientation orientation = mir_orientation_normal;
 
     std::function<void(MirEvent const*)> handle_event_callback;
     std::shared_ptr<mir::input::receiver::InputReceiverThread> input_thread;

=== modified file 'src/client/mir_surface_api.cpp'
--- src/client/mir_surface_api.cpp	2014-06-12 15:35:08 +0000
+++ src/client/mir_surface_api.cpp	2014-06-27 09:18:41 +0000
@@ -225,6 +225,11 @@
     return state;
 }
 
+MirOrientation mir_surface_get_orientation(MirSurface *surface)
+{
+    return surface->get_orientation();
+}
+
 MirWaitHandle* mir_surface_set_swapinterval(MirSurface* surf, int interval)
 {
     if ((interval < 0) || (interval > 1))

=== modified file 'src/client/rpc/mir_socket_rpc_channel.cpp'
--- src/client/rpc/mir_socket_rpc_channel.cpp	2014-06-12 15:35:08 +0000
+++ src/client/rpc/mir_socket_rpc_channel.cpp	2014-06-27 09:18:41 +0000
@@ -418,24 +418,25 @@
 
                 rpc_report->event_parsing_succeeded(e);
 
-                event_sink->handle_event(e);
-
-                // todo - surfaces should register with the event handler register.
-                if (e.type == mir_event_type_surface)
-                {
-                    surface_map->with_surface_do(e.surface.id,
-                        [&e](MirSurface* surface)
-                        {
-                            surface->handle_event(e);
-                        });
-                }
-                else if (e.type == mir_event_type_resize)
-                {
-                    surface_map->with_surface_do(e.resize.surface_id,
-                        [&e](MirSurface* surface)
-                        {
-                            surface->handle_event(e);
-                        });
+                auto const send_e = [&e](MirSurface* surface)
+                    { surface->handle_event(e); };
+
+                switch (e.type)
+                {
+                case mir_event_type_surface:
+                    surface_map->with_surface_do(e.surface.id, send_e);
+                    break;
+
+                case mir_event_type_resize:
+                    surface_map->with_surface_do(e.resize.surface_id, send_e);
+                    break;
+
+                case mir_event_type_orientation:
+                    surface_map->with_surface_do(e.orientation.surface_id, send_e);
+                    break;
+
+                default:
+                    event_sink->handle_event(e);
                 }
             }
             else

=== modified file 'src/platform/graphics/android/android_alloc_adaptor.cpp'
--- src/platform/graphics/android/android_alloc_adaptor.cpp	2014-03-06 06:05:17 +0000
+++ src/platform/graphics/android/android_alloc_adaptor.cpp	2014-06-27 09:18:41 +0000
@@ -88,7 +88,7 @@
     anwb->format = format;
     anwb->usage = usage_flag;
 
-    return std::make_shared<mga::AndroidNativeBuffer>(anwb, fence);
+    return std::make_shared<mga::AndroidNativeBuffer>(anwb, fence, mga::BufferAccess::read);
 }
 
 int mga::AndroidAllocAdaptor::convert_to_android_usage(BufferUsage usage)

=== modified file 'src/platform/graphics/android/android_platform.cpp'
--- src/platform/graphics/android/android_platform.cpp	2014-06-10 14:40:23 +0000
+++ src/platform/graphics/android/android_platform.cpp	2014-06-27 09:18:41 +0000
@@ -112,24 +112,31 @@
     return std::make_shared<mg::PlatformIPCPackage>();
 }
 
-void mga::AndroidPlatform::fill_ipc_package(BufferIPCPacker* packer, graphics::Buffer const* buffer) const
+void mga::AndroidPlatform::fill_buffer_package(
+    BufferIPCPacker* packer, graphics::Buffer const* buffer, BufferIpcMsgType msg_type) const
 {
     auto native_buffer = buffer->native_buffer_handle();
-    auto buffer_handle = native_buffer->handle();
-
-    int offset = 0;
-
-    for(auto i=0; i<buffer_handle->numFds; i++)
-    {
-        packer->pack_fd(buffer_handle->data[offset++]);
-    }
-    for(auto i=0; i<buffer_handle->numInts; i++)
-    {
-        packer->pack_data(buffer_handle->data[offset++]);
-    }
-
-    packer->pack_stride(buffer->stride());
-    packer->pack_size(buffer->size());
+
+    /* TODO: instead of waiting, pack the fence fd in the message to the client */ 
+    native_buffer->ensure_available_for(mga::BufferAccess::write);
+    if (msg_type == mg::BufferIpcMsgType::full_msg)
+    {
+        auto buffer_handle = native_buffer->handle();
+
+        int offset = 0;
+
+        for(auto i=0; i<buffer_handle->numFds; i++)
+        {
+            packer->pack_fd(buffer_handle->data[offset++]);
+        }
+        for(auto i=0; i<buffer_handle->numInts; i++)
+        {
+            packer->pack_data(buffer_handle->data[offset++]);
+        }
+
+        packer->pack_stride(buffer->stride());
+        packer->pack_size(buffer->size());
+    }
 }
 
 EGLNativeDisplayType mga::AndroidPlatform::egl_native_display() const

=== modified file 'src/platform/graphics/android/android_platform.h'
--- src/platform/graphics/android/android_platform.h	2014-06-02 17:07:02 +0000
+++ src/platform/graphics/android/android_platform.h	2014-06-27 09:18:41 +0000
@@ -49,7 +49,8 @@
         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;
+    void fill_buffer_package(
+        BufferIPCPacker* packer, graphics::Buffer const* buffer, BufferIpcMsgType msg_type) const;
     EGLNativeDisplayType egl_native_display() const;
 
 private:

=== modified file 'src/platform/graphics/android/buffer.cpp'
--- src/platform/graphics/android/buffer.cpp	2014-05-01 08:11:50 +0000
+++ src/platform/graphics/android/buffer.cpp	2014-06-27 09:18:41 +0000
@@ -76,7 +76,7 @@
 void mga::Buffer::gl_bind_to_texture()
 {
     std::unique_lock<std::mutex> lk(content_lock);
-    native_buffer->wait_for_content();
+    native_buffer->ensure_available_for(mga::BufferAccess::read);
 
     DispContextPair current
     {

=== modified file 'src/platform/graphics/android/fb_device.cpp'
--- src/platform/graphics/android/fb_device.cpp	2014-06-16 14:47:14 +0000
+++ src/platform/graphics/android/fb_device.cpp	2014-06-27 09:18:41 +0000
@@ -49,7 +49,7 @@
     context.swap_buffers();
     auto const& buffer = context.last_rendered_buffer();
     auto native_buffer = buffer->native_buffer_handle();
-    native_buffer->wait_for_content();
+    native_buffer->ensure_available_for(mga::BufferAccess::read);
     if (fb_device->post(fb_device.get(), native_buffer->handle()) != 0)
     {
         BOOST_THROW_EXCEPTION(std::runtime_error("error posting with fb device"));

=== modified file 'src/platform/graphics/android/hwc_device.cpp'
--- src/platform/graphics/android/hwc_device.cpp	2014-06-16 14:47:14 +0000
+++ src/platform/graphics/android/hwc_device.cpp	2014-06-27 09:18:41 +0000
@@ -25,6 +25,7 @@
 #include "framebuffer_bundle.h"
 #include "buffer.h"
 #include "hwc_fallback_gl_renderer.h"
+#include <limits>
 
 namespace mg = mir::graphics;
 namespace mga=mir::graphics::android;
@@ -34,6 +35,16 @@
 {
 static const size_t fbtarget_plus_skip_size = 2;
 static const size_t fbtarget_size = 1;
+
+bool plane_alpha_is_translucent(mg::Renderable const& renderable)
+{
+    float static const tolerance
+    {
+        1.0f/(2.0 * static_cast<float>(std::numeric_limits<decltype(hwc_layer_1_t::planeAlpha)>::max()))
+    };
+    return renderable.alpha_enabled() && (renderable.alpha() < 1.0f - tolerance);
+}
+
 bool renderable_list_is_hwc_incompatible(mg::RenderableList const& list)
 {
     if (list.empty())
@@ -41,11 +52,10 @@
 
     for(auto const& renderable : list)
     {
-        //TODO: enable alpha, 90 deg rotation
+        //TODO: enable planeAlpha for (hwc version >= 1.2), 90 deg rotation
         static glm::mat4 const identity;
-        if (renderable->shaped() ||
-            renderable->alpha_enabled() ||
-            (renderable->transformation() != identity))
+        if (plane_alpha_is_translucent(*renderable) ||
+           (renderable->transformation() != identity))
         {
             return true;
         }

=== modified file 'src/platform/graphics/android/hwc_fallback_gl_renderer.cpp'
--- src/platform/graphics/android/hwc_fallback_gl_renderer.cpp	2014-06-09 16:01:59 +0000
+++ src/platform/graphics/android/hwc_fallback_gl_renderer.cpp	2014-06-27 09:18:41 +0000
@@ -105,12 +105,17 @@
 
     glClearColor(0.0, 0.0, 0.0, 1.0);
     glClear(GL_COLOR_BUFFER_BIT);
-    
+    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
     glEnableVertexAttribArray(position_attr);
     glEnableVertexAttribArray(texcoord_attr);
 
     for(auto const& renderable : renderlist)
     {
+        if (renderable->alpha_enabled())
+            glEnable(GL_BLEND);
+        else
+            glDisable(GL_BLEND);
+
         auto const primitive = mg::tessellate_renderable_into_rectangle(*renderable);
         glVertexAttribPointer(position_attr, 3, GL_FLOAT, GL_FALSE, sizeof(mg::GLVertex),
                               &primitive.vertices[0].position);

=== modified file 'src/platform/graphics/android/hwc_fb_device.cpp'
--- src/platform/graphics/android/hwc_fb_device.cpp	2014-06-16 14:47:14 +0000
+++ src/platform/graphics/android/hwc_fb_device.cpp	2014-06-27 09:18:41 +0000
@@ -70,7 +70,7 @@
 
     auto const& buffer = context.last_rendered_buffer();
     auto native_buffer = buffer->native_buffer_handle();
-    native_buffer->wait_for_content();
+    native_buffer->ensure_available_for(mga::BufferAccess::read);
     if (fb_device->post(fb_device.get(), native_buffer->handle()) != 0)
     {
         BOOST_THROW_EXCEPTION(std::runtime_error("error posting with fb device"));

=== modified file 'src/platform/graphics/android/hwc_layers.cpp'
--- src/platform/graphics/android/hwc_layers.cpp	2014-06-04 22:41:05 +0000
+++ src/platform/graphics/android/hwc_layers.cpp	2014-06-27 09:18:41 +0000
@@ -22,6 +22,7 @@
 #include "mir/graphics/android/native_buffer.h"
 #include "hwc_layerlist.h"
 
+#include <limits>
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
 #include <cstring>
@@ -30,6 +31,13 @@
 namespace mga=mir::graphics::android;
 namespace geom=mir::geometry;
 
+namespace
+{
+decltype(hwc_layer_1_t::planeAlpha) static const plane_alpha_max{
+    std::numeric_limits<decltype(hwc_layer_1_t::planeAlpha)>::max()
+};
+}
+
 mga::HWCLayer& mga::HWCLayer::operator=(HWCLayer && other)
 {
     hwc_layer = other.hwc_layer;
@@ -58,6 +66,7 @@
     hwc_layer->acquireFenceFd = -1;
     hwc_layer->releaseFenceFd = -1;
     hwc_layer->blending = HWC_BLENDING_NONE;
+    hwc_layer->planeAlpha = plane_alpha_max;
 
     hwc_layer->visibleRegionScreen.numRects=1;
     hwc_layer->visibleRegionScreen.rects= &visible_rect;
@@ -84,7 +93,7 @@
 {
     if (hwc_layer->compositionType != HWC_FRAMEBUFFER)
     { 
-        associated_buffer->update_fence(hwc_layer->releaseFenceFd);
+        associated_buffer->update_usage(hwc_layer->releaseFenceFd, mga::BufferAccess::read);
         hwc_layer->releaseFenceFd = -1;
         hwc_layer->acquireFenceFd = -1;
         associated_buffer.reset();
@@ -118,10 +127,12 @@
 void mga::HWCLayer::set_render_parameters(geometry::Rectangle position, bool alpha_enabled)
 {
     if (alpha_enabled)
-        hwc_layer->blending = HWC_BLENDING_COVERAGE;
+        hwc_layer->blending = HWC_BLENDING_PREMULT;
     else
         hwc_layer->blending = HWC_BLENDING_NONE;
 
+    hwc_layer->planeAlpha = plane_alpha_max;
+
     /* note, if the sourceCrop and DisplayFrame sizes differ, the output will be linearly scaled */
     hwc_layer->displayFrame = 
     {

=== modified file 'src/platform/graphics/android/internal_client_window.cpp'
--- src/platform/graphics/android/internal_client_window.cpp	2014-04-15 05:31:19 +0000
+++ src/platform/graphics/android/internal_client_window.cpp	2014-06-27 09:18:41 +0000
@@ -65,7 +65,7 @@
     buffer = it->second.buffer;
     lookup.erase(it);
 
-    handle->update_fence(fence_fd);
+    handle->update_usage(fence_fd, mga::BufferAccess::write);
     surface->swap_buffers(buffer);
 }
 

=== modified file 'src/platform/graphics/android/interpreter_cache.cpp'
--- src/platform/graphics/android/interpreter_cache.cpp	2014-03-06 06:05:17 +0000
+++ src/platform/graphics/android/interpreter_cache.cpp	2014-06-27 09:18:41 +0000
@@ -58,5 +58,5 @@
     }
 
     auto native_buffer = native_it->second;
-    native_buffer->update_fence(fence);
+    native_buffer->update_usage(fence, mga::BufferAccess::write);
 }

=== modified file 'src/platform/graphics/mesa/display.cpp'
--- src/platform/graphics/mesa/display.cpp	2014-06-10 14:40:23 +0000
+++ src/platform/graphics/mesa/display.cpp	2014-06-27 09:18:41 +0000
@@ -233,6 +233,7 @@
 {
     handlers.register_fd_handler(
         {monitor.fd()},
+        this,
         [conf_change_handler, this](int)
         {
             monitor.process_events([conf_change_handler]

=== modified file 'src/platform/graphics/mesa/native_platform.cpp'
--- src/platform/graphics/mesa/native_platform.cpp	2014-06-02 17:07:02 +0000
+++ src/platform/graphics/mesa/native_platform.cpp	2014-06-27 09:18:41 +0000
@@ -97,21 +97,26 @@
     return std::make_shared<mgm::InternalClient>(nd);
 }
 
-void mgm::NativePlatform::fill_ipc_package(BufferIPCPacker* packer, Buffer const* buffer) const
+/* TODO : this is just a duplication of mgm::Platform::fill_buffer_package */
+void mgm::NativePlatform::fill_buffer_package(
+    BufferIPCPacker* packer, Buffer const* buffer, BufferIpcMsgType msg_type) const
 {
-    auto native_handle = buffer->native_buffer_handle();
-    for(auto i=0; i<native_handle->data_items; i++)
-    {
-        packer->pack_data(native_handle->data[i]);
-    }
-    for(auto i=0; i<native_handle->fd_items; i++)
-    {
-        packer->pack_fd(native_handle->fd[i]);
-    }
+    if (msg_type == mg::BufferIpcMsgType::full_msg)
+    {
+        auto native_handle = buffer->native_buffer_handle();
+        for(auto i=0; i<native_handle->data_items; i++)
+        {
+            packer->pack_data(native_handle->data[i]);
+        }
+        for(auto i=0; i<native_handle->fd_items; i++)
+        {
+            packer->pack_fd(native_handle->fd[i]);
+        }
 
-    packer->pack_stride(buffer->stride());
-    packer->pack_flags(native_handle->flags);
-    packer->pack_size(buffer->size());
+        packer->pack_stride(buffer->stride());
+        packer->pack_flags(native_handle->flags);
+        packer->pack_size(buffer->size());
+    }
 }
 
 extern "C" std::shared_ptr<mg::NativePlatform> create_native_platform(std::shared_ptr<mg::DisplayReport> const& /*report*/)

=== modified file 'src/platform/graphics/mesa/native_platform.h'
--- src/platform/graphics/mesa/native_platform.h	2014-03-12 02:46:58 +0000
+++ src/platform/graphics/mesa/native_platform.h	2014-06-27 09:18:41 +0000
@@ -42,7 +42,8 @@
         std::shared_ptr<BufferInitializer> const& buffer_initializer) override;
     std::shared_ptr<PlatformIPCPackage> get_ipc_package() override;
     std::shared_ptr<InternalClient> create_internal_client() override;
-    void fill_ipc_package(BufferIPCPacker* packer, Buffer const* buffer) const override;
+    void fill_buffer_package(
+        BufferIPCPacker* packer, Buffer const* buffer, BufferIpcMsgType msg_type) const override;
     
     static std::shared_ptr<InternalNativeDisplay> internal_native_display();
     static bool internal_native_display_in_use();

=== modified file 'src/platform/graphics/mesa/platform.cpp'
--- src/platform/graphics/mesa/platform.cpp	2014-06-10 14:40:23 +0000
+++ src/platform/graphics/mesa/platform.cpp	2014-06-27 09:18:41 +0000
@@ -182,21 +182,25 @@
     return std::make_shared<MesaPlatformIPCPackage>(drm->get_authenticated_fd());
 }
 
-void mgm::Platform::fill_ipc_package(BufferIPCPacker* packer, Buffer const* buffer) const
+void mgm::Platform::fill_buffer_package(
+    BufferIPCPacker* packer, Buffer const* buffer, BufferIpcMsgType msg_type) const
 {
-    auto native_handle = buffer->native_buffer_handle();
-    for(auto i=0; i<native_handle->data_items; i++)
-    {
-        packer->pack_data(native_handle->data[i]);
-    }
-    for(auto i=0; i<native_handle->fd_items; i++)
-    {
-        packer->pack_fd(native_handle->fd[i]);
-    }
+    if (msg_type == mg::BufferIpcMsgType::full_msg)
+    {
+        auto native_handle = buffer->native_buffer_handle();
+        for(auto i=0; i<native_handle->data_items; i++)
+        {
+            packer->pack_data(native_handle->data[i]);
+        }
+        for(auto i=0; i<native_handle->fd_items; i++)
+        {
+            packer->pack_fd(native_handle->fd[i]);
+        }
 
-    packer->pack_stride(buffer->stride());
-    packer->pack_flags(native_handle->flags);
-    packer->pack_size(buffer->size());
+        packer->pack_stride(buffer->stride());
+        packer->pack_flags(native_handle->flags);
+        packer->pack_size(buffer->size());
+    }
 }
 
 void mgm::Platform::drm_auth_magic(unsigned int magic)

=== modified file 'src/platform/graphics/mesa/platform.h'
--- src/platform/graphics/mesa/platform.h	2014-06-10 14:40:23 +0000
+++ src/platform/graphics/mesa/platform.h	2014-06-27 09:18:41 +0000
@@ -61,7 +61,8 @@
     std::shared_ptr<PlatformIPCPackage> get_ipc_package();
     std::shared_ptr<InternalClient> create_internal_client();
 
-    void fill_ipc_package(BufferIPCPacker* packer, Buffer const* buffer) const;
+    void fill_buffer_package(
+        BufferIPCPacker* packer, Buffer const* buffer, BufferIpcMsgType msg_type) const;
 
     EGLNativeDisplayType egl_native_display() const;
 

=== modified file 'src/server/asio_main_loop.cpp'
--- src/server/asio_main_loop.cpp	2014-06-12 15:35:08 +0000
+++ src/server/asio_main_loop.cpp	2014-06-27 09:18:41 +0000
@@ -26,6 +26,37 @@
 
 namespace
 {
+
+void synchronous_server_action(
+    mir::ServerActionQueue& queue,
+    boost::optional<std::thread::id> queue_thread_id,
+    mir::ServerAction const& action)
+{
+    if (!queue_thread_id || *queue_thread_id == std::this_thread::get_id())
+    {
+        try { action(); } catch(...) {}
+    }
+    else
+    {
+        std::mutex done_mutex;
+        bool done{false};
+        std::condition_variable done_condition;
+
+        queue.enqueue(&queue, [&]
+            {
+                std::lock_guard<std::mutex> lock(done_mutex);
+
+                try { action(); } catch(...) {}
+
+                done = true;
+                done_condition.notify_one();
+            });
+
+        std::unique_lock<std::mutex> lock(done_mutex);
+        done_condition.wait(lock, [&] { return done; });
+    }
+}
+
 struct MirClockTimerTraits
 {
     // TODO the clock used by the main loop is a global setting, this is a restriction
@@ -139,8 +170,9 @@
 public:
     FDHandler(boost::asio::io_service& io,
               std::initializer_list<int> fds,
+              void const* owner,
               std::function<void(int)> const& handler)
-        : handler{handler}
+        : handler{handler}, owner{owner}
     {
         for (auto fd : fds)
         {
@@ -150,33 +182,52 @@
         }
     }
 
-    void async_wait()
-    {
-        for (auto const& s : stream_descriptors)
-        {
-            s->async_read_some(
-                boost::asio::null_buffers(),
-                std::bind(&FDHandler::handle, this,
-                          std::placeholders::_1, std::placeholders::_2, s.get()));
-        }
+    bool is_owned_by(void const* possible_owner) const
+    {
+        return owner == possible_owner;
+    }
+
+    static void async_wait(std::shared_ptr<FDHandler> const& fd_handler, ServerActionQueue& queue)
+    {
+        for (auto const& s : fd_handler->stream_descriptors)
+            read_some(s.get(), fd_handler, queue);
     }
 
 private:
-    void handle(boost::system::error_code err, size_t /*bytes*/,
-                boost::asio::posix::stream_descriptor* s)
+    static void read_some(boost::asio::posix::stream_descriptor* s, std::weak_ptr<FDHandler> const& possible_fd_handler, ServerActionQueue& queue)
     {
-        if (!err)
-        {
-            handler(s->native_handle());
-            s->async_read_some(
-                boost::asio::null_buffers(),
-                std::bind(&FDHandler::handle, this,
-                          std::placeholders::_1, std::placeholders::_2, s));
-        }
+        s->async_read_some(
+            boost::asio::null_buffers(),
+            [possible_fd_handler,s,&queue](boost::system::error_code err, size_t /*bytes*/)
+            {
+                if (err)
+                    return;
+
+                // The actual execution of the fd handler is moved to the action queue.This allows us to synchronously
+                // unregister FDHandlers even when they are about to be executed. We do this because of the way Asio
+                // copies and executes pending completion handlers.
+                // In worst case during the call to unregister the FDHandler, it may still be executed, but not after
+                // the unregister call returned.
+                queue.enqueue(
+                    s,
+                    [possible_fd_handler, s, &queue]()
+                    {
+                        auto fd_handler = possible_fd_handler.lock();
+                        if (!fd_handler)
+                            return;
+
+                        fd_handler->handler(s->native_handle());
+                        fd_handler.reset();
+
+                        if (possible_fd_handler.lock())
+                            read_some(s, possible_fd_handler, queue);
+                    });
+            });
     }
 
     std::vector<std::unique_ptr<boost::asio::posix::stream_descriptor>> stream_descriptors;
     std::function<void(int)> handler;
+    void const* owner;
 };
 
 /*
@@ -198,12 +249,14 @@
 
 void mir::AsioMainLoop::run()
 {
+    main_loop_thread = std::this_thread::get_id();
     io.run();
 }
 
 void mir::AsioMainLoop::stop()
 {
     io.stop();
+    main_loop_thread.reset();
 }
 
 void mir::AsioMainLoop::register_signal_handler(
@@ -222,18 +275,43 @@
 
 void mir::AsioMainLoop::register_fd_handler(
     std::initializer_list<int> fds,
+    void const* owner,
     std::function<void(int)> const& handler)
 {
     assert(handler);
 
-    auto fd_handler = std::unique_ptr<FDHandler>{
-        new FDHandler{io, fds, handler}};
-
-    fd_handler->async_wait();
-
+    auto fd_handler = std::make_shared<FDHandler>(io, fds, owner, handler);
+
+    FDHandler::async_wait(fd_handler, *this);
+
+    std::lock_guard<std::mutex> lock(fd_handlers_mutex);
     fd_handlers.push_back(std::move(fd_handler));
 }
 
+void mir::AsioMainLoop::unregister_fd_handler(void const* owner)
+{
+    // synchronous_server_action makes sure that with the
+    // completion of the method unregister_fd_handler the
+    // handler will no longer be called.
+    // There is a chance for a fd handler callback to happen before
+    // the completion of this method.
+    synchronous_server_action(
+        *this,
+        main_loop_thread,
+        [this,owner]()
+        {
+            std::lock_guard<std::mutex> lock(fd_handlers_mutex);
+            auto end_of_valid = remove_if(
+                begin(fd_handlers),
+                end(fd_handlers),
+                [owner](std::shared_ptr<FDHandler> const& item)
+                {
+                    return item->is_owned_by(owner);
+                });
+            fd_handlers.erase(end_of_valid, end(fd_handlers));
+        });
+}
+
 namespace
 {
 class AlarmImpl : public mir::time::Alarm
@@ -266,15 +344,42 @@
         {
         }
 
-        mutable std::mutex m;
-        std::function<void(void)> callback;
+        std::recursive_mutex m;
+        std::function<void(void)> const callback;
         State state;
     };
 
     ::deadline_timer timer;
-    std::shared_ptr<InternalState> data;
+    std::shared_ptr<InternalState> const data;
+    std::function<void(boost::system::error_code const& ec)> const handler;
+
+    friend auto make_handler(std::weak_ptr<InternalState> possible_data)
+    -> std::function<void(boost::system::error_code const& ec)>;
 };
 
+auto make_handler(std::weak_ptr<AlarmImpl::InternalState> possible_data)
+-> std::function<void(boost::system::error_code const& ec)>
+{
+    // Awkwardly, we can't stop the async_wait handler from being called
+    // on a destroyed AlarmImpl. This means we need to wedge a weak_ptr
+    // into the async_wait callback.
+    return [possible_data](boost::system::error_code const& ec)
+    {
+        if (!ec)
+        {
+            if (auto data = possible_data.lock())
+            {
+                std::unique_lock<decltype(data->m)> lock(data->m);
+                if (data->state == mir::time::Alarm::pending)
+                {
+                    data->state = mir::time::Alarm::triggered;
+                    data->callback();
+                }
+            }
+        }
+    };
+}
+
 AlarmImpl::AlarmImpl(boost::asio::io_service& io,
                      std::chrono::milliseconds delay,
                      std::function<void ()> callback)
@@ -294,7 +399,8 @@
 AlarmImpl::AlarmImpl(boost::asio::io_service& io,
                      std::function<void(void)> callback)
     : timer{io},
-      data{std::make_shared<InternalState>(callback)}
+      data{std::make_shared<InternalState>(callback)},
+      handler{make_handler(data)}
 {
     data->state = triggered;
 }
@@ -338,25 +444,8 @@
 
 void AlarmImpl::update_timer()
 {
+    timer.async_wait(handler);
     std::lock_guard<decltype(data->m)> lock(data->m);
-    // Awkwardly, we can't stop the async_wait handler from being called
-    // on a destroyed AlarmImpl. This means we need to wedge a shared_ptr
-    // into the async_wait callback.
-    std::weak_ptr<InternalState> possible_data = data;
-    timer.async_wait([possible_data](boost::system::error_code const& ec)
-    {
-        auto data = possible_data.lock();
-        if (!data)
-            return;
-
-        std::unique_lock<decltype(data->m)> lock(data->m);
-        if (!ec && data->state == pending)
-        {
-            data->state = triggered;
-            lock.unlock();
-            data->callback();
-        }
-    });
     data->state = pending;
 }
 }

=== modified file 'src/server/compositor/default_display_buffer_compositor.cpp'
--- src/server/compositor/default_display_buffer_compositor.cpp	2014-06-10 18:40:05 +0000
+++ src/server/compositor/default_display_buffer_compositor.cpp	2014-06-27 09:18:41 +0000
@@ -20,6 +20,7 @@
 #include "default_display_buffer_compositor.h"
 
 #include "mir/compositor/scene.h"
+#include "mir/compositor/scene_element.h"
 #include "mir/compositor/renderer.h"
 #include "mir/graphics/renderable.h"
 #include "mir/graphics/display_buffer.h"
@@ -43,6 +44,12 @@
       renderer{renderer},
       report{report}
 {
+    scene->register_compositor(this);
+}
+
+mc::DefaultDisplayBufferCompositor::~DefaultDisplayBufferCompositor()
+{
+    scene->unregister_compositor(this);
 }
 
 void mc::DefaultDisplayBufferCompositor::composite()
@@ -50,8 +57,21 @@
     report->began_frame(this);
 
     auto const& view_area = display_buffer.view_area();
-    auto renderable_list = scene->renderable_list_for(this);
-    mc::filter_occlusions_from(renderable_list, view_area);
+    auto scene_elements = scene->scene_elements_for(this);
+    auto const& occlusions = mc::filter_occlusions_from(scene_elements, view_area);
+
+    for (auto const& element : occlusions)
+    {
+        if (element->renderable()->visible())
+            element->occluded_in(this);
+    }
+
+    mg::RenderableList renderable_list;
+    for (auto const& element : scene_elements)
+    {
+        element->rendered_in(this);
+        renderable_list.push_back(element->renderable());
+    }
 
     if (display_buffer.post_renderables_if_optimizable(renderable_list))
     {

=== modified file 'src/server/compositor/default_display_buffer_compositor.h'
--- src/server/compositor/default_display_buffer_compositor.h	2014-06-10 18:40:05 +0000
+++ src/server/compositor/default_display_buffer_compositor.h	2014-06-27 09:18:41 +0000
@@ -43,6 +43,7 @@
         std::shared_ptr<Scene> const& scene,
         std::shared_ptr<Renderer> const& renderer,
         std::shared_ptr<CompositorReport> const& report);
+    ~DefaultDisplayBufferCompositor();
 
     void composite() override;
 

=== modified file 'src/server/compositor/occlusion.cpp'
--- src/server/compositor/occlusion.cpp	2014-04-17 01:34:35 +0000
+++ src/server/compositor/occlusion.cpp	2014-06-27 09:18:41 +0000
@@ -17,11 +17,15 @@
  */
 
 #include "mir/geometry/rectangle.h"
+#include "mir/compositor/scene_element.h"
 #include "mir/graphics/renderable.h"
 #include "occlusion.h"
 
+#include <vector>
+
 using namespace mir::geometry;
 using namespace mir::graphics;
+using namespace mir::compositor;
 
 namespace
 {
@@ -62,17 +66,27 @@
 }
 }
 
-void mir::compositor::filter_occlusions_from(
-    RenderableList& list,
+SceneElementSequence mir::compositor::filter_occlusions_from(
+    SceneElementSequence& elements,
     Rectangle const& area)
 {
+    SceneElementSequence occluded;
     std::vector<Rectangle> coverage;
-    auto it = list.rbegin();
-    while (it != list.rend())
+
+    auto it = elements.rbegin();
+    while (it != elements.rend())
     {
-        if (renderable_is_occluded(**it, area, coverage))
-            list.erase(std::prev(it.base()));
+        auto const renderable = (*it)->renderable();
+        if (renderable_is_occluded(*renderable, area, coverage))
+        {
+            occluded.insert(occluded.begin(), *it);
+            it = SceneElementSequence::reverse_iterator(elements.erase(std::prev(it.base())));
+        }
         else
+        {
             it++;
+        }
     }
+
+    return occluded;
 }

=== modified file 'src/server/compositor/occlusion.h'
--- src/server/compositor/occlusion.h	2014-03-26 16:59:32 +0000
+++ src/server/compositor/occlusion.h	2014-06-27 09:18:41 +0000
@@ -19,17 +19,14 @@
 #ifndef MIR_COMPOSITOR_OCCLUSION_H_
 #define MIR_COMPOSITOR_OCCLUSION_H_
 
-#include "mir/graphics/renderable.h"
 #include "mir/compositor/scene.h"
-#include <vector>
-#include <set>
 
 namespace mir
 {
 namespace compositor
 {
 
-void filter_occlusions_from(graphics::RenderableList& list, geometry::Rectangle const& area);
+SceneElementSequence filter_occlusions_from(SceneElementSequence& list, geometry::Rectangle const& area);
 
 } // namespace compositor
 } // namespace mir

=== modified file 'src/server/compositor/timeout_frame_dropping_policy_factory.cpp'
--- src/server/compositor/timeout_frame_dropping_policy_factory.cpp	2014-05-22 20:48:20 +0000
+++ src/server/compositor/timeout_frame_dropping_policy_factory.cpp	2014-06-27 09:18:41 +0000
@@ -41,7 +41,7 @@
 
 private:
     std::chrono::milliseconds const timeout;
-    std::unique_ptr<mir::time::Alarm> alarm;
+    std::unique_ptr<mir::time::Alarm> const alarm;
     std::atomic<unsigned int> pending_swaps;
 };
 
@@ -49,15 +49,15 @@
                                                        std::chrono::milliseconds timeout,
                                                        std::function<void(void)> drop_frame)
     : timeout{timeout},
+      alarm{timer->create_alarm([this, drop_frame]
+        {
+            assert(pending_swaps.load() > 0);
+            drop_frame();
+            if (--pending_swaps > 0)
+                alarm->reschedule_in(this->timeout);
+        })},
       pending_swaps{0}
 {
-    alarm = timer->create_alarm([this, drop_frame]
-    {
-       assert(pending_swaps.load() > 0);
-       drop_frame();
-       if (--pending_swaps > 0)
-           alarm->reschedule_in(this->timeout);
-    });
 }
 
 void TimeoutFrameDroppingPolicy::swap_now_blocking()

=== modified file 'src/server/default_server_configuration.cpp'
--- src/server/default_server_configuration.cpp	2014-06-11 16:11:32 +0000
+++ src/server/default_server_configuration.cpp	2014-06-27 09:18:41 +0000
@@ -101,30 +101,6 @@
         });
 }
 
-std::shared_ptr<mi::CursorListener>
-mir::DefaultServerConfiguration::the_cursor_listener()
-{
-    struct DefaultCursorListener : mi::CursorListener
-    {
-        DefaultCursorListener(std::shared_ptr<mg::Cursor> const& cursor) :
-            cursor(cursor)
-        {
-        }
-
-        void cursor_moved_to(float abs_x, float abs_y)
-        {
-            cursor->move_to(geom::Point{abs_x, abs_y});
-        }
-
-        std::shared_ptr<mg::Cursor> const cursor;
-    };
-    return cursor_listener(
-        [this]() -> std::shared_ptr<mi::CursorListener>
-        {
-            return std::make_shared<DefaultCursorListener>(the_cursor());
-        });
-}
-
 std::shared_ptr<ms::SurfaceConfigurator> mir::DefaultServerConfiguration::the_surface_configurator()
 {
     struct DefaultSurfaceConfigurator : public ms::SurfaceConfigurator

=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2014-06-12 10:06:11 +0000
+++ src/server/frontend/session_mediator.cpp	2014-06-27 09:18:41 +0000
@@ -32,7 +32,6 @@
 #include "mir/graphics/cursor_images.h"
 #include "mir/compositor/buffer_stream.h"
 #include "mir/geometry/dimensions.h"
-#include "mir/graphics/platform.h"
 #include "mir/frontend/display_changer.h"
 #include "mir/graphics/display_configuration.h"
 #include "mir/graphics/pixel_format_utils.h"
@@ -139,7 +138,7 @@
 void mf::SessionMediator::advance_buffer(
     SurfaceId surf_id,
     Surface& surface,
-    std::function<void(graphics::Buffer*, bool)> complete)
+    std::function<void(graphics::Buffer*, graphics::BufferIpcMsgType)> complete)
 {
     auto& tracker = client_buffer_tracker[surf_id];
     if (!tracker) tracker = std::make_shared<ClientBufferTracker>(client_buffer_cache_size);
@@ -148,12 +147,17 @@
     surface.swap_buffers(client_buffer,
         [&tracker, &client_buffer, complete](mg::Buffer* new_buffer)
         {
+
             client_buffer = new_buffer;
             auto id = client_buffer->id();
             auto need_full_ipc = !tracker->client_has(id);
+            
             tracker->add(id);
 
-            complete(client_buffer, need_full_ipc);
+            if (need_full_ipc)
+                complete(client_buffer, mg::BufferIpcMsgType::full_msg);
+            else
+                complete(client_buffer, mg::BufferIpcMsgType::update_msg);
         });
 }
 
@@ -193,12 +197,13 @@
         response->add_fd(surface->client_input_fd());
 
     advance_buffer(surf_id, *surface,
-        [lock, this, response, done, session](graphics::Buffer* client_buffer, bool need_full_ipc)
+        [lock, this, response, done, session]
+        (graphics::Buffer* client_buffer, graphics::BufferIpcMsgType msg_type)
         {
             lock->unlock();
 
             auto buffer = response->mutable_buffer();
-            pack_protobuf_buffer(*buffer, client_buffer, need_full_ipc);
+            pack_protobuf_buffer(*buffer, client_buffer, msg_type);
 
             // TODO: NOTE: We use the ordering here to ensure the shell acts on the surface after the surface ID is sent over the wire.
             // This guarantees that notifications such as, gained focus, etc, can be correctly interpreted by the client.
@@ -229,11 +234,12 @@
     auto surface = session->get_surface(surf_id);
 
     advance_buffer(surf_id, *surface,
-        [lock, this, response, done, session](graphics::Buffer* client_buffer, bool need_full_ipc)
+        [lock, this, response, done, session]
+        (graphics::Buffer* client_buffer, graphics::BufferIpcMsgType msg_type)
         {
             lock->unlock();
 
-            pack_protobuf_buffer(*response, client_buffer, need_full_ipc);
+            pack_protobuf_buffer(*response, client_buffer, msg_type);
 
             done->Run();
         });
@@ -373,7 +379,7 @@
     mir::protobuf::Screencast* protobuf_screencast,
     google::protobuf::Closure* done)
 {
-    static bool const need_full_ipc{true};
+    static auto const msg_type = mg::BufferIpcMsgType::full_msg;
 
     geom::Rectangle const region{
         {parameters->region().left(), parameters->region().top()},
@@ -389,7 +395,7 @@
         screencast_session_id.as_value());
     pack_protobuf_buffer(*protobuf_screencast->mutable_buffer(),
                          buffer.get(),
-                         need_full_ipc);
+                         msg_type);
 
     done->Run();
 }
@@ -412,7 +418,7 @@
     mir::protobuf::Buffer* protobuf_buffer,
     google::protobuf::Closure* done)
 {
-    static bool const does_not_need_full_ipc{false};
+    static auto const msg_type = mg::BufferIpcMsgType::update_msg;
     ScreencastSessionId const screencast_session_id{
         protobuf_screencast_id->value()};
 
@@ -420,7 +426,7 @@
 
     pack_protobuf_buffer(*protobuf_buffer,
                          buffer.get(),
-                         does_not_need_full_ipc);
+                         msg_type);
 
     done->Run();
 }
@@ -619,13 +625,10 @@
 void mf::SessionMediator::pack_protobuf_buffer(
     protobuf::Buffer& protobuf_buffer,
     graphics::Buffer* graphics_buffer,
-    bool need_full_ipc)
+    mg::BufferIpcMsgType buffer_msg_type)
 {
     protobuf_buffer.set_buffer_id(graphics_buffer->id().as_uint32_t());
 
-    if (need_full_ipc)
-    {
-        mfd::ProtobufBufferPacker packer{&protobuf_buffer};
-        graphics_platform->fill_ipc_package(&packer, graphics_buffer);
-    }
+    mfd::ProtobufBufferPacker packer{&protobuf_buffer};
+    graphics_platform->fill_buffer_package(&packer, graphics_buffer, buffer_msg_type);
 }

=== modified file 'src/server/frontend/session_mediator.h'
--- src/server/frontend/session_mediator.h	2014-06-13 15:20:50 +0000
+++ src/server/frontend/session_mediator.h	2014-06-27 09:18:41 +0000
@@ -22,6 +22,7 @@
 #include "display_server.h"
 #include "mir/frontend/connection_context.h"
 #include "mir/frontend/surface_id.h"
+#include "mir/graphics/platform.h"
 #include "mir_toolkit/common.h"
 
 #include <functional>
@@ -164,9 +165,12 @@
 private:
     void pack_protobuf_buffer(protobuf::Buffer& protobuf_buffer,
                               graphics::Buffer* graphics_buffer,
-                              bool need_full_ipc);
+                              graphics::BufferIpcMsgType msg_type);
 
-    void advance_buffer(SurfaceId surf_id, Surface& surface, std::function<void(graphics::Buffer*, bool)> complete);
+    void advance_buffer(
+        SurfaceId surf_id,
+        Surface& surface,
+        std::function<void(graphics::Buffer*, graphics::BufferIpcMsgType)> complete);
 
     virtual std::function<void(std::shared_ptr<Session> const&)> prompt_session_connect_handler() const;
 

=== modified file 'src/server/graphics/default_configuration.cpp'
--- src/server/graphics/default_configuration.cpp	2014-06-10 14:40:23 +0000
+++ src/server/graphics/default_configuration.cpp	2014-06-27 09:18:41 +0000
@@ -27,6 +27,7 @@
 
 #include "mir/graphics/buffer_initializer.h"
 #include "mir/graphics/gl_config.h"
+#include "mir/graphics/cursor.h"
 #include "program_factory.h"
 
 #include "mir/shared_library.h"
@@ -34,6 +35,8 @@
 #include "mir/abnormal_exit.h"
 #include "mir/emergency_cleanup.h"
 
+#include "mir_toolkit/common.h"
+
 #include <boost/throw_exception.hpp>
 
 #include "builtin_cursor_images.h"
@@ -122,11 +125,23 @@
 std::shared_ptr<mg::Cursor>
 mir::DefaultServerConfiguration::the_cursor()
 {
+    struct NullCursor : public mg::Cursor
+    {
+        void show(mg::CursorImage const&) {}
+        void hide() {}
+        void move_to(geometry::Point) {}
+    };
     return cursor(
         [this]() -> std::shared_ptr<mg::Cursor>
         {
-            // For now we only support a hardware cursor.
-            return the_display()->create_hardware_cursor(the_default_cursor_image());
+            // We try to create a hardware cursor, as we have no software 
+            // cursor currently, if this fails we need to return
+            // a valid cursor object.
+            auto hardware_cursor = the_display()->create_hardware_cursor(the_default_cursor_image());
+            if (hardware_cursor)
+                return hardware_cursor;
+            else
+                return std::make_shared<NullCursor>();
         });
 }
 
@@ -138,7 +153,7 @@
     return default_cursor_image(
         [this]()
         {
-            return the_cursor_images()->image("arrow", default_cursor_size);
+            return the_cursor_images()->image(mir_default_cursor_name, default_cursor_size);
         });
 }
 

=== modified file 'src/server/graphics/nested/nested_platform.cpp'
--- src/server/graphics/nested/nested_platform.cpp	2014-06-02 17:07:02 +0000
+++ src/server/graphics/nested/nested_platform.cpp	2014-06-27 09:18:41 +0000
@@ -99,9 +99,10 @@
     return native_platform->create_internal_client();
 }
 
-void mgn::NestedPlatform::fill_ipc_package(BufferIPCPacker* packer, Buffer const* buffer) const
+void mgn::NestedPlatform::fill_buffer_package(
+    BufferIPCPacker* packer, Buffer const* buffer, BufferIpcMsgType msg_type) const
 {
-    native_platform->fill_ipc_package(packer, buffer);
+    native_platform->fill_buffer_package(packer, buffer, msg_type);
 }
 
 EGLNativeDisplayType mgn::NestedPlatform::egl_native_display() const

=== modified file 'src/server/graphics/nested/nested_platform.h'
--- src/server/graphics/nested/nested_platform.h	2014-06-02 17:07:02 +0000
+++ src/server/graphics/nested/nested_platform.h	2014-06-27 09:18:41 +0000
@@ -49,7 +49,8 @@
             std::shared_ptr<GLConfig> const& gl_config);
     std::shared_ptr<PlatformIPCPackage> get_ipc_package() override;
     std::shared_ptr<InternalClient> create_internal_client() override;
-    void fill_ipc_package(BufferIPCPacker* packer, Buffer const* Buffer) const override;
+    void fill_buffer_package(
+        BufferIPCPacker* packer, Buffer const* Buffer, BufferIpcMsgType msg_type) const override;
     EGLNativeDisplayType egl_native_display() const;
 
 private:

=== modified file 'src/server/input/CMakeLists.txt'
--- src/server/input/CMakeLists.txt	2014-06-02 17:07:02 +0000
+++ src/server/input/CMakeLists.txt	2014-06-27 09:18:41 +0000
@@ -5,11 +5,13 @@
 
   event_filter_chain.cpp
 
+  null_input_channel_factory.cpp
   null_input_configuration.cpp
   null_input_dispatcher.cpp
   nested_input_configuration.cpp
   display_input_region.cpp
   vt_filter.cpp
+  cursor_controller.cpp
   default_configuration.cpp
 )
 

=== modified file 'src/server/input/android/CMakeLists.txt'
--- src/server/input/android/CMakeLists.txt	2014-06-02 17:07:02 +0000
+++ src/server/input/android/CMakeLists.txt	2014-06-27 09:18:41 +0000
@@ -16,6 +16,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/common_input_thread.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/input_channel_factory.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/input_translator.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/input_sender.cpp
 )
 
 set(

=== modified file 'src/server/input/android/android_input_reader_policy.cpp'
--- src/server/input/android/android_input_reader_policy.cpp	2014-03-06 06:05:17 +0000
+++ src/server/input/android/android_input_reader_policy.cpp	2014-06-27 09:18:41 +0000
@@ -26,7 +26,7 @@
 namespace mia = mir::input::android;
 
 mia::InputReaderPolicy::InputReaderPolicy(std::shared_ptr<mi::InputRegion> const& input_region,
-                                          std::shared_ptr<CursorListener> const& cursor_listener)
+    std::shared_ptr<CursorListener> const& cursor_listener)
     : input_region(input_region),
       pointer_controller(new mia::PointerController(input_region, cursor_listener))
 {
@@ -56,3 +56,15 @@
 {
     return pointer_controller;
 }
+
+void mia::InputReaderPolicy::getAssociatedDisplayInfo(droidinput::InputDeviceIdentifier const& /* identifier */,
+    int& out_associated_display_id, bool& out_associated_display_is_external)
+{
+    // This is used primarily for mapping of direct input devices to screen space. Currently we only support one large display
+    // bounding all displays (i.e. input_region->bounding_rectangle())
+    // the external/internal distinction is mostly a leftover from android configuration nuances.
+    // Eventually we will need to use a combination of configuration and heuristic to implement this 
+    // correctly
+    out_associated_display_id = 0;
+    out_associated_display_is_external = false;
+}

=== modified file 'src/server/input/android/android_input_reader_policy.h'
--- src/server/input/android/android_input_reader_policy.h	2013-08-28 03:41:48 +0000
+++ src/server/input/android/android_input_reader_policy.h	2014-06-27 09:18:41 +0000
@@ -39,8 +39,11 @@
 
     virtual ~InputReaderPolicy() {}
 
-    virtual droidinput::sp<droidinput::PointerControllerInterface> obtainPointerController(int32_t device_id);
-    virtual void getReaderConfiguration(droidinput::InputReaderConfiguration* out_config);
+    droidinput::sp<droidinput::PointerControllerInterface> obtainPointerController(int32_t device_id) override;
+    void getReaderConfiguration(droidinput::InputReaderConfiguration* out_config) override;
+
+    void getAssociatedDisplayInfo(droidinput::InputDeviceIdentifier const& identifier,
+        int& out_associated_display_id, bool& out_associated_display_is_external) override;
 private:
     std::shared_ptr<InputRegion> const input_region;
     droidinput::sp<droidinput::PointerControllerInterface> pointer_controller;

=== modified file 'src/server/input/android/default_android_input_configuration.cpp'
--- src/server/input/android/default_android_input_configuration.cpp	2014-06-04 15:31:35 +0000
+++ src/server/input/android/default_android_input_configuration.cpp	2014-06-27 09:18:41 +0000
@@ -26,7 +26,6 @@
 #include "android_input_target_enumerator.h"
 #include "android_input_manager.h"
 #include "input_translator.h"
-#include "input_channel_factory.h"
 #include "common_input_thread.h"
 
 #include "mir/input/event_filter.h"
@@ -65,11 +64,6 @@
 {
 }
 
-std::shared_ptr<mi::InputChannelFactory> mia::DefaultInputConfiguration::the_input_channel_factory()
-{
-    return std::make_shared<mia::InputChannelFactory>();
-}
-
 std::shared_ptr<droidinput::EventHubInterface> mia::DefaultInputConfiguration::the_event_hub()
 {
     return event_hub(

=== added file 'src/server/input/android/input_send_entry.h'
--- src/server/input/android/input_send_entry.h	1970-01-01 00:00:00 +0000
+++ src/server/input/android/input_send_entry.h	2014-06-27 09:18:41 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_ANDROID_INPUT_SEND_ENTRY_H_
+#define MIR_INPUT_ANDROID_INPUT_SEND_ENTRY_H_
+
+#include "mir_toolkit/event.h"
+#include <memory>
+
+namespace mir
+{
+namespace input
+{
+class InputChannel;
+namespace android
+{
+
+/*!
+ * Stores information about an input event to be sent to a client
+ */
+struct InputSendEntry
+{
+    uint32_t sequence_id;
+    MirEvent event;
+    std::shared_ptr<InputChannel> channel;
+    InputSendEntry(uint32_t id, MirEvent ev, std::shared_ptr<InputChannel> const& channel)
+        : sequence_id(id), event(ev), channel(channel)
+    {
+    }
+};
+
+}
+}
+}
+
+#endif

=== added file 'src/server/input/android/input_sender.cpp'
--- src/server/input/android/input_sender.cpp	1970-01-01 00:00:00 +0000
+++ src/server/input/android/input_sender.cpp	2014-06-27 09:18:41 +0000
@@ -0,0 +1,410 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#include "input_sender.h"
+#include "input_send_entry.h"
+
+#include "mir/input/input_send_observer.h"
+#include "mir/input/input_channel.h"
+#include "mir/input/input_report.h"
+#include "mir/scene/surface.h"
+#include "mir/compositor/scene.h"
+#include "mir/main_loop.h"
+
+#include "androidfw/Input.h"
+#include "androidfw/InputTransport.h"
+#include "std/Errors.h"
+#include "std/String8.h"
+
+#include <boost/exception/errinfo_errno.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <cstring>
+#include <algorithm>
+#include <iterator>
+
+namespace mi = mir::input;
+namespace mia = mi::android;
+
+namespace droidinput = android;
+
+namespace
+{
+const std::chrono::seconds input_send_timeout{5};
+}
+
+mia::InputSender::InputSender(std::shared_ptr<mir::compositor::Scene> const& scene,
+                              std::shared_ptr<mir::MainLoop> const& main_loop,
+                              std::shared_ptr<mir::input::InputSendObserver> const& observer,
+                              std::shared_ptr<InputReport> const& report)
+    : state{main_loop, observer, report}, scene{scene}
+{
+    scene->add_observer(std::make_shared<SceneObserver>(state));
+}
+
+mia::InputSender::SceneObserver::SceneObserver(InputSenderState & state)
+    : state(state)
+{
+}
+
+void mia::InputSender::SceneObserver::surface_added(scene::Surface* surface)
+{
+    if (surface && surface->input_channel())
+    {
+        state.add_transfer(surface->input_channel()->server_fd(), surface);
+    }
+}
+
+void mia::InputSender::SceneObserver::surface_removed(scene::Surface* surface)
+{
+    if (surface && surface->input_channel())
+    {
+        remove_transfer_for(surface);
+    }
+}
+
+void mia::InputSender::SceneObserver::surface_exists(scene::Surface* surface)
+{
+    surface_added(surface);
+}
+
+
+void mia::InputSender::SceneObserver::remove_transfer_for(mir::input::Surface * surface)
+{
+    std::shared_ptr<InputChannel> closed_channel = surface->input_channel();
+
+    if (!closed_channel)
+        return;
+
+    state.remove_transfer(closed_channel->server_fd());
+
+}
+
+mia::InputSender::InputSenderState::InputSenderState(std::shared_ptr<mir::MainLoop> const& main_loop,
+                                                     std::shared_ptr<mir::input::InputSendObserver> const& observer,
+                                                     std::shared_ptr<InputReport> const& report)
+    : main_loop{main_loop}, report{report}, observer{observer}, seq{}
+{
+}
+
+void mia::InputSender::send_event(MirEvent const& event, std::shared_ptr<InputChannel> const& channel)
+{
+    state.send_event(channel, event);
+}
+
+std::shared_ptr<mia::InputSender::ActiveTransfer> mia::InputSender::InputSenderState::get_transfer(int fd)
+{
+    auto pos = transfers.find(fd);
+
+    if (pos == transfers.end())
+        return nullptr;
+
+    return pos->second;
+}
+
+void mia::InputSender::InputSenderState::send_event(std::shared_ptr<InputChannel> const& channel, MirEvent const& event)
+{
+    std::unique_lock<std::mutex> lock(sender_mutex);
+    auto transfer = get_transfer(channel->server_fd());
+
+    if (!transfer)
+        BOOST_THROW_EXCEPTION(std::runtime_error("Failure sending input event : Unknown channel provided"));
+
+    mia::InputSendEntry entry{next_seq(), event, channel};
+    lock.unlock();
+
+    transfer->send(std::move(entry));
+}
+
+void mia::InputSender::InputSenderState::add_transfer(int fd, mir::input::Surface * surface)
+{
+    std::lock_guard<std::mutex> lock(sender_mutex);
+    std::shared_ptr<ActiveTransfer> transfer{get_transfer(fd)};
+
+    if (transfer && transfer->used_for_surface(surface))
+        return;
+
+    transfers[fd] = std::make_shared<ActiveTransfer>(*this, fd, surface);
+}
+
+void mia::InputSender::InputSenderState::remove_transfer(int fd)
+{
+    std::unique_lock<std::mutex> lock(sender_mutex);
+    auto transfer = get_transfer(fd);
+
+    if (transfer)
+    {
+        transfers.erase(fd);
+        lock.unlock();
+
+        transfer->on_surface_disappeared();
+    }
+}
+
+uint32_t mia::InputSender::InputSenderState::next_seq()
+{
+    while(!++seq);
+    return seq;
+}
+
+mia::InputSender::ActiveTransfer::ActiveTransfer(InputSenderState & state, int server_fd, mir::input::Surface* surface) :
+    state(state),
+    publisher{droidinput::sp<droidinput::InputChannel>(
+            new droidinput::InputChannel(droidinput::String8(surface->name()), server_fd))},
+    surface{surface}
+{
+}
+
+void mia::InputSender::ActiveTransfer::send(InputSendEntry && event)
+{
+    if (event.event.type != mir_event_type_key &&
+        event.event.type != mir_event_type_motion)
+        return;
+
+    droidinput::status_t error_status =
+        (event.event.type == mir_event_type_key)
+        ? send_key_event(event.sequence_id, event.event.key)
+        : send_motion_event(event.sequence_id, event.event.motion);
+
+    if (error_status == droidinput::OK)
+    {
+        enqueue_entry(std::move(event));
+        return;
+    }
+
+    switch(error_status)
+    {
+    case droidinput::WOULD_BLOCK:
+        if (state.observer)
+            state.observer->client_blocked(event.event, surface);
+        break;
+    case droidinput::DEAD_OBJECT:
+        if (state.observer)
+            state.observer->send_failed(event.event, surface, InputSendObserver::socket_error);
+        break;
+    default:
+        BOOST_THROW_EXCEPTION(boost::enable_error_info(std::runtime_error("Failure sending input event : ")) << boost::errinfo_errno(errno));
+    }
+}
+
+mia::InputSender::ActiveTransfer::~ActiveTransfer()
+{
+    unsubscribe();
+}
+
+void mia::InputSender::ActiveTransfer::unsubscribe()
+{
+    state.main_loop->unregister_fd_handler(this);
+}
+
+void mia::InputSender::ActiveTransfer::subscribe()
+{
+    state.main_loop->register_fd_handler({publisher.getChannel()->getFd()},
+                                    this,
+                                    [this](int)
+                                    {
+                                        on_finish_signal();
+                                    });
+}
+
+droidinput::status_t mia::InputSender::ActiveTransfer::send_key_event(uint32_t seq, MirKeyEvent const& event)
+{
+    return publisher.publishKeyEvent(
+        seq,
+        event.device_id,
+        event.source_id,
+        event.action,
+        event.flags,
+        event.key_code,
+        event.scan_code,
+        event.modifiers,
+        event.repeat_count,
+        event.down_time,
+        event.event_time
+        );
+}
+
+droidinput::status_t mia::InputSender::ActiveTransfer::send_motion_event(uint32_t seq, MirMotionEvent const& event)
+{
+    droidinput::PointerCoords coords[MIR_INPUT_EVENT_MAX_POINTER_COUNT];
+    droidinput::PointerProperties properties[MIR_INPUT_EVENT_MAX_POINTER_COUNT];
+    // no default constructor:
+    std::memset(coords, 0, sizeof(coords));
+    std::memset(properties, 0, sizeof(properties));
+
+    for (size_t i = 0; i < event.pointer_count; ++i)
+    {
+        // Note: this assumes that: x == raw_x + x_offset;
+        // here x, y is used instead of the raw co-ordinates and offset is set to zero
+        coords[i].setAxisValue(AMOTION_EVENT_AXIS_X, event.pointer_coordinates[i].x);
+        coords[i].setAxisValue(AMOTION_EVENT_AXIS_Y, event.pointer_coordinates[i].y);
+
+        coords[i].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, event.pointer_coordinates[i].touch_major);
+        coords[i].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, event.pointer_coordinates[i].touch_minor);
+        coords[i].setAxisValue(AMOTION_EVENT_AXIS_SIZE, event.pointer_coordinates[i].size);
+        coords[i].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, event.pointer_coordinates[i].pressure);
+        coords[i].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, event.pointer_coordinates[i].orientation);
+        coords[i].setAxisValue(AMOTION_EVENT_AXIS_VSCROLL, event.pointer_coordinates[i].vscroll);
+        coords[i].setAxisValue(AMOTION_EVENT_AXIS_HSCROLL, event.pointer_coordinates[i].hscroll);
+        properties[i].toolType = event.pointer_coordinates[i].tool_type;
+        properties[i].id = event.pointer_coordinates[i].id;
+    }
+
+    return publisher.publishMotionEvent(
+        seq,
+        event.device_id,
+        event.source_id,
+        event.action,
+        static_cast<int32_t>(event.flags),
+        event.edge_flags,
+        static_cast<int32_t>(event.modifiers),
+        static_cast<int32_t>(event.button_state),
+        0.0f,  // event.x_offset,
+        0.0f,  // event.y_offset,
+        event.x_precision,
+        event.y_precision,
+        event.down_time,
+        event.event_time,
+        event.pointer_count,
+        properties,
+        coords
+        );
+}
+
+void mia::InputSender::ActiveTransfer::on_surface_disappeared()
+{
+    std::unique_lock<std::mutex> lock{transfer_mutex};
+    std::vector<InputSendEntry> release_pending_responses;
+
+    swap(release_pending_responses, pending_responses);
+
+    lock.unlock();
+
+    auto observer = state.observer;
+    if (observer)
+    {
+        std::for_each(release_pending_responses.rbegin(),
+                      release_pending_responses.rend(),
+                      [observer,this](InputSendEntry const& entry)
+                      {
+                          observer->send_failed(entry.event, surface, InputSendObserver::surface_disappeared);
+                      });
+    }
+}
+
+void mia::InputSender::ActiveTransfer::on_finish_signal()
+{
+    uint32_t sequence;
+    bool handled;
+
+    while(true)
+    {
+        droidinput::status_t status = publisher.receiveFinishedSignal(&sequence, &handled);
+
+        if (status == droidinput::OK)
+        {
+            state.report->received_event_finished_signal(publisher.getChannel()->getFd(), sequence);
+            InputSendEntry entry = unqueue_entry(sequence);
+            auto observer = state.observer;
+
+            if (entry.sequence_id == sequence && observer)
+                observer->send_suceeded(entry.event,
+                                        surface,
+                                        handled ? InputSendObserver::consumed : InputSendObserver::not_consumed);
+        }
+        else
+        {
+            return;
+            // TODO find a better way to handle communication errors, droidinput::InputDispatcher just ignores them
+        }
+    }
+}
+
+void mia::InputSender::ActiveTransfer::on_response_timeout()
+{
+    int top_sequence_id{0};
+
+    {
+        std::lock_guard<std::mutex> lock(transfer_mutex);
+        if (pending_responses.empty())
+            return;
+        top_sequence_id = pending_responses.front().sequence_id;
+    }
+
+    mia::InputSendEntry timedout_entry{unqueue_entry(top_sequence_id)};
+
+    if (state.observer)
+        state.observer->send_failed(timedout_entry.event, surface, InputSendObserver::no_response_received);
+}
+
+void mia::InputSender::ActiveTransfer::enqueue_entry(mia::InputSendEntry && entry)
+{
+    std::lock_guard<std::mutex> lock(transfer_mutex);
+    if (pending_responses.empty())
+    {
+        subscribe();
+        update_timer();
+    }
+
+    pending_responses.push_back(entry);
+}
+
+mia::InputSendEntry mia::InputSender::ActiveTransfer::unqueue_entry(uint32_t sequence_id)
+{
+    std::lock_guard<std::mutex> lock(transfer_mutex);
+    auto pos = std::find_if(pending_responses.begin(),
+                            pending_responses.end(),
+                            [sequence_id](mia::InputSendEntry const& entry)
+                            { return entry.sequence_id == sequence_id; });
+
+    if (pos == end(pending_responses))
+        return {0, MirEvent{}, std::shared_ptr<mi::InputChannel>()};
+
+    mia::InputSendEntry result = *pos;
+    pending_responses.erase(pos);
+    if (pending_responses.empty())
+    {
+        unsubscribe();
+        cancel_timer();
+    }
+    else
+    {
+        update_timer();
+    }
+
+    return result;
+}
+
+void mia::InputSender::ActiveTransfer::update_timer()
+{
+    if (send_timer)
+        send_timer->reschedule_in(input_send_timeout);
+    else
+        send_timer = state.main_loop->notify_in(input_send_timeout, [this](){on_response_timeout();});
+}
+
+void mia::InputSender::ActiveTransfer::cancel_timer()
+{
+    if (send_timer)
+        send_timer->cancel();
+}
+
+bool mia::InputSender::ActiveTransfer::used_for_surface(input::Surface const* surface) const
+{
+    return this->surface == surface;
+}

=== added file 'src/server/input/android/input_sender.h'
--- src/server/input/android/input_sender.h	1970-01-01 00:00:00 +0000
+++ src/server/input/android/input_sender.h	2014-06-27 09:18:41 +0000
@@ -0,0 +1,146 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_ANDROID_INPUT_SENDER_H_
+#define MIR_INPUT_ANDROID_INPUT_SENDER_H_
+
+#include "mir/input/input_sender.h"
+#include "mir/scene/null_observer.h"
+
+#include "androidfw/InputTransport.h"
+
+#include <memory>
+#include <unordered_map>
+#include <mutex>
+#include <vector>
+
+namespace droidinput = android;
+
+namespace mir
+{
+class MainLoop;
+namespace time
+{
+class Alarm;
+}
+namespace compositor
+{
+class Scene;
+}
+namespace scene
+{
+class InputRegistrar;
+}
+namespace input
+{
+class InputReport;
+namespace android
+{
+class InputSendEntry;
+class Surface;
+
+class InputSender : public input::InputSender
+{
+public:
+    InputSender(std::shared_ptr<compositor::Scene> const& scene,
+                std::shared_ptr<MainLoop> const& main_loop,
+                std::shared_ptr<InputSendObserver> const& observer,
+                std::shared_ptr<InputReport> const& report);
+
+    void send_event(MirEvent const& event, std::shared_ptr<InputChannel> const& channel) override;
+
+private:
+    struct InputSenderState;
+
+    class SceneObserver : public scene::NullObserver
+    {
+    public:
+        explicit SceneObserver(InputSenderState & state);
+    private:
+        void surface_added(scene::Surface* surface) override;
+        void surface_removed(scene::Surface* surface) override;
+        void surface_exists(scene::Surface* surface) override;
+
+        void remove_transfer_for(input::Surface* surface);
+        InputSenderState & state;
+    };
+
+    class ActiveTransfer
+    {
+    public:
+        ActiveTransfer(InputSenderState & state, int server_fd, input::Surface* surface);
+        ~ActiveTransfer();
+        void send(InputSendEntry && item);
+        bool used_for_surface(input::Surface const* surface) const;
+        void on_surface_disappeared();
+
+    private:
+        void subscribe();
+        void unsubscribe();
+        void on_finish_signal();
+        void on_response_timeout();
+        void update_timer();
+        void cancel_timer();
+        droidinput::status_t send_key_event(uint32_t sequence_id, MirKeyEvent const& event);
+        droidinput::status_t send_motion_event(uint32_t sequence_id, MirMotionEvent const& event);
+        void process_and_submit_result(std::shared_ptr<InputSendObserver> const& observer, std::shared_ptr<InputReport> const& report);
+        InputSendEntry unqueue_entry(uint32_t sequence_id);
+        void enqueue_entry(InputSendEntry && entry);
+
+        InputSenderState & state;
+        droidinput::InputPublisher publisher;
+        input::Surface * surface;
+        std::vector<InputSendEntry> pending_responses;
+        std::mutex transfer_mutex;
+        std::unique_ptr<time::Alarm> send_timer;
+
+        ActiveTransfer& operator=(ActiveTransfer const&) = delete;
+        ActiveTransfer(ActiveTransfer const&) = delete;
+    };
+
+    struct InputSenderState
+    {
+        InputSenderState(std::shared_ptr<MainLoop> const& main_loop,
+                         std::shared_ptr<InputSendObserver> const& observer,
+                         std::shared_ptr<InputReport> const& report);
+        void send_event(std::shared_ptr<InputChannel> const& channel, MirEvent const& event);
+        void add_transfer(int fd, input::Surface* surface);
+        void remove_transfer(int fd);
+
+        std::shared_ptr<MainLoop> const main_loop;
+        std::shared_ptr<InputReport> const report;
+        std::shared_ptr<InputSendObserver> const observer;
+
+    private:
+        std::shared_ptr<ActiveTransfer> get_transfer(int fd);
+        uint32_t next_seq();
+        uint32_t seq;
+
+        std::unordered_map<int,std::shared_ptr<ActiveTransfer>> transfers;
+        std::mutex sender_mutex;
+    };
+
+    InputSenderState state;
+    std::shared_ptr<compositor::Scene> scene;
+};
+
+}
+}
+}
+
+#endif

=== added file 'src/server/input/cursor_controller.cpp'
--- src/server/input/cursor_controller.cpp	1970-01-01 00:00:00 +0000
+++ src/server/input/cursor_controller.cpp	2014-06-27 09:18:41 +0000
@@ -0,0 +1,244 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#include "cursor_controller.h"
+
+#include "mir/input/input_targets.h"
+#include "mir/input/surface.h"
+#include "mir/graphics/cursor.h"
+#include "mir/scene/observer.h"
+#include "mir/scene/surface_observer.h"
+#include "mir/scene/surface.h"
+
+#include <functional>
+#include <mutex>
+#include <map>
+
+#include <assert.h>
+
+namespace mi = mir::input;
+namespace mg = mir::graphics;
+namespace ms = mir::scene;
+namespace geom = mir::geometry;
+
+namespace
+{
+
+struct UpdateCursorOnSurfaceChanges : ms::SurfaceObserver
+{
+    UpdateCursorOnSurfaceChanges(mi::CursorController* cursor_controller)
+        : cursor_controller(cursor_controller)
+    {
+    }
+
+    void attrib_changed(MirSurfaceAttrib, int) override
+    {
+        // Attribute changing alone wont trigger a cursor update
+    }
+    void resized_to(geom::Size const&) override
+    {
+        cursor_controller->update_cursor_image();
+    }
+    void moved_to(geom::Point const&) override
+    {
+        cursor_controller->update_cursor_image();
+    }
+    void hidden_set_to(bool) override
+    {
+        cursor_controller->update_cursor_image();
+    }
+    void frame_posted(int) override
+    {
+        // Frame posting wont trigger a cursor update
+    }
+    void alpha_set_to(float) override
+    {
+        cursor_controller->update_cursor_image();
+    }
+    void transformation_set_to(glm::mat4 const&) override
+    {
+        cursor_controller->update_cursor_image();
+    }
+    void reception_mode_set_to(mi::InputReceptionMode) override
+    {
+        cursor_controller->update_cursor_image();
+    }
+    void cursor_image_set_to(mg::CursorImage const&) override
+    {
+        cursor_controller->update_cursor_image();
+    }
+    void orientation_set_to(MirOrientation /* orientation */) override
+    {
+        // No need to update cursor for orientation property change alone.
+    }
+
+    mi::CursorController* const cursor_controller;
+};
+
+struct UpdateCursorOnSceneChanges : ms::Observer
+{
+    UpdateCursorOnSceneChanges(mi::CursorController* cursor_controller)
+        : cursor_controller(cursor_controller)
+    {
+    }
+    
+    void add_surface_observer(ms::Surface* surface)
+    {
+        auto const observer = std::make_shared<UpdateCursorOnSurfaceChanges>(cursor_controller);
+        surface->add_observer(observer);
+
+        {
+            std::unique_lock<decltype(surface_observers_guard)> lg(surface_observers_guard);
+            surface_observers[surface] = observer;
+        }
+    }
+    
+    void surface_added(ms::Surface *surface)
+    {
+        add_surface_observer(surface);
+        cursor_controller->update_cursor_image();
+    }
+    void surface_removed(ms::Surface *surface)
+    {
+        {
+            std::unique_lock<decltype(surface_observers_guard)> lg(surface_observers_guard);
+            auto it = surface_observers.find(surface);
+            if (it != surface_observers.end())
+            {
+                surface->remove_observer(it->second);
+                surface_observers.erase(it);
+            }
+        }
+        cursor_controller->update_cursor_image();
+    }
+    void surfaces_reordered()
+    {
+        cursor_controller->update_cursor_image();
+    }
+    
+    void surface_exists(ms::Surface *surface)
+    {
+        add_surface_observer(surface);
+        cursor_controller->update_cursor_image();
+    }
+    
+    void end_observation()
+    {
+        std::unique_lock<decltype(surface_observers_guard)> lg(surface_observers_guard);
+        for (auto &kv : surface_observers)
+        {
+                auto surface = kv.first;
+                if (surface)
+                    surface->remove_observer(kv.second);
+        }
+        surface_observers.clear();
+    }
+    
+private:
+    mi::CursorController* const cursor_controller;
+
+    std::mutex surface_observers_guard;
+    std::map<ms::Surface*, std::weak_ptr<ms::SurfaceObserver>> surface_observers;
+};
+
+std::shared_ptr<mi::Surface> topmost_surface_containing_point(
+    std::shared_ptr<mi::InputTargets> const& targets, geom::Point const& point)
+{
+    std::shared_ptr<mi::Surface> top_surface_at_point;
+    targets->for_each([&top_surface_at_point, &point]
+        (std::shared_ptr<mi::Surface> const& surface) 
+        {
+            if (surface->input_area_contains(point))
+                top_surface_at_point = surface;
+        });
+    return top_surface_at_point;
+}
+
+}
+
+mi::CursorController::CursorController(std::shared_ptr<mi::InputTargets> const& input_targets,
+    std::shared_ptr<mg::Cursor> const& cursor,
+    std::shared_ptr<mg::CursorImage> const& default_cursor_image) :
+        input_targets(input_targets),
+        cursor(cursor),
+        default_cursor_image(default_cursor_image),
+        current_cursor(default_cursor_image)
+{
+    // TODO: Add observer could return weak_ptr to eliminate this
+    // pattern
+    auto strong_observer = std::make_shared<UpdateCursorOnSceneChanges>(this);
+    input_targets->add_observer(strong_observer);
+    observer = strong_observer;
+}
+
+mi::CursorController::~CursorController()
+{
+    try 
+    {
+        input_targets->remove_observer(observer);
+    }
+    catch (...)
+    {
+        std::terminate();
+    }
+}
+
+void mi::CursorController::set_cursor_image_locked(std::lock_guard<std::mutex> const&,
+    std::shared_ptr<mg::CursorImage> const& image)
+{
+    if (current_cursor == image)
+    {
+        return;
+    }
+
+    current_cursor = image;
+    if (image)
+        cursor->show(*image);
+    else
+        cursor->hide();
+}
+
+void mi::CursorController::update_cursor_image_locked(std::lock_guard<std::mutex> const& lg)
+{
+    auto surface = topmost_surface_containing_point(input_targets, cursor_location);
+    if (surface)
+    {
+        set_cursor_image_locked(lg, surface->cursor_image());
+    }
+    else
+    {
+        set_cursor_image_locked(lg, default_cursor_image);
+    }
+}
+
+void mi::CursorController::update_cursor_image()
+{
+    std::lock_guard<std::mutex> lg(cursor_state_guard);
+    update_cursor_image_locked(lg);
+}
+
+void mi::CursorController::cursor_moved_to(float abs_x, float abs_y)
+{
+    std::lock_guard<std::mutex> lg(cursor_state_guard);
+
+    cursor_location = geom::Point{geom::X{abs_x}, geom::Y{abs_y}};
+    
+    update_cursor_image_locked(lg);
+
+    cursor->move_to(cursor_location);
+}

=== added file 'src/server/input/cursor_controller.h'
--- src/server/input/cursor_controller.h	1970-01-01 00:00:00 +0000
+++ src/server/input/cursor_controller.h	2014-06-27 09:18:41 +0000
@@ -0,0 +1,77 @@
+/*
+ * 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_INPUT_CURSOR_CONTROLLER_H_
+#define MIR_INPUT_CURSOR_CONTROLLER_H_
+
+#include "mir/input/cursor_listener.h"
+#include "mir/geometry/point.h"
+
+#include <memory>
+#include <mutex>
+
+namespace mir
+{
+namespace graphics
+{
+class Cursor;
+class CursorImage;
+}
+namespace scene
+{
+class Observer;
+}
+
+namespace input
+{
+class InputTargets;
+
+class CursorController : public CursorListener
+{
+public:
+    CursorController(std::shared_ptr<InputTargets> const& input_targets,
+        std::shared_ptr<graphics::Cursor> const& cursor,
+        std::shared_ptr<graphics::CursorImage> const& default_cursor_image);
+    virtual ~CursorController();
+
+    void cursor_moved_to(float abs_x, float abs_y);
+
+    // Trigger an update of the cursor image without cursor motion, e.g.
+    // in response to scene changes.
+    void update_cursor_image();
+
+private:
+    std::shared_ptr<InputTargets> const input_targets;
+    std::shared_ptr<graphics::Cursor> const cursor;
+    std::shared_ptr<graphics::CursorImage> const default_cursor_image;
+
+    std::mutex cursor_state_guard;
+    geometry::Point cursor_location;
+    std::shared_ptr<graphics::CursorImage> current_cursor;
+
+    std::weak_ptr<scene::Observer> observer;
+    
+
+    void update_cursor_image_locked(std::lock_guard<std::mutex> const&);
+    void set_cursor_image_locked(std::lock_guard<std::mutex> const&, std::shared_ptr<graphics::CursorImage> const& image);
+};
+
+}
+}
+
+#endif // MIR_INPUT_CURSOR_CONTROLLER_H_

=== modified file 'src/server/input/default_configuration.cpp'
--- src/server/input/default_configuration.cpp	2014-06-06 10:03:54 +0000
+++ src/server/input/default_configuration.cpp	2014-06-27 09:18:41 +0000
@@ -24,18 +24,24 @@
 #include "android/android_input_registrar.h"
 #include "android/android_input_target_enumerator.h"
 #include "android/event_filter_dispatcher_policy.h"
+#include "android/input_sender.h"
+#include "android/input_channel_factory.h"
 #include "display_input_region.h"
 #include "event_filter_chain.h"
 #include "nested_input_configuration.h"
 #include "null_input_configuration.h"
+#include "cursor_controller.h"
 #include "null_input_dispatcher.h"
 #include "null_input_targeter.h"
+#include "null_input_send_observer.h"
+#include "null_input_channel_factory.h"
 
 #include "mir/input/android/default_android_input_configuration.h"
 #include "mir/options/configuration.h"
 #include "mir/options/option.h"
 #include "mir/compositor/scene.h"
 #include "mir/report/legacy_input_report.h"
+#include "mir/main_loop.h"
 
 #include <InputDispatcher.h>
 
@@ -120,6 +126,27 @@
         });
 }
 
+std::shared_ptr<mi::InputSender>
+mir::DefaultServerConfiguration::the_input_sender()
+{
+    return input_sender(
+        [this]()
+        {
+            return std::make_shared<mia::InputSender>(the_scene(), the_main_loop(), the_input_send_observer(), the_input_report());
+        });
+}
+
+std::shared_ptr<mi::InputSendObserver>
+mir::DefaultServerConfiguration::the_input_send_observer()
+{
+    return input_send_observer(
+        [this]()
+        {
+            return std::make_shared<mi::NullInputSendObserver>();
+        });
+}
+
+
 std::shared_ptr<msh::InputTargeter>
 mir::DefaultServerConfiguration::the_input_targeter()
 {
@@ -190,7 +217,21 @@
 
 std::shared_ptr<mi::InputChannelFactory> mir::DefaultServerConfiguration::the_input_channel_factory()
 {
-    return the_input_configuration()->the_input_channel_factory();
-}
-
-
+    auto const options = the_options();
+    if (!options->get<bool>(options::enable_input_opt))
+        return std::make_shared<mi::NullInputChannelFactory>();
+    else
+        return std::make_shared<mia::InputChannelFactory>();
+}
+
+std::shared_ptr<mi::CursorListener>
+mir::DefaultServerConfiguration::the_cursor_listener()
+{
+    return cursor_listener(
+        [this]() -> std::shared_ptr<mi::CursorListener>
+        {
+            return std::make_shared<mi::CursorController>(the_input_targets(), 
+                the_cursor(), the_default_cursor_image());
+        });
+
+}

=== modified file 'src/server/input/nested_input_configuration.cpp'
--- src/server/input/nested_input_configuration.cpp	2014-06-02 17:07:02 +0000
+++ src/server/input/nested_input_configuration.cpp	2014-06-27 09:18:41 +0000
@@ -27,15 +27,6 @@
 namespace mi = mir::input;
 namespace mia = mir::input::android;
 
-mi::NestedInputConfiguration::NestedInputConfiguration()
-{
-}
-
-std::shared_ptr<mi::InputChannelFactory> mi::NestedInputConfiguration::the_input_channel_factory()
-{
-    return std::make_shared<mia::InputChannelFactory>();
-}
-
 std::shared_ptr<mi::InputManager> mi::NestedInputConfiguration::the_input_manager()
 {
     return input_manager(

=== modified file 'src/server/input/nested_input_configuration.h'
--- src/server/input/nested_input_configuration.h	2014-06-02 17:07:02 +0000
+++ src/server/input/nested_input_configuration.h	2014-06-27 09:18:41 +0000
@@ -27,14 +27,11 @@
 {
 namespace input
 {
-class NestedInputRelay;
-
 class NestedInputConfiguration : public InputConfiguration
 {
 public:
-    NestedInputConfiguration();
+    NestedInputConfiguration() = default;
     virtual ~NestedInputConfiguration() = default;
-    std::shared_ptr<InputChannelFactory> the_input_channel_factory() override;
     std::shared_ptr<InputManager> the_input_manager() override;
 
 private:

=== added file 'src/server/input/null_input_channel_factory.cpp'
--- src/server/input/null_input_channel_factory.cpp	1970-01-01 00:00:00 +0000
+++ src/server/input/null_input_channel_factory.cpp	2014-06-27 09:18:41 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#include "null_input_channel_factory.h"
+
+#include "mir/input/input_channel.h"
+
+namespace mi = mir::input;
+
+namespace
+{
+class NullInputChannel : public mi::InputChannel
+{
+    int client_fd() const override
+    {
+        return -1;
+    }
+    int server_fd() const override
+    {
+        return -1;
+    }
+};
+}
+
+std::shared_ptr<mi::InputChannel> mi::NullInputChannelFactory::make_input_channel()
+{
+    return std::make_shared<NullInputChannel>();
+}
+

=== added file 'src/server/input/null_input_channel_factory.h'
--- src/server/input/null_input_channel_factory.h	1970-01-01 00:00:00 +0000
+++ src/server/input/null_input_channel_factory.h	2014-06-27 09:18:41 +0000
@@ -0,0 +1,38 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_NULL_INPUT_CHANNEL_FACTORY_H_
+#define MIR_INPUT_NULL_INPUT_CHANNEL_FACTORY_H_
+
+#include "mir/input/input_channel_factory.h"
+
+namespace mir
+{
+namespace input
+{
+class InputChannel;
+
+class NullInputChannelFactory : public mir::input::InputChannelFactory
+{
+    std::shared_ptr<mir::input::InputChannel> make_input_channel() override;
+};
+
+}
+}
+
+#endif

=== modified file 'src/server/input/null_input_configuration.cpp'
--- src/server/input/null_input_configuration.cpp	2014-06-02 17:07:02 +0000
+++ src/server/input/null_input_configuration.cpp	2014-06-27 09:18:41 +0000
@@ -19,43 +19,9 @@
 #include "null_input_configuration.h"
 #include "null_input_manager.h"
 
-#include "mir/input/input_channel_factory.h"
-#include "mir/input/input_channel.h"
-
 namespace mi = mir::input;
 
-namespace
-{
-
-class NullInputChannel : public mi::InputChannel
-{
-    int client_fd() const override
-    {
-        return 0;
-    }
-    int server_fd() const override
-    {
-        return 0;
-    }
-};
-
-class NullInputChannelFactory : public mi::InputChannelFactory
-{
-    std::shared_ptr<mi::InputChannel> make_input_channel() override
-    {
-        return std::make_shared<NullInputChannel>();
-    }
-};
-
-}
-
-std::shared_ptr<mi::InputChannelFactory> mi::NullInputConfiguration::the_input_channel_factory()
-{
-    return std::make_shared<NullInputChannelFactory>();
-}
-
 std::shared_ptr<mi::InputManager> mi::NullInputConfiguration::the_input_manager()
 {
     return std::make_shared<NullInputManager>();
 }
-

=== modified file 'src/server/input/null_input_configuration.h'
--- src/server/input/null_input_configuration.h	2014-06-02 17:07:02 +0000
+++ src/server/input/null_input_configuration.h	2014-06-27 09:18:41 +0000
@@ -33,7 +33,6 @@
     NullInputConfiguration() = default;
     virtual ~NullInputConfiguration() = default;
 
-    std::shared_ptr<input::InputChannelFactory> the_input_channel_factory() override;
     std::shared_ptr<input::InputManager> the_input_manager() override;
 
 protected:

=== added file 'src/server/input/null_input_send_observer.h'
--- src/server/input/null_input_send_observer.h	1970-01-01 00:00:00 +0000
+++ src/server/input/null_input_send_observer.h	2014-06-27 09:18:41 +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 General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_NULL_INPUT_SEND_OBSERVER_H_
+#define MIR_INPUT_NULL_INPUT_SEND_OBSERVER_H_
+
+#include "mir/input/input_send_observer.h"
+
+namespace mir
+{
+namespace input
+{
+
+class NullInputSendObserver : public InputSendObserver
+{
+public:
+    void send_failed(MirEvent const& /*event*/, input::Surface* /*surface*/, FailureReason /*reason*/) override
+    {
+    }
+
+    void send_suceeded(MirEvent const& /*event*/, input::Surface* /*surface*/, InputResponse /*response*/) override
+    {
+    }
+
+    void client_blocked(MirEvent const& /*event*/, input::Surface* /*client*/) override
+    {
+    }
+};
+
+}
+}
+#endif

=== modified file 'src/server/scene/CMakeLists.txt'
--- src/server/scene/CMakeLists.txt	2014-06-12 10:24:08 +0000
+++ src/server/scene/CMakeLists.txt	2014-06-27 09:18:41 +0000
@@ -22,4 +22,5 @@
   legacy_surface_change_notification.cpp
   prompt_session_container.cpp
   prompt_session_manager_impl.cpp
+  rendering_tracker.cpp
 )

=== modified file 'src/server/scene/basic_surface.cpp'
--- src/server/scene/basic_surface.cpp	2014-06-12 15:35:08 +0000
+++ src/server/scene/basic_surface.cpp	2014-06-27 09:18:41 +0000
@@ -23,6 +23,7 @@
 #include "mir/frontend/event_sink.h"
 #include "mir/input/input_channel.h"
 #include "mir/shell/input_targeter.h"
+#include "mir/input/input_sender.h"
 #include "mir/graphics/buffer.h"
 
 #include "mir/scene/scene_report.h"
@@ -88,6 +89,14 @@
         p->alpha_set_to(alpha);
 }
 
+void ms::SurfaceObservers::orientation_set_to(MirOrientation orientation)
+{
+    std::unique_lock<decltype(mutex)> lock(mutex);
+    // TBD Maybe we should copy observers so we can release the lock?
+    for (auto const& p : observers)
+        p->orientation_set_to(orientation);
+}
+
 void ms::SurfaceObservers::transformation_set_to(glm::mat4 const& t)
 {
     std::unique_lock<decltype(mutex)> lock(mutex);
@@ -133,6 +142,7 @@
     bool nonrectangular,
     std::shared_ptr<mc::BufferStream> const& buffer_stream,
     std::shared_ptr<mi::InputChannel> const& input_channel,
+    std::shared_ptr<input::InputSender> const& input_sender,
     std::shared_ptr<SurfaceConfigurator> const& configurator,
     std::shared_ptr<mg::CursorImage> const& cursor_image,
     std::shared_ptr<SceneReport> const& report) :
@@ -146,11 +156,13 @@
     input_rectangles{geom::Rectangle{geom::Point{0, 0}, surface_rect.size}},
     surface_buffer_stream(buffer_stream),
     server_input_channel(input_channel),
+    input_sender(input_sender),
     configurator(configurator),
     cursor_image_(cursor_image),
     report(report),
     type_value(mir_surface_type_normal),
     state_value(mir_surface_state_restored),
+    visibility_value(mir_surface_visibility_exposed),
     dpi_value(0)
 {
     report->surface_created(this, surface_name);
@@ -340,6 +352,10 @@
     observers.alpha_set_to(alpha);
 }
 
+void ms::BasicSurface::set_orientation(MirOrientation orientation)
+{
+    observers.orientation_set_to(orientation);
+}
 
 void ms::BasicSurface::set_transformation(glm::mat4 const& t)
 {
@@ -431,6 +447,7 @@
 {
     int result = 0;
     bool allow_dropping = false;
+
     /*
      * TODO: In future, query the shell implementation for the subset of
      *       attributes/types it implements.
@@ -463,6 +480,10 @@
             BOOST_THROW_EXCEPTION(std::logic_error("Invalid DPI value"));
         result = dpi();
         break;
+    case mir_surface_attrib_visibility:
+        set_visibility(static_cast<MirSurfaceVisibility>(value));
+        result = visibility_value;
+        break;
     default:
         BOOST_THROW_EXCEPTION(std::logic_error("Invalid surface "
                                                "attribute."));
@@ -486,13 +507,16 @@
 
 void ms::BasicSurface::set_cursor_image(std::shared_ptr<mg::CursorImage> const& image)
 {
+    {
         std::unique_lock<std::mutex> lock(guard);
         cursor_image_ = image;
+    }
 
-        observers.cursor_image_set_to(*image);
+    observers.cursor_image_set_to(*image);
 }
     
-std::shared_ptr<mg::CursorImage> ms::BasicSurface::cursor_image()
+
+std::shared_ptr<mg::CursorImage> ms::BasicSurface::cursor_image() const
 {
     std::unique_lock<std::mutex> lock(guard);
     return cursor_image_;
@@ -518,6 +542,21 @@
     return valid;
 }
 
+void ms::BasicSurface::set_visibility(MirSurfaceVisibility new_visibility)
+{
+    if (new_visibility != mir_surface_visibility_occluded &&
+        new_visibility != mir_surface_visibility_exposed)
+    {
+        BOOST_THROW_EXCEPTION(std::logic_error("Invalid visibility value"));
+    }
+
+    if (visibility_value != new_visibility)
+    {
+        visibility_value = new_visibility;
+        observers.attrib_changed(mir_surface_attrib_visibility, visibility_value);
+    }
+}
+
 void ms::BasicSurface::add_observer(std::shared_ptr<SurfaceObserver> const& observer)
 {
     observers.add(observer);
@@ -626,3 +665,8 @@
             nonrectangular, 
             this));
 }
+
+void ms::BasicSurface::consume(MirEvent const& event)
+{
+    input_sender->send_event(event, server_input_channel);
+}

=== modified file 'src/server/scene/basic_surface.h'
--- src/server/scene/basic_surface.h	2014-06-12 15:35:08 +0000
+++ src/server/scene/basic_surface.h	2014-06-27 09:18:41 +0000
@@ -47,6 +47,7 @@
 namespace input
 {
 class InputChannel;
+class InputSender;
 class Surface;
 }
 namespace scene
@@ -64,6 +65,7 @@
     void hidden_set_to(bool hide) override;
     void frame_posted(int frames_available) override;
     void alpha_set_to(float alpha) override;
+    void orientation_set_to(MirOrientation orientation) override;
     void transformation_set_to(glm::mat4 const& t) override;
     void reception_mode_set_to(input::InputReceptionMode mode) override;
     void cursor_image_set_to(graphics::CursorImage const& image) override;
@@ -85,6 +87,7 @@
         bool nonrectangular,
         std::shared_ptr<compositor::BufferStream> const& buffer_stream,
         std::shared_ptr<input::InputChannel> const& input_channel,
+        std::shared_ptr<input::InputSender> const& sender,
         std::shared_ptr<SurfaceConfigurator> const& configurator,
         std::shared_ptr<graphics::CursorImage> const& cursor_image,
         std::shared_ptr<SceneReport> const& report);
@@ -120,7 +123,9 @@
     geometry::Point top_left() const override;
     geometry::Rectangle input_bounds() const override;
     bool input_area_contains(geometry::Point const& point) const override;
+    void consume(MirEvent const& event);
     void set_alpha(float alpha) override;
+    void set_orientation(MirOrientation orientation) override;
     void set_transformation(glm::mat4 const&) override;
 
     bool visible() const;
@@ -138,7 +143,7 @@
     void show() override;
     
     void set_cursor_image(std::shared_ptr<graphics::CursorImage> const& image);
-    std::shared_ptr<graphics::CursorImage> cursor_image();
+    std::shared_ptr<graphics::CursorImage> cursor_image() const;
 
     void add_observer(std::shared_ptr<SurfaceObserver> const& observer) override;
     void remove_observer(std::weak_ptr<SurfaceObserver> const& observer) override;
@@ -150,6 +155,7 @@
     bool set_type(MirSurfaceType t);  // Use configure() to make public changes
     bool set_state(MirSurfaceState s);
     bool set_dpi(int);
+    void set_visibility(MirSurfaceVisibility v);
 
     SurfaceObservers observers;
     std::mutex mutable guard;
@@ -164,12 +170,14 @@
     std::vector<geometry::Rectangle> input_rectangles;
     std::shared_ptr<compositor::BufferStream> const surface_buffer_stream;
     std::shared_ptr<input::InputChannel> const server_input_channel;
+    std::shared_ptr<input::InputSender> const input_sender;
     std::shared_ptr<SurfaceConfigurator> const configurator;
     std::shared_ptr<graphics::CursorImage> cursor_image_;
     std::shared_ptr<SceneReport> const report;
 
     MirSurfaceType type_value;
     MirSurfaceState state_value;
+    MirSurfaceVisibility visibility_value;
     int dpi_value;
 };
 

=== modified file 'src/server/scene/default_configuration.cpp'
--- src/server/scene/default_configuration.cpp	2014-06-11 16:11:32 +0000
+++ src/server/scene/default_configuration.cpp	2014-06-27 09:18:41 +0000
@@ -72,6 +72,7 @@
             return std::make_shared<ms::SurfaceAllocator>(
                 the_buffer_stream_factory(),
                 the_input_channel_factory(),
+                the_input_sender(),
                 the_surface_configurator(),
                 the_default_cursor_image(),
                 the_scene_report());

=== modified file 'src/server/scene/legacy_surface_change_notification.cpp'
--- src/server/scene/legacy_surface_change_notification.cpp	2014-06-12 15:35:08 +0000
+++ src/server/scene/legacy_surface_change_notification.cpp	2014-06-27 09:18:41 +0000
@@ -56,6 +56,11 @@
     notify_scene_change();
 }
 
+// An orientation change alone is not enough to trigger recomposition.
+void ms::LegacySurfaceChangeNotification::orientation_set_to(MirOrientation /*orientation*/)
+{
+}
+
 void ms::LegacySurfaceChangeNotification::transformation_set_to(glm::mat4 const& /*t*/)
 {
     notify_scene_change();

=== modified file 'src/server/scene/legacy_surface_change_notification.h'
--- src/server/scene/legacy_surface_change_notification.h	2014-06-12 15:35:08 +0000
+++ src/server/scene/legacy_surface_change_notification.h	2014-06-27 09:18:41 +0000
@@ -42,6 +42,7 @@