Merge lp:~alan-griffiths/mir/msh_SystemCompositorWindowManager into lp:mir

[Alan Griffiths]

shell, examples: add a basic SystemCompositorWindowManager

shell, examples: add a basic SystemCompositorWindowManager

Ensures we have explicit support for the system-compositor use case. The following mir_demo_server config now offers a minimal "system compositor":

    $ cat ~/.config/mir/mir_demo_server.config
    file=/tmp/mir_socket
    arw-file=
    vt=1
    display-config=sidebyside
    window-manager=system-compositor

SystemCompositorWindowManager is slightly simplified from USC's WindowManager - mostly by removing the SessionMonitor references and providing hooks to reinstate the behaviour downstream.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2660
http://jenkins.qa.ubuntu.com/job/mir-ci/4082/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/2822
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/335
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/2770
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/238
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/238/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2770
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2770/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/5605
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/21147

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2661
http://jenkins.qa.ubuntu.com/job/mir-ci/4083/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/2823/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/336/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/2771/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/239/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2771/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2662
http://jenkins.qa.ubuntu.com/job/mir-ci/4085/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/2825
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/338
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/2773
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/241
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/241/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2773
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2773/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/5607
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/21152

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

review: Approve (continuous-integration)

[Alexandros Frantzis (afrantzis)]

Looks good.

I was a bit torn when I started reviewing this (not sure if it's worth the trouble and extra coupling), but I think this may be useful for simple products based on Mir. I still don't think it's worth doing this if it's just to simplify USC.

95 + /// Called the first time each surface owned by the session posts its first buffer

We have always assumed one surface per system-compositor client, so it's not clear what's the correct behavior if such a client creates and posts to multiple surfaces. I guess the proposed approach of always focusing the "default" surface is OK for now, but perhaps in the future on_session_ready method should be extended to also provide the surface that became ready.

review: Approve

[Alan Griffiths (alan-griffiths)]

> We have always assumed one surface per system-compositor client, so it's not
> clear what's the correct behavior if such a client creates and posts to
> multiple surfaces. I guess the proposed approach of always focusing the
> "default" surface is OK for now, but perhaps in the future on_session_ready
> method should be extended to also provide the surface that became ready.

What we actually have (c.f. the nested code and spinner) is one surface for each output for each system-compositor client.

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/mir-autolanding/1547/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/2849
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/362
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/2797
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-autolanding/102/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2797
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2797/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/5629
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/21198

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2665
http://jenkins.qa.ubuntu.com/job/mir-ci/4108/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/2860
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/373
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/2808
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/264
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/264/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2808
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2808/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/5638
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/21210

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

review: Approve (continuous-integration)

=== modified file 'examples/server_example_window_management.cpp'
--- examples/server_example_window_management.cpp	2015-05-19 21:34:34 +0000
+++ examples/server_example_window_management.cpp	2015-06-16 08:37:48 +0000
@@ -27,6 +27,7 @@
 #include "mir/input/composite_event_filter.h"
 #include "mir/options/option.h"
 #include "mir/shell/display_layout.h"
+#include "mir/shell/system_compositor_window_manager.h"
 
 namespace me = mir::examples;
 namespace mf = mir::frontend;
@@ -42,11 +43,12 @@
 namespace
 {
 char const* const wm_option = "window-manager";
-char const* const wm_description = "window management strategy [{tiling|fullscreen|canonical}]";
+char const* const wm_description = "window management strategy [{tiling|fullscreen|canonical|system-compositor}]";
 
 char const* const wm_tiling = "tiling";
 char const* const wm_fullscreen = "fullscreen";
 char const* const wm_canonical = "canonical";
+char const* const wm_system_compositor = "system-compositor";
 
 struct NullSessionInfo
 {
@@ -149,6 +151,13 @@
             {
                 return std::make_shared<CanonicalWindowManager>(focus_controller, server.the_shell_display_layout());
             }
+            else if (selection == wm_system_compositor)
+            {
+                return std::make_shared<msh::SystemCompositorWindowManager>(
+                    focus_controller,
+                    server.the_shell_display_layout(),
+                    server.the_session_coordinator());
+            }
 
             throw mir::AbnormalExit("Unknown window manager: " + selection);
         });

=== added file 'include/server/mir/shell/system_compositor_window_manager.h'
--- include/server/mir/shell/system_compositor_window_manager.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/shell/system_compositor_window_manager.h	2015-06-16 08:37:48 +0000
@@ -0,0 +1,99 @@
+/*
+ * Copyright © 2015 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_SHELL_SYSTEM_COMPOSITOR_WINDOW_MANAGER_H_
+#define MIR_SHELL_SYSTEM_COMPOSITOR_WINDOW_MANAGER_H_
+
+#include "mir/shell/window_manager.h"
+
+namespace mir
+{
+namespace scene { class PlacementStrategy; class SessionCoordinator; }
+namespace shell
+{
+class FocusController;
+class DisplayLayout;
+
+/** Minimal window management for system compositing.
+ */
+class SystemCompositorWindowManager : public WindowManager
+{
+public:
+    SystemCompositorWindowManager(
+        FocusController* focus_controller,
+        std::shared_ptr<shell::DisplayLayout> const& display_layout,
+        std::shared_ptr<scene::SessionCoordinator> const& session_coordinator);
+
+/** @name Customization points
+ * These are the likely events that a system compositor will care about
+ *  @{ */
+    /// Called when a session first connects (before any surfaces are ready)
+    virtual void on_session_added(std::shared_ptr<scene::Session> const& session) const;
+
+    /// Called when a session disconnects
+    virtual void on_session_removed(std::shared_ptr<scene::Session> const& session) const;
+
+    /// Called the first time each surface owned by the session posts its first buffer
+    virtual void on_session_ready(std::shared_ptr<scene::Session> const& session) const;
+/** @} */
+
+protected:
+    FocusController* const focus_controller;
+    std::shared_ptr<DisplayLayout> const display_layout;
+    std::shared_ptr<scene::SessionCoordinator> const session_coordinator;
+
+private:
+    void add_session(std::shared_ptr<scene::Session> const& session) override;
+
+    void remove_session(std::shared_ptr<scene::Session> const& session) override;
+
+    frontend::SurfaceId add_surface(
+        std::shared_ptr<scene::Session> const& session,
+        scene::SurfaceCreationParameters const& params,
+        std::function<frontend::SurfaceId(std::shared_ptr<scene::Session> const& session, scene::SurfaceCreationParameters const& params)> const& build) override;
+
+    void modify_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface,
+        SurfaceSpecification const& modifications) override;
+
+    void remove_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::weak_ptr<scene::Surface> const& surface) override;
+
+    void add_display(geometry::Rectangle const& area) override;
+
+    void remove_display(geometry::Rectangle const& area) override;
+
+    bool handle_keyboard_event(MirKeyboardEvent const* event) override;
+
+    bool handle_touch_event(MirTouchEvent const* event) override;
+
+    bool handle_pointer_event(MirPointerEvent const* event) override;
+
+    int set_surface_attribute(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface,
+        MirSurfaceAttrib attrib,
+        int value) override;
+};
+}
+}
+
+
+#endif /* MIR_SHELL_SYSTEM_COMPOSITOR_WINDOW_MANAGER_H_ */

=== modified file 'src/server/shell/CMakeLists.txt'
--- src/server/shell/CMakeLists.txt	2015-05-28 07:48:04 +0000
+++ src/server/shell/CMakeLists.txt	2015-06-16 08:37:48 +0000
@@ -10,6 +10,7 @@
   default_window_manager.cpp
   shell_wrapper.cpp
   surface_ready_observer.cpp
+  system_compositor_window_manager.cpp
   default_persistent_surface_store.cpp
   persistent_surface_store.cpp
 )

=== added file 'src/server/shell/system_compositor_window_manager.cpp'
--- src/server/shell/system_compositor_window_manager.cpp	1970-01-01 00:00:00 +0000
+++ src/server/shell/system_compositor_window_manager.cpp	2015-06-16 08:37:48 +0000
@@ -0,0 +1,151 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored By: Alan Griffiths <[e-mail]>
+ */
+
+#include "mir/shell/system_compositor_window_manager.h"
+
+#include "mir/shell/display_layout.h"
+#include "mir/shell/focus_controller.h"
+#include "mir/shell/surface_ready_observer.h"
+#include "mir/shell/surface_specification.h"
+
+#include "mir/scene/session.h"
+#include "mir/scene/session_coordinator.h"
+#include "mir/scene/surface.h"
+#include "mir/scene/surface_creation_parameters.h"
+
+namespace mf = mir::frontend;
+namespace ms = mir::scene;
+namespace msh = mir::shell;
+
+msh::SystemCompositorWindowManager::SystemCompositorWindowManager(
+    FocusController* focus_controller,
+    std::shared_ptr<DisplayLayout> const& display_layout,
+    std::shared_ptr<ms::SessionCoordinator> const& session_coordinator) :
+    focus_controller{focus_controller},
+    display_layout{display_layout},
+    session_coordinator{session_coordinator}
+{
+}
+
+void msh::SystemCompositorWindowManager::add_session(std::shared_ptr<ms::Session> const& session)
+{
+    on_session_added(session);
+}
+
+void msh::SystemCompositorWindowManager::remove_session(std::shared_ptr<ms::Session> const& session)
+{
+    on_session_removed(session);
+}
+
+auto msh::SystemCompositorWindowManager::add_surface(
+    std::shared_ptr<ms::Session> const& session,
+    ms::SurfaceCreationParameters const& params,
+    std::function<mf::SurfaceId(std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const& params)> const& build)
+-> mf::SurfaceId
+{
+    mir::geometry::Rectangle rect{params.top_left, params.size};
+
+    display_layout->place_in_output(params.output_id, rect);
+
+    auto placed_parameters = params;
+    placed_parameters.top_left = rect.top_left;
+    placed_parameters.size = rect.size;
+
+    auto const result = build(session, placed_parameters);
+    auto const surface = session->surface(result);
+
+    auto const session_ready_observer = std::make_shared<SurfaceReadyObserver>(
+        [this](std::shared_ptr<ms::Session> const& session, std::shared_ptr<ms::Surface> const& /*surface*/)
+            {
+                on_session_ready(session);
+            },
+        session,
+        surface);
+
+    surface->add_observer(session_ready_observer);
+
+    return result;
+}
+
+void msh::SystemCompositorWindowManager::modify_surface(
+    std::shared_ptr<ms::Session> const& /*session*/,
+    std::shared_ptr<ms::Surface> const& surface,
+    SurfaceSpecification const& modifications)
+{
+    if (modifications.name.is_set())
+        surface->rename(modifications.name.value());
+}
+
+void msh::SystemCompositorWindowManager::remove_surface(
+    std::shared_ptr<ms::Session> const& /*session*/,
+    std::weak_ptr<ms::Surface> const& /*surface*/)
+{
+}
+
+void msh::SystemCompositorWindowManager::add_display(mir::geometry::Rectangle const& /*area*/)
+{
+}
+
+void msh::SystemCompositorWindowManager::remove_display(mir::geometry::Rectangle const& /*area*/)
+{
+}
+
+bool msh::SystemCompositorWindowManager::handle_keyboard_event(MirKeyboardEvent const* /*event*/)
+{
+    return false;
+}
+
+bool msh::SystemCompositorWindowManager::handle_touch_event(MirTouchEvent const* /*event*/)
+{
+    return false;
+}
+
+bool msh::SystemCompositorWindowManager::handle_pointer_event(MirPointerEvent const* /*event*/)
+{
+    return false;
+}
+
+int msh::SystemCompositorWindowManager::set_surface_attribute(
+    std::shared_ptr<ms::Session> const& /*session*/,
+    std::shared_ptr<ms::Surface> const& surface,
+    MirSurfaceAttrib attrib,
+    int value)
+{
+    return surface->configure(attrib, value);
+}
+
+void msh::SystemCompositorWindowManager::on_session_added(std::shared_ptr<mir::scene::Session> const& /*session*/) const
+{
+}
+
+void msh::SystemCompositorWindowManager::on_session_removed(std::shared_ptr<mir::scene::Session> const& session) const
+{
+    if (focus_controller->focused_session() == session)
+    {
+        auto const next_session = session_coordinator->successor_of({});
+        if (next_session)
+            focus_controller->set_focus_to(next_session, next_session->default_surface());
+        else
+            focus_controller->set_focus_to(next_session, {});
+    }
+}
+
+void msh::SystemCompositorWindowManager::on_session_ready(std::shared_ptr<mir::scene::Session> const& session) const
+{
+    focus_controller->set_focus_to(session, session->default_surface());
+}

=== modified file 'src/server/symbols.map'
--- src/server/symbols.map	2015-06-10 23:37:28 +0000
+++ src/server/symbols.map	2015-06-16 08:37:48 +0000
@@ -5,7 +5,8 @@
     vtable?for?mir::input::NullInputDispatcher;
     VTT?for?mir::DefaultServerConfiguration;
     VTT?for?mir::shell::ShellWrapper;
-    
+    VTT?for?mir::shell::SystemCompositorWindowManager;
+
 # The following symbols come from running a script over the generated docs. Vis:
 # ../tools/process_doxygen_xml.py doc/xml/*.xml | grep "^mirserver public" | sed "s/mirserver public: /    /" | sort  
     mir::compositor::Compositor::Compositor*;
@@ -252,6 +253,34 @@
     mir::shell::ShellWrapper::surface_at*;
     mir::shell::SurfaceReadyObserver::SurfaceReadyObserver*;
     mir::shell::SurfaceReadyObserver::?SurfaceReadyObserver*;
+    mir::shell::SystemCompositorWindowManager::SystemCompositorWindowManager*;
+    mir::shell::SystemCompositorWindowManager::add_display*;
+    mir::shell::SystemCompositorWindowManager::add_prompt_provider_for*;
+    mir::shell::SystemCompositorWindowManager::add_session*;
+    mir::shell::SystemCompositorWindowManager::add_surface*;
+    mir::shell::SystemCompositorWindowManager::close_session*;
+    mir::shell::SystemCompositorWindowManager::create_surface*;
+    mir::shell::SystemCompositorWindowManager::destroy_surface*;
+    mir::shell::SystemCompositorWindowManager::focused_session*;
+    mir::shell::SystemCompositorWindowManager::focused_surface*;
+    mir::shell::SystemCompositorWindowManager::focus_next_session*;
+    mir::shell::SystemCompositorWindowManager::get_surface_attribute*;
+    mir::shell::SystemCompositorWindowManager::handle*;
+    mir::shell::SystemCompositorWindowManager::modify_surface*;
+    mir::shell::SystemCompositorWindowManager::on_session_added*;
+    mir::shell::SystemCompositorWindowManager::on_session_removed*;
+    mir::shell::SystemCompositorWindowManager::on_session_ready*;
+    mir::shell::SystemCompositorWindowManager::open_session*;
+    mir::shell::SystemCompositorWindowManager::raise*;
+    mir::shell::SystemCompositorWindowManager::remove_display*;
+    mir::shell::SystemCompositorWindowManager::remove_session*;
+    mir::shell::SystemCompositorWindowManager::remove_surface*;
+    mir::shell::SystemCompositorWindowManager::set_focus_to*;
+    mir::shell::SystemCompositorWindowManager::set_surface_attribute*;
+    mir::shell::SystemCompositorWindowManager::ShellWrapper*;
+    mir::shell::SystemCompositorWindowManager::start_prompt_session_for*;
+    mir::shell::SystemCompositorWindowManager::stop_prompt_session*;
+    mir::shell::SystemCompositorWindowManager::surface_at*;
     mir::shell::WindowManager::operator*;
     mir::shell::WindowManager::?WindowManager*;
     mir::shell::WindowManager::WindowManager*;
@@ -345,6 +374,29 @@
     non-virtual?thunk?to?mir::shell::ShellWrapper::stop_prompt_session*;
     non-virtual?thunk?to?mir::shell::ShellWrapper::surface_at*;
     non-virtual?thunk?to?mir::shell::SurfaceReadyObserver::?SurfaceReadyObserver*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::add_display*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::add_prompt_provider_for*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::close_session*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::create_surface*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::destroy_surface*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::focused_session*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::focused_surface*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::focus_next_session*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::get_surface_attribute*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::handle*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::modify_surface*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::on_session_added*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::on_session_removed*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::on_session_ready*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::open_session*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::raise*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::remove_display*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::set_focus_to*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::set_surface_attribute*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::ShellWrapper*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::start_prompt_session_for*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::stop_prompt_session*;
+    non-virtual?thunk?to?mir::shell::SystemCompositorWindowManager::surface_at*;
     non-virtual?thunk?to?mir::shell::WindowManager::?WindowManager*;
     non-virtual?thunk?to?mir::time::Alarm::?Alarm*;
     non-virtual?thunk?to?mir::time::AlarmFactory::?AlarmFactory*;
@@ -402,6 +454,7 @@
     typeinfo?for?mir::shell::Shell;
     typeinfo?for?mir::shell::ShellWrapper;
     typeinfo?for?mir::shell::SurfaceReadyObserver;
+    typeinfo?for?mir::shell::SystemCompositorWindowManager;
     typeinfo?for?mir::shell::WindowManager;
     typeinfo?for?mir::time::Alarm;
     typeinfo?for?mir::time::AlarmFactory;
@@ -459,6 +512,7 @@
     vtable?for?mir::shell::Shell;
     vtable?for?mir::shell::ShellWrapper;
     vtable?for?mir::shell::SurfaceReadyObserver;
+    vtable?for?mir::shell::SystemCompositorWindowManager;
     vtable?for?mir::shell::WindowManager;
     vtable?for?mir::time::Alarm;
     vtable?for?mir::time::AlarmFactory;

=== modified file 'tests/acceptance-tests/CMakeLists.txt'
--- tests/acceptance-tests/CMakeLists.txt	2015-06-11 09:41:30 +0000
+++ tests/acceptance-tests/CMakeLists.txt	2015-06-16 08:37:48 +0000
@@ -45,6 +45,7 @@
   test_surface_modifications.cpp
   test_surface_placement.cpp
   test_surface_morphing.cpp
+  test_system_compositor_window_manager.cpp
   test_session_mediator_report.cpp
 )
 

=== added file 'tests/acceptance-tests/test_system_compositor_window_manager.cpp'
--- tests/acceptance-tests/test_system_compositor_window_manager.cpp	1970-01-01 00:00:00 +0000
+++ tests/acceptance-tests/test_system_compositor_window_manager.cpp	2015-06-16 08:37:48 +0000
@@ -0,0 +1,205 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alan Griffiths <[e-mail]>
+ */
+
+#include "mir/shell/system_compositor_window_manager.h"
+#include "mir_toolkit/mir_client_library.h"
+
+#include "mir/geometry/rectangle.h"
+#include "mir_test_framework/headless_test.h"
+#include "mir_test/signal.h"
+
+#include "gmock/gmock.h"
+
+namespace msh = mir::shell;
+namespace mt = mir::test;
+namespace mtf = mir_test_framework;
+
+using namespace testing;
+using namespace std::chrono_literals;
+
+namespace
+{
+class SurfaceHandle
+{
+public:
+    explicit SurfaceHandle(MirSurface* surface) : surface{surface} {}
+    ~SurfaceHandle() { if (surface) mir_surface_release_sync(surface); }
+
+    operator MirSurface*() const { return surface; }
+
+    void post_buffer()
+    {
+        mir_buffer_stream_swap_buffers_sync(mir_surface_get_buffer_stream(surface));
+    }
+
+    SurfaceHandle(SurfaceHandle const&& that) : surface{that.surface} { surface = nullptr; }
+private:
+    SurfaceHandle(SurfaceHandle const&) = delete;
+    MirSurface* surface;
+};
+
+struct MockClient
+{
+    explicit MockClient(char const* connect_string) :
+        connection{mir_connect_sync(connect_string, __PRETTY_FUNCTION__)}
+    {
+    }
+
+    MockClient(MockClient&& source) :
+        connection{nullptr}
+    {
+        std::swap(connection, source.connection);
+    }
+
+    auto create_surface(int output_id) -> SurfaceHandle
+    {
+        auto const spec = mir_connection_create_spec_for_normal_surface(
+                connection, 800, 600, mir_pixel_format_bgr_888);
+
+        mir_surface_spec_set_fullscreen_on_output(spec, output_id);
+        auto const surface = mir_surface_create_sync(spec);
+        mir_surface_spec_release(spec);
+
+        mir_surface_set_event_handler(surface, on_surface_event, this);
+
+        return SurfaceHandle{surface};
+    };
+
+    void disconnect()
+    {
+        if (connection)
+            mir_connection_release(connection);
+
+        connection = nullptr;
+    }
+
+    ~MockClient() noexcept
+    {
+        disconnect();
+    }
+
+    MOCK_METHOD2(surface_event, void(MirSurface* surface, const MirEvent* event));
+
+private:
+    MirConnection* connection{nullptr};
+
+    static void on_surface_event(MirSurface* surface, const MirEvent* event, void* client_ptr)
+    {
+        static_cast<MockClient*>(client_ptr)->surface_event(surface, event);
+    }
+};
+
+struct SystemCompositorWindowManager : mtf::HeadlessTest
+{
+    void SetUp() override
+    {
+        add_to_environment("MIR_SERVER_NO_FILE", "");
+
+        initial_display_layout({{{0, 0}, { 640,  480}}, {{480, 0}, {1920, 1080}}});
+
+        server.override_the_window_manager_builder(
+            [this](msh::FocusController* focus_controller)
+            {
+                return std::make_shared<msh::SystemCompositorWindowManager>(
+                    focus_controller,
+                    server.the_shell_display_layout(),
+                    server.the_session_coordinator());
+            });
+
+        start_server();
+    }
+
+    void TearDown() override
+    {
+        stop_server();
+    }
+
+    MockClient connect_client()
+    {
+        return MockClient(new_connection().c_str());
+    }
+};
+
+MATCHER_P(MirFocusEvent, expected, "")
+{
+    if (mir_event_get_type(arg) != mir_event_type_surface)
+        return false;
+
+    auto surface_event = mir_event_get_surface_event(arg);
+    auto attrib = mir_surface_event_get_attribute(surface_event);
+    auto value = mir_surface_event_get_attribute_value(surface_event);
+
+    return (attrib == mir_surface_attrib_focus)
+        && (value == expected);
+}
+}
+
+TEST_F(SystemCompositorWindowManager, when_output_is_valid_surfaces_creation_succeeds)
+{
+    auto client = connect_client();
+
+    auto surface1 = client.create_surface(1);
+    auto surface2 = client.create_surface(2);
+
+    EXPECT_TRUE(mir_surface_is_valid(surface1));
+    EXPECT_TRUE(mir_surface_is_valid(surface2));
+}
+
+TEST_F(SystemCompositorWindowManager, when_output_ID_not_specified_surfaces_creation_fails)
+{
+    auto client = connect_client();
+
+    auto surface = client.create_surface(0);
+
+    EXPECT_FALSE(mir_surface_is_valid(surface));
+    EXPECT_THAT(mir_surface_get_error_message(surface), HasSubstr("Failed to place surface"));
+}
+
+TEST_F(SystemCompositorWindowManager, if_a_surface_posts_client_gets_focus)
+{
+    auto client = connect_client();
+
+    // Throw away all uninteresting surface events
+    EXPECT_CALL(client, surface_event(_, Not(MirFocusEvent(mir_surface_focused)))).Times(AnyNumber());
+
+    auto surface = client.create_surface(1);
+
+    mt::Signal signal;
+
+    EXPECT_CALL(client, surface_event(_, MirFocusEvent(mir_surface_focused))).Times(1)
+            .WillOnce(InvokeWithoutArgs([&] { signal.raise(); }));
+
+    surface.post_buffer();
+
+    signal.wait_for(1s);
+}
+
+TEST_F(SystemCompositorWindowManager, if_no_surface_posts_client_never_gets_focus)
+{
+    auto client = connect_client();
+    auto surface = client.create_surface(1);
+
+    mt::Signal signal;
+
+    ON_CALL(client, surface_event(_, MirFocusEvent(mir_surface_focused)))
+            .WillByDefault(InvokeWithoutArgs([&] { signal.raise(); }));
+
+    EXPECT_CALL(client, surface_event(_, MirFocusEvent(mir_surface_focused))).Times(0);
+
+    signal.wait_for(100ms);
+}