Merge lp:~andreas-pokorny/mir/nested-hardware-cursor into lp:mir

[Andreas Pokorny]

Add an option to specify the behavior of the nested cursor

The nested cursor previously only forwarded cursor image changes to the host compositor. That way the host compositor or shell is still in control of the position of the cursor. With this change now, the nested Cursor has a new mode of operation: Disabling the display of the host compositor and providing its own cursor as a separate stacked buffer stream.

Since the nested cursor is not blended into the nested display buffers, movement of the nested cursor does not cause a partial or full screen redraw inside the nested shell.

No request for review yet..

This is for testing the cursor mode in which the session shell controls the position but the system compositor draws the cursor.

tests still missing ..

[Andreas Pokorny (andreas-pokorny)]

review: Disapprove

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:3654
https://mir-jenkins.ubuntu.com/job/mir-ci/1690/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/2115/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/2177
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/2168
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/2168
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=yakkety/2168
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2143/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2143
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2143/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2143
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2143/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2143
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2143/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2143
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2143/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/1690/rebuild

review: Needs Fixing (continuous-integration)

[lp:~andreas-pokorny/mir/nested-hardware-cursor]

3655. By Andreas Pokorny on 2016-09-13

merge ci fixes

3656. By Andreas Pokorny on 2016-09-13

Trying with 10 seconds now

Unmerged revisions

3656. By Andreas Pokorny on 2016-09-13

Trying with 10 seconds now

3655. By Andreas Pokorny on 2016-09-13

merge ci fixes

3654. By Andreas Pokorny on 2016-09-12

merge lp:mir

3653. By Andreas Pokorny on 2016-09-07

Merge nested display changes from lp:mir

3652. By Andreas Pokorny on 2016-09-02

merge ci fix

3651. By Andreas Pokorny on 2016-09-01

merge startup race fixes

3650. By Andreas Pokorny on 2016-09-01

merge shutdown race fixes

3649. By Andreas Pokorny on 2016-09-01

merge lp:mir

3648. By Andreas Pokorny on 2016-08-16

Update cursor size needed to calculate cursor image bounds

3647. By Andreas Pokorny on 2016-08-13

merged bypass fix and more dbugging

=== modified file 'debian/control'
--- debian/control	2016-09-01 14:08:30 +0000
+++ debian/control	2016-09-13 09:13:43 +0000
@@ -69,7 +69,7 @@
 
 #TODO: Packaging infrastructure for better dependency generation,
 #      ala pkg-xorg's xviddriver:Provides and ABI detection.
-Package: libmirserver41
+Package: libmirserver42
 Section: libs
 Architecture: linux-any
 Multi-Arch: same
@@ -135,7 +135,7 @@
 Architecture: linux-any
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmirserver41 (= ${binary:Version}),
+Depends: libmirserver42 (= ${binary:Version}),
          libmirplatform-dev (= ${binary:Version}),
          libmircommon-dev (= ${binary:Version}),
          libglm-dev,
 
=== renamed file 'debian/libmirserver41.install' => 'debian/libmirserver42.install'
--- debian/libmirserver41.install	2016-06-30 11:36:23 +0000
+++ debian/libmirserver42.install	2016-09-13 09:13:43 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirserver.so.41
+usr/lib/*/libmirserver.so.42
 
=== modified file 'examples/render_surfaces.cpp'
--- examples/render_surfaces.cpp	2016-09-02 10:44:49 +0000
+++ examples/render_surfaces.cpp	2016-09-13 09:13:43 +0000
@@ -229,6 +229,8 @@
         virtual void paused() override {}
         virtual void resumed() override {}
         virtual void started() override {callback(); callback = []{}; }
+        virtual void ready_for_user_input() override {}
+        virtual void stop_receiving_input() override {}
 
         std::function<void()> callback;
     };
 
=== modified file 'include/server/mir/server_status_listener.h'
--- include/server/mir/server_status_listener.h	2013-10-15 09:22:41 +0000
+++ include/server/mir/server_status_listener.h	2016-09-13 09:13:43 +0000
@@ -29,6 +29,8 @@
     virtual void resumed() = 0;
     virtual void started() = 0;
 
+    virtual void ready_for_user_input() = 0;
+    virtual void stop_receiving_input() = 0;
 protected:
     ServerStatusListener() = default;
     virtual ~ServerStatusListener() = default;
 
=== modified file 'src/include/platform/mir/options/configuration.h'
--- src/include/platform/mir/options/configuration.h	2016-07-29 17:33:01 +0000
+++ src/include/platform/mir/options/configuration.h	2016-09-13 09:13:43 +0000
@@ -51,6 +51,7 @@
 extern char const* const nbuffers_opt;
 extern char const* const composite_delay_opt;
 extern char const* const enable_key_repeat_opt;
+extern char const* const control_host_cursor_opt;
 
 extern char const* const name_opt;
 
 
=== modified file 'src/include/server/mir/default_server_status_listener.h'
--- src/include/server/mir/default_server_status_listener.h	2015-02-22 07:46:25 +0000
+++ src/include/server/mir/default_server_status_listener.h	2016-09-13 09:13:43 +0000
@@ -37,6 +37,14 @@
     virtual void started()
     {
     }
+
+    virtual void ready_for_user_input()
+    {
+    }
+
+    virtual void stop_receiving_input()
+    {
+    }
 };
 }
 
 
=== modified file 'src/platform/options/default_configuration.cpp'
--- src/platform/options/default_configuration.cpp	2016-07-29 17:33:01 +0000
+++ src/platform/options/default_configuration.cpp	2016-09-13 09:13:43 +0000
@@ -52,6 +52,7 @@
 char const* const mo::nbuffers_opt                = "nbuffers";
 char const* const mo::composite_delay_opt         = "composite-delay";
 char const* const mo::enable_key_repeat_opt       = "enable-key-repeat";
+char const* const mo::control_host_cursor_opt     = "control-host-cursor";
 
 char const* const mo::off_opt_value = "off";
 char const* const mo::log_opt_value = "log";
@@ -150,6 +151,8 @@
             "Library to use for platform input support (default: input-stub.so)")
         (platform_path, po::value<std::string>()->default_value(MIR_SERVER_PLATFORM_PATH),
             "Directory to look for platform libraries (default: " MIR_SERVER_PLATFORM_PATH ")")
+        (control_host_cursor_opt,
+            "Control host cursor position from nested server")
         (enable_input_opt, po::value<bool>()->default_value(enable_input_default),
             "Enable input.")
         (compositor_report_opt, po::value<std::string>()->default_value(off_opt_value),
 
=== modified file 'src/platform/symbols.map'
--- src/platform/symbols.map	2016-09-02 16:51:10 +0000
+++ src/platform/symbols.map	2016-09-13 09:13:43 +0000
@@ -96,6 +96,7 @@
 # Why are server-only options here in libmirplatform?...
     mir::options::composite_delay_opt*; 
     mir::options::compositor_report_opt*;
+    mir::options::control_host_cursor_opt*;
     mir::options::Configuration::?Configuration*;
     mir::options::Configuration::Configuration*;
     mir::options::Configuration::operator*;
 
=== modified file 'src/platforms/mesa/server/kms/bypass.cpp'
--- src/platforms/mesa/server/kms/bypass.cpp	2016-08-24 02:09:08 +0000
+++ src/platforms/mesa/server/kms/bypass.cpp	2016-09-13 09:13:43 +0000
@@ -19,6 +19,7 @@
 #include "mir/graphics/renderable.h"
 #include "mir/graphics/display_buffer.h"
 #include "bypass.h"
+#include <iostream>
 
 using namespace mir;
 namespace mgm = mir::graphics::mesa;
@@ -35,8 +36,9 @@
     if (!bypass_is_feasible)
         return false;
 
+    mir::geometry::Rectangle const empty{};
     //offscreen surfaces don't affect if bypass is possible
-    if (!view_area.overlaps(renderable->screen_position()))
+    if (view_area.intersection_with(renderable->screen_position()) == empty)
         return false;
 
     auto const is_opaque = !((renderable->alpha() != 1.0f) || renderable->shaped());
 
=== modified file 'src/renderers/gl/renderer.cpp'
--- src/renderers/gl/renderer.cpp	2016-06-02 05:33:50 +0000
+++ src/renderers/gl/renderer.cpp	2016-09-13 09:13:43 +0000
@@ -36,6 +36,7 @@
 
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
+#include <iostream>
 #include <cmath>
 
 namespace mg = mir::graphics;
 
=== modified file 'src/server/CMakeLists.txt'
--- src/server/CMakeLists.txt	2016-08-08 03:22:02 +0000
+++ src/server/CMakeLists.txt	2016-09-13 09:13:43 +0000
@@ -124,7 +124,7 @@
   ${CMAKE_SOURCE_DIR}/include/server/mir DESTINATION "include/mirserver"
 )
 
-set(MIRSERVER_ABI 41) # Be sure to increment MIR_VERSION_MINOR at the same time
+set(MIRSERVER_ABI 42) # Be sure to increment MIR_VERSION_MINOR at the same time
 set(symbol_map ${CMAKE_CURRENT_SOURCE_DIR}/symbols.map)
 
 set_target_properties(
 
=== modified file 'src/server/graphics/default_configuration.cpp'
--- src/server/graphics/default_configuration.cpp	2016-07-26 03:56:14 +0000
+++ src/server/graphics/default_configuration.cpp	2016-09-13 09:13:43 +0000
@@ -228,11 +228,15 @@
             auto const my_name = options->is_set(options::name_opt) ?
                 options->get<std::string>(options::name_opt) :
                 "nested-mir@:" + server_socket;
+            auto const cursor_mode = options->is_set(options::control_host_cursor_opt) ?
+                mgn::MirClientHostConnection::CursorMode::ReplaceHostCursor :
+                mgn::MirClientHostConnection::CursorMode::ForwardCursorImage;
 
-            return std::make_shared<graphics::nested::MirClientHostConnection>(
+            return std::make_shared<mgn::MirClientHostConnection>(
                 host_socket,
                 my_name,
-                the_host_lifecycle_event_listener()
+                the_host_lifecycle_event_listener(),
+                cursor_mode
                 );
         });
 }
 
=== modified file 'src/server/graphics/nested/cursor.cpp'
--- src/server/graphics/nested/cursor.cpp	2016-01-29 08:18:22 +0000
+++ src/server/graphics/nested/cursor.cpp	2016-09-13 09:13:43 +0000
@@ -35,8 +35,9 @@
 {
 }
 
-void mgn::Cursor::move_to(geom::Point)
+void mgn::Cursor::move_to(geom::Point pos)
 {
+    connection->set_cursor_position(pos);
 }
 
 void mgn::Cursor::show(mg::CursorImage const& cursor_image)
 
=== modified file 'src/server/graphics/nested/display_buffer.cpp'
--- src/server/graphics/nested/display_buffer.cpp	2016-08-25 13:34:29 +0000
+++ src/server/graphics/nested/display_buffer.cpp	2016-09-13 09:13:43 +0000
@@ -52,6 +52,7 @@
     mg::BufferProperties properties(output.extents().size, output.current_format, mg::BufferUsage::hardware);
     return connection.create_surface(
         host_stream, mir::geometry::Displacement{0, 0}, properties,
+        output.extents(),
         surface_title.str().c_str(), static_cast<uint32_t>(output.id.as_value()));
 }
 }
 
=== modified file 'src/server/graphics/nested/host_connection.h'
--- src/server/graphics/nested/host_connection.h	2016-09-01 16:26:31 +0000
+++ src/server/graphics/nested/host_connection.h	2016-09-13 09:13:43 +0000
@@ -60,9 +60,11 @@
         std::shared_ptr<HostStream> const& stream,
         geometry::Displacement stream_displacement,
         graphics::BufferProperties properties,
+        geometry::Rectangle const& extents,
         char const* name, uint32_t output_id) = 0;
 
     virtual void set_cursor_image(CursorImage const& image) = 0;
+    virtual void set_cursor_position(geometry::Point const& pos) = 0;
     virtual void hide_cursor() = 0;
     virtual auto graphics_platform_library() -> std::string = 0;
 
 
=== modified file 'src/server/graphics/nested/input_platform.cpp'
--- src/server/graphics/nested/input_platform.cpp	2016-07-07 09:59:19 +0000
+++ src/server/graphics/nested/input_platform.cpp	2016-09-13 09:13:43 +0000
@@ -217,6 +217,7 @@
 
             if (event_type == mir_event_type_input)
             {
+                std::lock_guard<std::mutex> lock(devices_guard);
                 auto const* input_ev = mir_event_get_input_event(&event);
                 auto const id = mir_input_event_get_device_id(input_ev);
                 auto it = devices.find(id);
@@ -234,6 +235,7 @@
             }
             else if (event_type == mir_event_type_input_device_state)
             {
+                std::lock_guard<std::mutex> lock(devices_guard);
                 if (!devices.empty())
                 {
                     auto const* device_state = mir_event_get_input_device_state_event(&event);
@@ -270,6 +272,7 @@
     std::function<void(MirEvent const&, mir::geometry::Rectangle const&)> empty_event_callback;
     connection->set_input_event_callback(empty_event_callback);
 
+    std::lock_guard<std::mutex> lock(devices_guard);
     for(auto const& device : devices)
         input_device_registry->remove_device(device.second);
 
 
=== modified file 'src/server/graphics/nested/mir_client_host_connection.cpp'
--- src/server/graphics/nested/mir_client_host_connection.cpp	2016-09-01 16:26:31 +0000
+++ src/server/graphics/nested/mir_client_host_connection.cpp	2016-09-13 09:13:43 +0000
@@ -24,6 +24,7 @@
 #include "mir/raii.h"
 #include "mir/graphics/platform_operation_message.h"
 #include "mir/graphics/cursor_image.h"
+#include "mir/geometry/point.h"
 #include "mir/input/device.h"
 #include "mir/input/device_capability.h"
 #include "mir/input/pointer_configuration.h"
@@ -44,6 +45,7 @@
 namespace mgn = mir::graphics::nested;
 namespace mi = mir::input;
 namespace mf = mir::frontend;
+namespace geom = mir::geometry;
 
 namespace
 {
@@ -90,15 +92,13 @@
     }
 }
 
-class MirClientHostSurface : public mgn::HostSurface
+class BasicHostSurface : public mgn::HostSurface
 {
 public:
-    MirClientHostSurface(
-        MirConnection* mir_connection,
-        MirSurfaceSpec* spec)
-        : mir_connection(mir_connection),
-          mir_surface{
-              mir_surface_create_sync(spec)}
+    BasicHostSurface(MirConnection* mir_connection,
+                     MirSurfaceSpec* spec,
+                     std::shared_ptr<mgn::HostStream> const& stream)
+        : mir_connection(mir_connection), mir_surface(mir_surface_create_sync(spec)), main_stream(stream)
     {
         if (!mir_surface_is_valid(mir_surface))
         {
@@ -107,16 +107,15 @@
         }
     }
 
-    ~MirClientHostSurface()
+    ~BasicHostSurface()
     {
-        if (cursor) mir_buffer_stream_release_sync(cursor);
+        destroy_cursor();
         mir_surface_release_sync(mir_surface);
     }
 
     EGLNativeWindowType egl_native_window() override
     {
-        return reinterpret_cast<EGLNativeWindowType>(
-            mir_buffer_stream_get_egl_native_window(mir_surface_get_buffer_stream(mir_surface)));
+        return main_stream->egl_native_window();
     }
 
     void set_event_handler(mir_surface_event_callback cb, void* context) override
@@ -124,7 +123,12 @@
         mir_surface_set_event_handler(mir_surface, cb, context);
     }
 
-    void set_cursor_image(mg::CursorImage const& image)
+    virtual void set_cursor_image(mg::CursorImage const& image) = 0;
+    virtual void set_cursor_position(geom::Point const&) = 0;
+    virtual void hide_cursor() = 0;
+
+protected:
+    bool update_cursor(mg::CursorImage const& image)
     {
         auto const image_width = image.size().width.as_int();
         auto const image_height = image.size().height.as_int();
@@ -132,7 +136,7 @@
         if ((image_width <= 0) || (image_height <= 0))
         {
             hide_cursor();
-            return;
+            return true;
         }
 
         MirGraphicsRegion g;
@@ -166,9 +170,43 @@
 
         mir_buffer_stream_swap_buffers_sync(cursor);
 
-        if (new_cursor || cursor_hotspot != image.hotspot())
-        {
-            cursor_hotspot = image.hotspot();
+        return new_cursor;
+    }
+
+    void destroy_cursor()
+    {
+        if (cursor)
+        {
+            mir_buffer_stream_release_sync(cursor);
+            cursor = nullptr;
+        }
+    }
+
+    MirConnection* const mir_connection;
+    MirSurface* const mir_surface;
+    std::shared_ptr<mgn::HostStream> const main_stream;
+    MirBufferStream* cursor{nullptr};
+
+};
+
+class CursorConfigurationHostSurface : public BasicHostSurface
+{
+public:
+    CursorConfigurationHostSurface(
+        MirConnection* connection,
+        MirSurfaceSpec* spec,
+        std::shared_ptr<mgn::HostStream> const& stream)
+        : BasicHostSurface(connection, spec, stream)
+    {
+    }
+
+    void set_cursor_image(mg::CursorImage const& image) override
+    {
+        bool new_cursor = update_cursor(image);
+
+        if (new_cursor)
+        {
+            auto cursor_hotspot = image.hotspot();
 
             auto conf = mir_cursor_configuration_from_buffer_stream(
                 cursor, cursor_hotspot.dx.as_int(), cursor_hotspot.dy.as_int());
@@ -178,20 +216,103 @@
         }
     }
 
-    void hide_cursor()
-    {
-        if (cursor) { mir_buffer_stream_release_sync(cursor); cursor = nullptr; }
-
-        auto conf = mir_cursor_configuration_from_name(mir_disabled_cursor_name);
-        mir_surface_configure_cursor(mir_surface, conf);
-        mir_cursor_configuration_destroy(conf);
-    }
-
+    void set_cursor_position(geom::Point const&) override
+    {
+    }
+
+    void hide_cursor() override
+    {
+        destroy_cursor();
+        auto conf = mir_cursor_configuration_from_name(mir_disabled_cursor_name);
+        mir_surface_configure_cursor(mir_surface, conf);
+        mir_cursor_configuration_destroy(conf);
+    }
+};
+
+class BufferStreamCursorHostSurface : public BasicHostSurface
+{
+public:
+    BufferStreamCursorHostSurface(
+        MirConnection* mir_connection,
+        MirSurfaceSpec* spec,
+        std::shared_ptr<mgn::HostStream> const stream,
+        geom::Rectangle const& extents)
+        : BasicHostSurface(mir_connection, spec, stream),
+          extents{extents}
+    {
+        // hide cursor in surface:
+        auto conf = mir_cursor_configuration_from_name(mir_disabled_cursor_name);
+        mir_surface_configure_cursor(mir_surface, conf);
+        mir_cursor_configuration_destroy(conf);
+    }
+
+    void set_cursor_image(mg::CursorImage const& image)
+    {
+        bool force_update = update_cursor(image);
+        cursor_size = image.size();
+        update_cursor_position(force_update, cursor_position, image.hotspot());
+    }
+
+    void set_cursor_position(geom::Point const& pos) override
+    {
+        if (pos != cursor_position && cursor)
+        {
+            update_cursor_position(false, pos, cursor_hotspot);
+        }
+    }
+
+    void update_cursor_position(bool force_update, geom::Point const& pos, geom::Displacement const& new_hotspot)
+    {
+        auto old_cursor_bounds = geom::Rectangle{cursor_position - cursor_hotspot, cursor_size};
+        auto new_cursor_bounds = geom::Rectangle{pos - new_hotspot, cursor_size};
+        auto stream_position = new_cursor_bounds.top_left - extents.top_left;
+        auto was_visible = extents.overlaps(old_cursor_bounds);
+        auto is_visible = extents.overlaps(new_cursor_bounds);
+        auto changed = force_update || pos != cursor_position || cursor_hotspot != new_hotspot;
+
+        if (changed)
+        {
+            cursor_hotspot = new_hotspot;
+            cursor_position = pos;
+        }
+
+        if (was_visible && !is_visible)
+        {
+            hide_cursor();
+        }
+        else if (changed && is_visible)
+        {
+            std::unique_ptr<MirSurfaceSpec, void(*)(MirSurfaceSpec *)> spec{
+                mir_connection_create_spec_for_changes(mir_connection),
+                    mir_surface_spec_release};
+
+            MirBufferStreamInfo infos[2] =
+            {
+                {main_stream->handle(), 0, 0},
+                {cursor, stream_position.dx.as_int(), stream_position.dy.as_int()}
+            };
+            mir_surface_spec_set_streams(spec.get(), infos, 2);
+
+            mir_surface_apply_spec(mir_surface, spec.get());
+        }
+    }
+
+    void hide_cursor() override
+    {
+        std::unique_ptr<MirSurfaceSpec, void(*)(MirSurfaceSpec *)> spec{
+            mir_connection_create_spec_for_changes(mir_connection),
+            mir_surface_spec_release};
+
+        MirBufferStreamInfo stream = {main_stream->handle(), 0, 0};
+        mir_surface_spec_set_streams(spec.get(), &stream, 1);
+
+        mir_surface_apply_spec(mir_surface, spec.get());
+    }
 private:
-    MirConnection* const mir_connection;
-    MirSurface* const mir_surface;
-    MirBufferStream* cursor{nullptr};
     mir::geometry::Displacement cursor_hotspot;
+    geom::Rectangle extents;
+    geom::Point cursor_position;
+    geom::Size cursor_size;
 };
 
 class MirClientHostStream : public mgn::HostStream
@@ -261,11 +382,13 @@
 mgn::MirClientHostConnection::MirClientHostConnection(
     std::string const& host_socket,
     std::string const& name,
-    std::shared_ptr<msh::HostLifecycleEventListener> const& host_lifecycle_event_listener)
+    std::shared_ptr<msh::HostLifecycleEventListener> const& host_lifecycle_event_listener,
+    CursorMode cursor_mode)
     : mir_connection{mir_connect_sync(host_socket.c_str(), name.c_str())},
       conf_change_callback{[]{}},
       host_lifecycle_event_listener{host_lifecycle_event_listener},
-      event_callback{[](MirEvent const&, mir::geometry::Rectangle const&){}}
+      event_callback{[](MirEvent const&, mir::geometry::Rectangle const&){}},
+      cursor_mode{cursor_mode}
 {
     if (!mir_connection_is_valid(mir_connection))
     {
@@ -340,8 +463,10 @@
     std::shared_ptr<HostStream> const& stream,
     mir::geometry::Displacement displacement,
     mg::BufferProperties properties,
+    geometry::Rectangle const& extents,
     char const* name, uint32_t output_id)
 {
+    // TODO pass down Displacement
     std::lock_guard<std::mutex> lg(surfaces_mutex);
     auto spec = mir::raii::deleter_for(
         mir_connection_create_spec_for_normal_surface(
@@ -352,7 +477,7 @@
         mir_surface_spec_release);
 
     MirBufferUsage usage = (properties.usage == mg::BufferUsage::hardware) ?
-        mir_buffer_usage_hardware : mir_buffer_usage_software; 
+        mir_buffer_usage_hardware : mir_buffer_usage_software;
 
     mir_surface_spec_set_name(spec.get(), name);
     mir_surface_spec_set_buffer_usage(spec.get(), usage);
@@ -360,16 +485,31 @@
     MirBufferStreamInfo info { stream->handle(), displacement.dx.as_int(), displacement.dy.as_int() };
     mir_surface_spec_set_streams(spec.get(), &info, 1);
 
-    auto surf = std::shared_ptr<MirClientHostSurface>(
-        new MirClientHostSurface(mir_connection, spec.get()),
-        [this](MirClientHostSurface *surf)
-        {
-            std::lock_guard<std::mutex> lg(surfaces_mutex);
-            auto it = std::find(surfaces.begin(), surfaces.end(), surf);
-            surfaces.erase(it);
-            delete surf;
-        });
-
+    std::shared_ptr<BasicHostSurface> surf;
+    if (cursor_mode == CursorMode::ReplaceHostCursor)
+    {
+        surf = std::shared_ptr<BasicHostSurface>(
+            new BufferStreamCursorHostSurface(mir_connection, spec.get(), stream, extents),
+            [this](BufferStreamCursorHostSurface *surf)
+            {
+                std::lock_guard<std::mutex> lg(surfaces_mutex);
+                auto it = std::find(surfaces.begin(), surfaces.end(), surf);
+                surfaces.erase(it);
+                delete surf;
+            });
+    }
+    else
+    {
+        surf = std::shared_ptr<BasicHostSurface>(
+            new CursorConfigurationHostSurface(mir_connection, spec.get(), stream),
+            [this](CursorConfigurationHostSurface *surf)
+            {
+                std::lock_guard<std::mutex> lg(surfaces_mutex);
+                auto it = std::find(surfaces.begin(), surfaces.end(), surf);
+                surfaces.erase(it);
+                delete surf;
+            });
+    }
     if (stored_cursor_image.size().width.as_int() * stored_cursor_image.size().height.as_int())
         surf->set_cursor_image(stored_cursor_image);
 
@@ -409,20 +549,32 @@
 void mgn::MirClientHostConnection::set_cursor_image(mg::CursorImage const& image)
 {
     std::lock_guard<std::mutex> lg(surfaces_mutex);
+
     stored_cursor_image = image;
+
     for (auto s : surfaces)
     {
-        auto surface = static_cast<MirClientHostSurface*>(s);
+        auto surface = static_cast<BasicHostSurface*>(s);
         surface->set_cursor_image(stored_cursor_image);
     }
 }
 
+void mgn::MirClientHostConnection::set_cursor_position(geom::Point const& pos)
+{
+    std::lock_guard<std::mutex> lg(surfaces_mutex);
+    for (auto s : surfaces)
+    {
+        auto surface = static_cast<BasicHostSurface*>(s);
+        surface->set_cursor_position(pos);
+    }
+}
+
 void mgn::MirClientHostConnection::hide_cursor()
 {
     std::lock_guard<std::mutex> lg(surfaces_mutex);
     for (auto s : surfaces)
     {
-        auto surface = static_cast<MirClientHostSurface*>(s);
+        auto surface = static_cast<BasicHostSurface*>(s);
         surface->hide_cursor();
     }
 }
 
=== modified file 'src/server/graphics/nested/mir_client_host_connection.h'
--- src/server/graphics/nested/mir_client_host_connection.h	2016-09-01 16:26:31 +0000
+++ src/server/graphics/nested/mir_client_host_connection.h	2016-09-13 09:13:43 +0000
@@ -54,9 +54,16 @@
 class MirClientHostConnection : public HostConnection
 {
 public:
+    enum class CursorMode
+    {
+        ForwardCursorImage,
+        ReplaceHostCursor
+    };
+
     MirClientHostConnection(std::string const& host_socket,
                             std::string const& name,
-                            std::shared_ptr<msh::HostLifecycleEventListener> const& host_lifecycle_event_listener);
+                            std::shared_ptr<msh::HostLifecycleEventListener> const& host_lifecycle_event_listener,
+                            CursorMode mode);
     ~MirClientHostConnection();
 
     std::vector<int> platform_fd_items() override;
@@ -67,11 +74,13 @@
         std::shared_ptr<HostStream> const& stream,
         geometry::Displacement stream_displacement,
         graphics::BufferProperties properties,
+        geometry::Rectangle const& extents,
         char const* name, uint32_t output_id) override;
     void set_display_config_change_callback(std::function<void()> const& cb) override;
     void apply_display_config(MirDisplayConfiguration&) override;
 
     void set_cursor_image(CursorImage const& image) override;
+    void set_cursor_position(geometry::Point const& pos) override;
     void hide_cursor() override;
     auto graphics_platform_library() -> std::string override;
 
@@ -114,6 +123,7 @@
         std::vector<uint8_t> buffer;
     };
     NestedCursorImage stored_cursor_image;
+    CursorMode cursor_mode;
 };
 
 }
 
=== modified file 'src/server/input/default_configuration.cpp'
--- src/server/input/default_configuration.cpp	2016-07-28 23:00:22 +0000
+++ src/server/input/default_configuration.cpp	2016-09-13 09:13:43 +0000
@@ -361,7 +361,8 @@
                the_input_reading_multiplexer(),
                the_main_loop(),
                the_cookie_authority(),
-               the_key_mapper());
+               the_key_mapper(),
+               the_server_status_listener());
 
            if (key_repeater && !the_options()->is_set(options::host_socket_opt))
                key_repeater->set_input_device_hub(hub);
 
=== modified file 'src/server/input/default_input_device_hub.cpp'
--- src/server/input/default_input_device_hub.cpp	2016-07-07 09:59:19 +0000
+++ src/server/input/default_input_device_hub.cpp	2016-09-13 09:13:43 +0000
@@ -22,6 +22,7 @@
 #include "mir/input/input_device.h"
 #include "mir/input/input_device_observer.h"
 #include "mir/geometry/point.h"
+#include "mir/server_status_listener.h"
 #include "mir/dispatch/multiplexing_dispatchable.h"
 #include "mir/dispatch/action_queue.h"
 #include "mir/frontend/event_sink.h"
@@ -44,7 +45,8 @@
     std::shared_ptr<dispatch::MultiplexingDispatchable> const& input_multiplexer,
     std::shared_ptr<mir::ServerActionQueue> const& observer_queue,
     std::shared_ptr<mir::cookie::Authority> const& cookie_authority,
-    std::shared_ptr<mi::KeyMapper> const& key_mapper)
+    std::shared_ptr<mi::KeyMapper> const& key_mapper,
+    std::shared_ptr<mir::ServerStatusListener> const& server_status_listener)
     : seat{seat},
       sink{sink},
       input_dispatchable{input_multiplexer},
@@ -52,6 +54,7 @@
       device_queue(std::make_shared<dispatch::ActionQueue>()),
       cookie_authority(cookie_authority),
       key_mapper(key_mapper),
+      server_status_listener(server_status_listener),
       device_id_generator{0}
 {
     input_dispatchable->add_watch(device_queue);
@@ -264,6 +267,12 @@
         observer->device_added(handles.back());
         observer->changes_complete();
     }
+
+    if (!ready && handles.size())
+    {
+        server_status_listener->ready_for_user_input();
+        ready = true;
+    }
 }
 
 void mi::DefaultInputDeviceHub::remove_device_handle(MirInputDeviceId id)
@@ -289,4 +298,10 @@
 
     handles.erase(handle_it, end(handles));
     sink->handle_input_device_change(handles);
+
+    if (ready && 0 == handles.size())
+    {
+        ready = false;
+        server_status_listener->stop_receiving_input();
+    }
 }
 
=== modified file 'src/server/input/default_input_device_hub.h'
--- src/server/input/default_input_device_hub.h	2016-07-07 09:59:19 +0000
+++ src/server/input/default_input_device_hub.h	2016-09-13 09:13:43 +0000
@@ -37,6 +37,7 @@
 namespace mir
 {
 class ServerActionQueue;
+class ServerStatusListener;
 namespace frontend
 {
 class EventSink;
@@ -67,7 +68,8 @@
                           std::shared_ptr<dispatch::MultiplexingDispatchable> const& input_multiplexer,
                           std::shared_ptr<ServerActionQueue> const& observer_queue,
                           std::shared_ptr<cookie::Authority> const& cookie_authority,
-                          std::shared_ptr<KeyMapper> const& key_mapper);
+                          std::shared_ptr<KeyMapper> const& key_mapper,
+                          std::shared_ptr<ServerStatusListener> const& server_status_listener);
 
     // InputDeviceRegistry - calls from mi::Platform
     void add_device(std::shared_ptr<InputDevice> const& device) override;
@@ -91,6 +93,7 @@
     std::shared_ptr<dispatch::ActionQueue> const device_queue;
     std::shared_ptr<cookie::Authority> const cookie_authority;
     std::shared_ptr<KeyMapper> const key_mapper;
+    std::shared_ptr<ServerStatusListener> const server_status_listener;
 
     struct RegisteredDevice : public InputSink
     {
@@ -124,6 +127,7 @@
     std::vector<std::shared_ptr<InputDeviceObserver>> observers;
 
     MirInputDeviceId device_id_generator;
+    bool ready{false};
 };
 
 }
 
=== modified file 'src/server/symbols.map'
--- src/server/symbols.map	2016-08-26 19:01:27 +0000
+++ src/server/symbols.map	2016-09-13 09:13:43 +0000
@@ -1,4 +1,4 @@
-MIR_SERVER_0.24 {
+MIR_SERVER_0.25 {
  global:
   extern "C++" {
 # Symbols not yet picked up by script
@@ -176,6 +176,7 @@
     mir::Server::override_the_logger*;
     mir::Server::override_the_prompt_session_listener*;
     mir::Server::override_the_prompt_session_manager*;
+    mir::Server::override_the_seat_report*;
     mir::Server::override_the_server_status_listener*;
     mir::Server::override_the_session_authorizer*;
     mir::Server::override_the_session_listener*;
@@ -835,10 +836,3 @@
   };
  local: *;
 };
-
-MIR_SERVER_0.25 {
- global:
-  extern "C++" {
-    mir::Server::override_the_seat_report*;
-  };
-} MIR_SERVER_0.24;
 
=== modified file 'tests/acceptance-tests/test_nested_mir.cpp'
--- tests/acceptance-tests/test_nested_mir.cpp	2016-08-26 11:25:15 +0000
+++ tests/acceptance-tests/test_nested_mir.cpp	2016-09-13 09:13:43 +0000
@@ -24,10 +24,12 @@
 #include "mir/graphics/display_configuration.h"
 #include "mir/graphics/display_configuration_policy.h"
 #include "mir/graphics/display_configuration_report.h"
+#include "mir/input/input_device_info.h"
 #include "mir/shell/shell.h"
 #include "mir/input/cursor_listener.h"
 #include "mir/cached_ptr.h"
 #include "mir/main_loop.h"
+#include "mir/server_status_listener.h"
 #include "mir/scene/session_coordinator.h"
 #include "mir/scene/session.h"
 #include "mir/scene/surface.h"
@@ -37,8 +39,10 @@
 
 #include "mir_test_framework/headless_in_process_server.h"
 #include "mir_test_framework/using_stub_client_platform.h"
+#include "mir_test_framework/stub_server_platform_factory.h"
 #include "mir_test_framework/headless_nested_server_runner.h"
 #include "mir_test_framework/any_surface.h"
+#include "mir_test_framework/fake_input_device.h"
 #include "mir/test/signal.h"
 #include "mir/test/spin_wait.h"
 #include "mir/test/display_config_matchers.h"
@@ -50,12 +54,14 @@
 #include "mir/test/doubles/nested_mock_egl.h"
 #include "mir/test/fake_shared.h"
 
+#include <future>
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
 namespace geom = mir::geometry;
 namespace mf = mir::frontend;
 namespace mg = mir::graphics;
+namespace mi = mir::input;
 namespace msh = mir::shell;
 namespace mt = mir::test;
 namespace mtd = mir::test::doubles;
@@ -67,6 +73,23 @@
 
 namespace
 {
+struct InputReadyServerStatusListener : mir::ServerStatusListener
+{
+    std::shared_ptr<std::promise<void>> const input_ready;
+    InputReadyServerStatusListener(std::shared_ptr<std::promise<void>> const& promise)
+        : input_ready(promise)
+    {}
+
+    void paused() override {}
+    void resumed() override {}
+    void started() override {}
+    void ready_for_user_input() override
+    {
+        input_ready->set_value();
+    }
+    void stop_receiving_input() override {}
+};
+
 struct MockSessionMediatorReport : mf::SessionMediatorReport
 {
     MockSessionMediatorReport()
@@ -127,6 +150,7 @@
 };
 
 std::chrono::seconds const timeout{5};
+std::chrono::seconds const long_timeout{10};
 
 // We can't rely on the test environment to have X cursors, so we provide some of our own
 auto const cursor_names = {
@@ -403,10 +427,21 @@
             { return std::make_shared<NiceMock<MockDisplayConfigurationPolicy>>(); });
     }
 
+    void wait_until_ready()
+    {
+        auto future_status = ready_for_input->get_future().wait_for(10s);
+
+        if (future_status != std::future_status::ready)
+            BOOST_THROW_EXCEPTION(std::runtime_error("Nested Server never started"));
+    }
+
 protected:
     NestedMirRunner(std::string const& connection_string, bool)
         : mtf::HeadlessNestedServerRunner(connection_string)
     {
+        server.override_the_server_status_listener([this]
+            { return std::make_shared<InputReadyServerStatusListener>(ready_for_input); });
+
         server.override_the_host_lifecycle_event_listener([this]
             { return the_mock_host_lifecycle_event_listener(); });
 
@@ -422,14 +457,19 @@
 
 private:
     mir::CachedPtr<MockHostLifecycleEventListener> mock_host_lifecycle_event_listener;
-    
     mir::CachedPtr<MockDisplayConfigurationPolicy> mock_display_configuration_policy_;
+    std::shared_ptr<std::promise<void>> ready_for_input = std::make_shared<std::promise<void>>();
+    mir::UniqueModulePtr<mtf::FakeInputDevice> fake_device{mtf::add_fake_input_device(mi::InputDeviceInfo{
+        "test-devce", "test-device",
+        mi::DeviceCapability::pointer | mi::DeviceCapability::keyboard | mi::DeviceCapability::alpha_numeric})};
 };
 
 struct NestedServer : mtf::HeadlessInProcessServer
 {
     mtd::NestedMockEGL mock_egl;
     mtf::UsingStubClientPlatform using_stub_client_platform;
+    mt::Signal condition;
+    mt::Signal test_processed_result;
 
     std::shared_ptr<MockSessionMediatorReport> mock_session_mediator_report;
     NiceMock<MockDisplay> display{display_geometry};
@@ -906,38 +946,43 @@
 
     server.the_cursor_listener()->cursor_moved_to(489, 9);
 
-    // TODO workaround for lp:1523621
-    // (I don't see a way to detect that the host has placed focus on "Mir nested display for output #1")
-    std::this_thread::sleep_for(10ms);
-
-    {
-        mt::Signal condition;
-        EXPECT_CALL(*mock_cursor, show(_)).Times(1)
-            .WillRepeatedly(InvokeWithoutArgs([&] { condition.raise(); }));
-
-        auto conf = mir_cursor_configuration_from_buffer_stream(client.buffer_stream, 0, 0);
-        mir_wait_for(mir_surface_configure_cursor(client.surface, conf));
-        mir_cursor_configuration_destroy(conf);
-
-        condition.wait_for(timeout);
-        Mock::VerifyAndClearExpectations(mock_cursor.get());
-    }
+    nested_mir.wait_until_ready();
+
+    // FIXME: In this test setup the software cursor will trigger scene_changed() on show(...).
+    // Thus a new frame will be composed. Then a "FramePostObserver" in basic_surface.cpp will
+    // react to the frame_posted callback by setting the cursor buffer again via show(..)
+    // The number of show calls depends solely on scheduling decisions
+    EXPECT_CALL(*mock_cursor, show(_)).Times(AtLeast(frames))
+        .WillRepeatedly(InvokeWithoutArgs(
+                    [&]
+                    {
+                        condition.raise();
+                        test_processed_result.wait_for(timeout);
+                        test_processed_result.reset();
+                    }));
+
+    auto conf = mir_cursor_configuration_from_buffer_stream(client.buffer_stream, 0, 0);
+    mir_wait_for(mir_surface_configure_cursor(client.surface, conf));
+    mir_cursor_configuration_destroy(conf);
+
+    EXPECT_TRUE(condition.wait_for(timeout));
+    condition.reset();
+    test_processed_result.raise();
 
     for (int i = 0; i != frames; ++i)
     {
-        mt::Signal condition;
-        EXPECT_CALL(*mock_cursor, show(_)).Times(1)
-            .WillRepeatedly(InvokeWithoutArgs([&] { condition.raise(); }));
-
         mir_buffer_stream_swap_buffers_sync(client.buffer_stream);
 
-        condition.wait_for(timeout);
-        Mock::VerifyAndClearExpectations(mock_cursor.get());
+        EXPECT_TRUE(condition.wait_for(timeout));
+        condition.reset();
+        test_processed_result.raise();
     }
+    Mock::VerifyAndClearExpectations(mock_cursor.get());
 }
 
 TEST_F(NestedServer, named_cursor_image_changes_are_forwarded_to_host)
 {
+    mt::Signal condition;
     NestedMirRunner nested_mir{new_connection()};
 
     ClientWithAPaintedSurface client(nested_mir);
@@ -945,25 +990,32 @@
 
     server.the_cursor_listener()->cursor_moved_to(489, 9);
 
-    // TODO workaround for lp:1523621
-    // (I don't see a way to detect that the host has placed focus on "Mir nested display for output #1")
-    std::this_thread::sleep_for(1s);
-    Mock::VerifyAndClearExpectations(mock_cursor.get());
+    nested_mir.wait_until_ready();
+
+    // FIXME: In this test setup the software cursor will trigger scene_changed() on show(...).
+    // Thus a new frame will be composed. Then a "FramePostObserver" in basic_surface.cpp will
+    // react to the frame_posted callback by setting the cursor buffer again via show(..)
+    // The number of show calls depends solely on scheduling decisions
+    EXPECT_CALL(*mock_cursor, show(_)).Times(AtLeast(cursor_names.size()))
+            .WillRepeatedly(InvokeWithoutArgs(
+                    [&]
+                    {
+                        condition.raise();
+                        test_processed_result.wait_for(long_timeout);
+                        test_processed_result.reset();
+                    }));
 
     for (auto const name : cursor_names)
     {
-        mt::Signal condition;
-
-        EXPECT_CALL(*mock_cursor, show(_)).Times(1)
-            .WillOnce(InvokeWithoutArgs([&] { condition.raise(); }));
-
         auto const cursor = mir_cursor_configuration_from_name(name);
         mir_wait_for(mir_surface_configure_cursor(client.surface, cursor));
         mir_cursor_configuration_destroy(cursor);
 
-        condition.wait_for(timeout);
-        Mock::VerifyAndClearExpectations(mock_cursor.get());
+        EXPECT_TRUE(condition.wait_for(long_timeout));
+        condition.reset();
+        test_processed_result.raise();
     }
+    Mock::VerifyAndClearExpectations(mock_cursor.get());
 }
 
 TEST_F(NestedServer, can_hide_the_host_cursor)
@@ -976,22 +1028,23 @@
 
     server.the_cursor_listener()->cursor_moved_to(489, 9);
 
-    // TODO workaround for lp:1523621
-    // (I don't see a way to detect that the host has placed focus on "Mir nested display for output #1")
-    std::this_thread::sleep_for(10ms);
-
-    {
-        mt::Signal condition;
-        EXPECT_CALL(*mock_cursor, show(_)).Times(1)
-            .WillRepeatedly(InvokeWithoutArgs([&] { condition.raise(); }));
-
-        auto conf = mir_cursor_configuration_from_buffer_stream(client.buffer_stream, 0, 0);
-        mir_wait_for(mir_surface_configure_cursor(client.surface, conf));
-        mir_cursor_configuration_destroy(conf);
-
-        condition.wait_for(timeout);
-        Mock::VerifyAndClearExpectations(mock_cursor.get());
-    }
+    nested_mir.wait_until_ready();
+    Mock::VerifyAndClearExpectations(mock_cursor.get());
+
+    // FIXME: In this test setup the software cursor will trigger scene_changed() on show(...).
+    // Thus a new frame will be composed. Then a "FramePostObserver" in basic_surface.cpp will
+    // react to the frame_posted callback by setting the cursor buffer again via show(..)
+    // The number of show calls depends solely on scheduling decisions
+    EXPECT_CALL(*mock_cursor, show(_)).Times(AtLeast(1))
+        .WillOnce(mt::WakeUp(&condition));
+
+    auto conf = mir_cursor_configuration_from_buffer_stream(client.buffer_stream, 0, 0);
+    mir_wait_for(mir_surface_configure_cursor(client.surface, conf));
+    mir_cursor_configuration_destroy(conf);
+
+    std::this_thread::sleep_for(500ms);
+    condition.wait_for(timeout);
+    Mock::VerifyAndClearExpectations(mock_cursor.get());
 
     nested_mir.cursor_wrapper->set_hidden(true);
 
 
=== modified file 'tests/include/mir/test/doubles/mock_server_status_listener.h'
--- tests/include/mir/test/doubles/mock_server_status_listener.h	2013-10-15 09:22:41 +0000
+++ tests/include/mir/test/doubles/mock_server_status_listener.h	2016-09-13 09:13:43 +0000
@@ -36,6 +36,8 @@
     MOCK_METHOD0(paused, void());
     MOCK_METHOD0(resumed, void());
     MOCK_METHOD0(started, void());
+    MOCK_METHOD0(ready_for_user_input, void());
+    MOCK_METHOD0(stop_receiving_input, void());
 };
 
 }
 
=== modified file 'tests/include/mir/test/doubles/stub_host_connection.h'
--- tests/include/mir/test/doubles/stub_host_connection.h	2016-09-01 16:26:31 +0000
+++ tests/include/mir/test/doubles/stub_host_connection.h	2016-09-13 09:13:43 +0000
@@ -66,7 +66,7 @@
     std::shared_ptr<graphics::nested::HostSurface>
         create_surface(
             std::shared_ptr<graphics::nested::HostStream> const&, geometry::Displacement,
-            graphics::BufferProperties, char const*, uint32_t) override
+            graphics::BufferProperties, geometry::Rectangle const& , char const*, uint32_t) override
     {
         return surface;
     }
@@ -83,6 +83,9 @@
     void hide_cursor() override
     {
     }
+    void set_cursor_position(geometry::Point const&) override
+    {
+    }
 
     auto graphics_platform_library() -> std::string override { return {}; }
 
@@ -118,7 +121,7 @@
         void set_event_handler(mir_surface_event_callback, void*) override {}
     };
     std::shared_ptr<graphics::nested::HostSurface> const surface;
-    
+
     std::shared_ptr<MirBuffer> create_buffer(graphics::BufferProperties const&)
     {
         return nullptr;
 
=== modified file 'tests/integration-tests/input/test_single_seat_setup.cpp'
--- tests/integration-tests/input/test_single_seat_setup.cpp	2016-07-28 23:00:22 +0000
+++ tests/integration-tests/input/test_single_seat_setup.cpp	2016-09-13 09:13:43 +0000
@@ -27,6 +27,7 @@
 #include "mir/test/doubles/mock_cursor_listener.h"
 #include "mir/test/doubles/mock_event_sink.h"
 #include "mir/test/doubles/mock_seat_report.h"
+#include "mir/test/doubles/mock_server_status_listener.h"
 #include "mir/test/doubles/triggered_main_loop.h"
 #include "mir/test/event_matchers.h"
 #include "mir/test/doubles/advanceable_clock.h"
@@ -82,6 +83,7 @@
     NiceMock<mtd::MockCursorListener> mock_cursor_listener;
     NiceMock<mtd::MockTouchVisualizer> mock_visualizer;
     NiceMock<mtd::MockSeatReport> mock_seat_report;
+    NiceMock<mtd::MockServerStatusListener> mock_status_listener;
     mi::receiver::XKBMapper key_mapper;
     mir::dispatch::MultiplexingDispatchable multiplexer;
     mtd::AdvanceableClock clock;
@@ -90,7 +92,7 @@
         mt::fake_shared(mock_region), mt::fake_shared(key_mapper), mt::fake_shared(clock), mt::fake_shared(mock_seat_report)};
     mi::DefaultInputDeviceHub hub{
         mt::fake_shared(mock_sink), mt::fake_shared(seat), mt::fake_shared(multiplexer), mt::fake_shared(observer_loop),
-        cookie_authority, mt::fake_shared(key_mapper)};
+        cookie_authority, mt::fake_shared(key_mapper), mt::fake_shared(mock_status_listener)};
     NiceMock<mtd::MockInputDeviceObserver> mock_observer;
 
     mi::DeviceCapabilities const keyboard_caps = mi::DeviceCapability::keyboard | mi::DeviceCapability::alpha_numeric;
 
=== modified file 'tests/mir_test_framework/testing_server_options.cpp'
--- tests/mir_test_framework/testing_server_options.cpp	2016-05-03 06:55:25 +0000
+++ tests/mir_test_framework/testing_server_options.cpp	2016-09-13 09:13:43 +0000
@@ -119,6 +119,8 @@
             server_started_sync.try_signal_ready_for();
             on_start();
         }
+        void ready_for_user_input() {}
+        void stop_receiving_input() {}
 
         mt::CrossProcessSync server_started_sync;
         std::function<void(void)> const on_start;
 
=== modified file 'tests/unit-tests/input/test_default_input_device_hub.cpp'
--- tests/unit-tests/input/test_default_input_device_hub.cpp	2016-06-02 08:20:22 +0000
+++ tests/unit-tests/input/test_default_input_device_hub.cpp	2016-09-13 09:13:43 +0000
@@ -25,6 +25,7 @@
 #include "mir/test/doubles/mock_input_seat.h"
 #include "mir/test/doubles/mock_event_sink.h"
 #include "mir/test/doubles/mock_key_mapper.h"
+#include "mir/test/doubles/mock_server_status_listener.h"
 #include "mir/test/doubles/stub_cursor_listener.h"
 #include "mir/test/doubles/stub_touch_visualizer.h"
 #include "mir/test/doubles/triggered_main_loop.h"
@@ -81,8 +82,9 @@
     NiceMock<mtd::MockInputSeat> mock_seat;
     NiceMock<mtd::MockEventSink> mock_sink;
     NiceMock<mtd::MockKeyMapper> mock_key_mapper;
+    NiceMock<mtd::MockServerStatusListener> mock_server_status_listener;
     mi::DefaultInputDeviceHub hub{mt::fake_shared(mock_sink), mt::fake_shared(mock_seat), mt::fake_shared(multiplexer),
-                                  mt::fake_shared(observer_loop), cookie_authority, mt::fake_shared(mock_key_mapper)};
+                                  mt::fake_shared(observer_loop), cookie_authority, mt::fake_shared(mock_key_mapper), mt::fake_shared(mock_server_status_listener)};
     NiceMock<mtd::MockInputDeviceObserver> mock_observer;
     NiceMock<mtd::MockInputDevice> device{"device","dev-1", mi::DeviceCapability::unknown};
     NiceMock<mtd::MockInputDevice> another_device{"another_device","dev-2", mi::DeviceCapability::keyboard};
@@ -210,3 +212,22 @@
     observer_loop.trigger_server_actions();
 }
 
+TEST_F(InputDeviceHubTest, emit_ready_to_receive_input_after_first_device_added)
+{
+    EXPECT_CALL(mock_server_status_listener, ready_for_user_input()).Times(1);
+    hub.add_device(mt::fake_shared(device));
+    hub.add_device(mt::fake_shared(another_device));
+
+    observer_loop.trigger_server_actions();
+}
+
+TEST_F(InputDeviceHubTest, emit_stop_receiving_input_after_last_device_added)
+{
+    EXPECT_CALL(mock_server_status_listener, stop_receiving_input()).Times(1);
+    hub.add_device(mt::fake_shared(device));
+    hub.add_device(mt::fake_shared(another_device));
+
+    hub.remove_device(mt::fake_shared(device));
+    hub.remove_device(mt::fake_shared(another_device));
+    observer_loop.trigger_server_actions();
+}