Mir

Merge lp:~alan-griffiths/mir/MVC-introduce-default-controller-object into lp:mir

MVC-introduce-default-controller-object
Merge into development-branch

Proposed by Alan Griffiths on 2015-01-19

Status:	Merged
Approved by:	Alexandros Frantzis on 2015-01-22
Approved revision:	2240
Merged at revision:	2250
Proposed branch:	lp:~alan-griffiths/mir/MVC-introduce-default-controller-object
Merge into:	lp:mir
Prerequisite:	lp:~alan-griffiths/mir/MVC-cleanup-of-frontend
Diff against target:	1401 lines (+542/-338) 19 files modified include/server/mir/scene/session_coordinator.h (+40/-4) include/server/mir/shell/session_coordinator_wrapper.h (+13/-29) server-ABI-sha1sums (+2/-2) src/include/server/mir/default_server_configuration.h (+5/-0) src/server/scene/default_configuration.cpp (+0/-13) src/server/scene/session_manager.cpp (+22/-120) src/server/scene/session_manager.h (+11/-40) src/server/shell/CMakeLists.txt (+1/-0) src/server/shell/default_configuration.cpp (+25/-1) src/server/shell/default_shell.cpp (+178/-0) src/server/shell/default_shell.h (+94/-0) src/server/shell/session_coordinator_wrapper.cpp (+13/-45) src/server/symbols.map (+2/-0) tests/acceptance-tests/server_configuration_wrapping.cpp (+3/-3) tests/acceptance-tests/test_client_focus_notification.cpp (+1/-0) tests/acceptance-tests/test_prompt_session_client_api.cpp (+1/-1) tests/integration-tests/CMakeLists.txt (+1/-1) tests/integration-tests/test_default_shell.cpp (+27/-30) tests/unit-tests/scene/test_session_manager.cpp (+103/-49)
To merge this branch:	bzr merge lp:~alan-griffiths/mir/MVC-introduce-default-controller-object
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot	continuous-integration		Approve on 2015-01-22
Robert Carr (community)			Approve on 2015-01-21
Alexandros Frantzis (community)			Approve on 2015-01-21
Daniel van Vugt			Needs Information on 2015-01-21
Alberto Aguirre		2015-01-19	Approve on 2015-01-20
Review via email: mp+246924@code.launchpad.net

Commit Message

shell, scene: introduce a "Controller" into shell and shift window management logic there from scene

Description of the Change

shell, scene: introduce a "Controller" into shell and shift window management logic there from scene

I hope thins to start simplifying after this - my next target is the removal of FocusSetter/DefaultFocusMechanism and their integration into DefaultShell.

This doesn't make the "DefaultShell" controller customizable - that, and other cleanup is for a future MP

PS Jenkins bot (ps-jenkins) wrote on 2015-01-20:

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

review: Needs Fixing (continuous-integration)

Alan Griffiths (alan-griffiths) wrote on 2015-01-20:

mako-08 AWOL again - retriggering

PS Jenkins bot (ps-jenkins) wrote on 2015-01-20:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-01-20:

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

review: Approve (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-01-20:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-01-20:

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

review: Needs Fixing (continuous-integration)

Alberto Aguirre (albaguirre) wrote on 2015-01-20:

OK.

review: Approve

Daniel van Vugt (vanvugt) wrote on 2015-01-21:

That's a bit disappointing. It's this ugliness by previous branch was designed to avoid:
13 + auto const surface = std::dynamic_pointer_cast<ms::Surface>(session->get_surface(surface_id));
And yet we've landed it already.

On a different note; are there plans to move Shell out of frontend? Why is it there?

review: Needs Information

Alan Griffiths (alan-griffiths) wrote on 2015-01-21:

> That's a bit disappointing. It's this ugliness by previous branch was designed
> to avoid:
> 13 + auto const surface =
> std::dynamic_pointer_cast<ms::Surface>(session->get_surface(surface_id));
> And yet we've landed it already.

Agreed, the ugliness hasn't been addressed (yet). But the point of this MP is to separate the window management logic from the model code. I'm trying to keep other (needed) refactoring out of the MP until the consolidation of "controller" functionality is in place.

> On a different note; are there plans to move Shell out of frontend? Why is it
> there?

I'm sure you've asked this question before. The answer is still the same:

No, the frontend::Shell interface defines the needs of frontend and hence belongs there.

Alan Griffiths (alan-griffiths) wrote on 2015-01-21:

>
W: Failed to fetch http://archive.ubuntu.com/ubuntu/dists/vivid/universe/i18n/Translation-en Hash Sum mismatch

unrelated CI error

lp:~alan-griffiths/mir/MVC-introduce-default-controller-object updated on 2015-01-21

2240. By Alan Griffiths on 2015-01-21: merge lp:mir

Alexandros Frantzis (afrantzis) wrote on 2015-01-21:

Looks good as an intermediate step.

review: Approve

PS Jenkins bot (ps-jenkins) wrote on 2015-01-21:

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

review: Needs Fixing (continuous-integration)

Alan Griffiths (alan-griffiths) wrote on 2015-01-21:

> Building remotely on cloud-worker-11 in workspace /var/lib/jenkins/slaves/cloud-worker-11/workspace/mir-android-vivid-i386-build
...
> [ 51%] Building CXX object tests/acceptance-tests/throwback/CMakeFiles/acceptance-test-throwback.dir/test_custom_input_dispatcher.cpp.o
> Build timed out (after 120 minutes). Marking the build as failed.
> Build was aborted

cloud-worker-11 timing out again

Retriggering

Robert Carr (robertcarr) wrote on 2015-01-21:

review: Approve

PS Jenkins bot (ps-jenkins) wrote on 2015-01-21:

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

review: Needs Fixing (continuous-integration)

Alberto Aguirre (albaguirre) wrote on 2015-01-22:

"FATAL: Unable to delete script file /tmp/hudson3556432461291323175.sh
hudson.util.IOException2: remote file operation failed: /tmp/hudson3556432461291323175.sh at hudson.remoting.Channel@4e966112:cloud-worker-11"

Re-triggering

PS Jenkins bot (ps-jenkins) wrote on 2015-01-22:

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

review: Needs Fixing (continuous-integration)

Daniel van Vugt (vanvugt) wrote on 2015-01-22:

> No, the frontend::Shell interface defines the needs of frontend and hence
> belongs there.

I don't think that's a good answer. A "shell" is something that will be implemented by other people. And those other people should not know or care what the internal term "frontend" means to the Mir source code.

Alan Griffiths (alan-griffiths) wrote on 2015-01-22:

>
Building remotely on cloud-worker-11 in workspace /var/lib/jenkins/slaves/cloud-worker-11/workspace/mir-android-vivid-i386-build
...

> [ 51%] Building CXX object tests/mir_test_doubles/CMakeFiles/mir-test-doubles.dir/test_protobuf_client.cpp.o
> FATAL: Unable to delete script file /tmp/hudson6153692886848568188.sh
> hudson.util.IOException2: remote file operation failed: /tmp/hudson6153692886848568188.sh at hudson.remoting.Channel@5ba6b35d:cloud-worker-11

Our old friend cloud-worker-11 :(

Alan Griffiths (alan-griffiths) wrote on 2015-01-22:

> > No, the frontend::Shell interface defines the needs of frontend and hence
> > belongs there.
>
> I don't think that's a good answer. A "shell" is something that will be
> implemented by other people. And those other people should not know or care
> what the internal term "frontend" means to the Mir source code.

1. I don't see how any of this tired discussion is relevant to landing this MP
2. Putting the interface with the code that uses it is policy (although not followed very strictly - but we are fixing that)
3. frontend::Shell is not a definition of "something that will be implemented by other people" it is a definition of what that would need to do to support frontend.
4. "something that will be implemented by other people" will have to support other components too - e.g. to handle changes to outputs it needs to support graphics::DisplayConfigurationPolicy

There is nothing that prevents us having:

shell::Shell : public graphics::DisplayConfigurationPolicy, public frontend::Shell, ...

Alexandros Frantzis (afrantzis) wrote on 2015-01-22:

All parts of the request for information have been either addressed adequately (we agree that std::dynamic_cast<> is not ideal and will be fixed in a future MP), or are tangential to this MP (frontend::Shell discussion) and therefore not blockers anyway, so I am going to top approve.

PS Jenkins bot (ps-jenkins) on 2015-01-22:

review: Approve (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Alan Griffiths

Emanuele Antonio Faraone

Gerry Boland

Mir development team

 === modified file 'include/server/mir/scene/session_coordinator.h'
 --- include/server/mir/scene/session_coordinator.h	2015-01-14 06:39:13 +0000
 +++ include/server/mir/scene/session_coordinator.h	2015-01-21 10:18:06 +0000
@@ -19,17 +19,53 @@
  #ifndef MIR_SCENE_SESSION_COORDINATOR_H_
  #define MIR_SCENE_SESSION_COORDINATOR_H_
--
--#include "mir/frontend/shell.h"
--#include "mir/shell/focus_controller.h"
++#include "mir/frontend/surface_id.h"
++
++#include "mir_toolkit/common.h"
++
++#include <memory>
  namespace mir
+ {
++namespace frontend
++{
++class EventSink;
++}
++
  namespace scene
+ {
++class PromptSession;
++class PromptSessionCreationParameters;
++class Session;
++class Surface;
++class SurfaceCreationParameters;
--class SessionCoordinator : public frontend::Shell, public shell::FocusController
++class SessionCoordinator
+ {
++public:
++    virtual void set_focus_to(std::shared_ptr<Session> const& focus) = 0;
++    virtual void unset_focus() = 0;
++
++    virtual std::shared_ptr<Session> open_session(
++        pid_t client_pid,
++        std::string const& name,
++        std::shared_ptr<frontend::EventSink> const& sink) = 0;
++
++    virtual void close_session(std::shared_ptr<Session> const& session)  = 0;
++
++    virtual std::shared_ptr<Session> successor_of(std::shared_ptr<Session> const&) const = 0;
++
++    virtual std::shared_ptr<PromptSession> start_prompt_session_for(std::shared_ptr<Session> const& session,
++                                                                  PromptSessionCreationParameters const& params) = 0;
++    virtual void add_prompt_provider_for(std::shared_ptr<PromptSession> const& prompt_session,
++                                                                  std::shared_ptr<Session> const& session) = 0;
++    virtual void stop_prompt_session(std::shared_ptr<PromptSession> const& prompt_session) = 0;
++
++protected:
++    SessionCoordinator() = default;
++    virtual ~SessionCoordinator() = default;
++    SessionCoordinator(SessionCoordinator const&) = delete;
++    SessionCoordinator& operator=(SessionCoordinator const&) = delete;
  };
+ }
 === modified file 'include/server/mir/shell/session_coordinator_wrapper.h'
 --- include/server/mir/shell/session_coordinator_wrapper.h	2015-01-19 11:36:40 +0000
 +++ include/server/mir/shell/session_coordinator_wrapper.h	2015-01-21 10:18:06 +0000
@@ -31,43 +31,27 @@
  public:
      SessionCoordinatorWrapper(std::shared_ptr<scene::SessionCoordinator> const& wrapped);
--    virtual std::shared_ptr<frontend::Session> open_session(
++    virtual std::shared_ptr<scene::Session> open_session(
          pid_t client_pid,
          std::string const& name,
          std::shared_ptr<frontend::EventSink> const& sink) override;
--    virtual void close_session(std::shared_ptr<frontend::Session> const& session) override;
--
--    void focus_next() override;
--    std::weak_ptr<scene::Session> focussed_application() const override;
++    virtual void close_session(std::shared_ptr<scene::Session> const& session) override;
++
++    std::shared_ptr<scene::Session> successor_of(std::shared_ptr<scene::Session> const&) const override;
++
      void set_focus_to(std::shared_ptr<scene::Session> const& focus) override;
--
--    void handle_surface_created(std::shared_ptr<frontend::Session> const& session) override;
--
--    std::shared_ptr<frontend::PromptSession> start_prompt_session_for(
--        std::shared_ptr<frontend::Session> const& session,
++    void unset_focus() override;
++
++    std::shared_ptr<scene::PromptSession> start_prompt_session_for(
++        std::shared_ptr<scene::Session> const& session,
          scene::PromptSessionCreationParameters const& params) override;
      void add_prompt_provider_for(
--        std::shared_ptr<frontend::PromptSession> const& prompt_session,
--        std::shared_ptr<frontend::Session> const& session) override;
--
--    void stop_prompt_session(std::shared_ptr<frontend::PromptSession> const& prompt_session) override;
--
--    frontend::SurfaceId create_surface(std::shared_ptr<frontend::Session> const& session, scene::SurfaceCreationParameters const& params) override;
--
--    void destroy_surface(std::shared_ptr<frontend::Session> const& session, frontend::SurfaceId surface) override;
--
--    int set_surface_attribute(
--        std::shared_ptr<frontend::Session> const& session,
--        frontend::SurfaceId surface_id,
--        MirSurfaceAttrib attrib,
--        int value) override;
--
--    int get_surface_attribute(
--        std::shared_ptr<frontend::Session> const& session,
--        frontend::SurfaceId surface_id,
--        MirSurfaceAttrib attrib) override;
++        std::shared_ptr<scene::PromptSession> const& prompt_session,
++        std::shared_ptr<scene::Session> const& session) override;
++
++    void stop_prompt_session(std::shared_ptr<scene::PromptSession> const& prompt_session) override;
  protected:
      std::shared_ptr<scene::SessionCoordinator> const wrapped;
 === modified file 'server-ABI-sha1sums'
 --- server-ABI-sha1sums	2015-01-21 08:38:18 +0000
 +++ server-ABI-sha1sums	2015-01-21 10:18:06 +0000
@@ -90,7 +90,7 @@
  b657cfb8fb31140b83b78fc19135dd0165ede67b  include/server/mir/scene/prompt_session.h
  a745a63d413ced63b82350b8c253b65dffd5bf44  include/server/mir/scene/prompt_session_listener.h
  a09a3f18ecea53dc45386c1e2baf545c4177c047  include/server/mir/scene/prompt_session_manager.h
--5edf446380070f567500069e422d293e88468ee5  include/server/mir/scene/session_coordinator.h
++d812335ef394d076952db04d1560f1f4a3159510  include/server/mir/scene/session_coordinator.h
 cb940e808eca7db115239a25167955d34acafc4  include/server/mir/scene/session.h
  ee94083f10f890e24c0e0bbdb94842e2dd788deb  include/server/mir/scene/session_listener.h
 f5f26000fd2312373817d05c488a6a950a47c82  include/server/mir/scene/snapshot.h
@@ -107,7 +107,7 @@
 a2107b01feae13060d5c305804906e53c52e0be  include/server/mir/shell/focus_controller.h
  f8d415af54b4a477338fb9dbe20db01aa4544029  include/server/mir/shell/host_lifecycle_event_listener.h
 f50c37bb8e36a1aa4918af6aa01b0f032ed0984  include/server/mir/shell/input_targeter.h
--a46723e246b4cb6619cf8abbedb02c3391f563c9  include/server/mir/shell/session_coordinator_wrapper.h
++abb366424a9e09a75e5e68c67095f0b9bbe8eb54  include/server/mir/shell/session_coordinator_wrapper.h
 e869c5b87ab8be4bc185d2cd55a93d699cde72  include/server/mir/shell/surface_coordinator_wrapper.h
 cc8c0b12ee4fd78d86c8f3309546e4dc68c9f  include/server/mir/terminate_with_current_exception.h
 b8c2a763c8f5f00b737c3a187db2304676f8076  include/server/mir/time/alarm.h
 === modified file 'src/include/server/mir/default_server_configuration.h'
 --- src/include/server/mir/default_server_configuration.h	2015-01-14 06:39:13 +0000
 +++ src/include/server/mir/default_server_configuration.h	2015-01-21 10:18:06 +0000
@@ -75,6 +75,7 @@
  class FocusController;
  class DisplayLayout;
  class HostLifecycleEventListener;
++class DefaultShell;
+ }
  namespace time
+ {
@@ -438,6 +439,10 @@
      std::shared_ptr<scene::BroadcastingSessionEventSink> the_broadcasting_session_event_sink();
      auto report_factory(char const* report_opt) -> std::unique_ptr<report::ReportFactory>;
++
++    // TODO properly expose a shell::Shell interface
++    CachedPtr<shell::DefaultShell> default_shell;
++    auto the_shell() -> std::shared_ptr<shell::DefaultShell>;
  };
+ }
 === modified file 'src/server/scene/default_configuration.cpp'
 --- src/server/scene/default_configuration.cpp	2015-01-14 06:39:13 +0000
 +++ src/server/scene/default_configuration.cpp	2015-01-21 10:18:06 +0000
@@ -179,7 +179,6 @@
                  std::make_shared<ms::SessionManager>(
                      the_surface_coordinator(),
                      the_session_container(),
--                    the_shell_focus_setter(),
                      the_snapshot_strategy(),
                      the_session_event_sink(),
                      the_session_listener(),
@@ -194,18 +193,6 @@
      return wrapped;
+ }
--std::shared_ptr<mf::Shell>
--mir::DefaultServerConfiguration::the_frontend_shell()
--{
--    return the_session_coordinator();
--}
--
--std::shared_ptr<msh::FocusController>
--mir::DefaultServerConfiguration::the_focus_controller()
--{
--    return the_session_coordinator();
--}
--
  std::shared_ptr<ms::PixelBuffer>
  mir::DefaultServerConfiguration::the_pixel_buffer()
+ {
 === modified file 'src/server/scene/session_manager.cpp'
 --- src/server/scene/session_manager.cpp	2015-01-19 11:36:40 +0000
 +++ src/server/scene/session_manager.cpp	2015-01-21 10:18:06 +0000
@@ -21,7 +21,6 @@
  #include "session_container.h"
  #include "mir/scene/surface.h"
  #include "mir/scene/surface_coordinator.h"
--#include "mir/shell/focus_setter.h"
  #include "mir/scene/session.h"
  #include "mir/scene/session_listener.h"
  #include "mir/scene/prompt_session.h"
@@ -41,14 +40,12 @@
  ms::SessionManager::SessionManager(std::shared_ptr<SurfaceCoordinator> const& surface_factory,
      std::shared_ptr<SessionContainer> const& container,
--    std::shared_ptr<msh::FocusSetter> const& focus_setter,
      std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
      std::shared_ptr<SessionEventSink> const& session_event_sink,
      std::shared_ptr<SessionListener> const& session_listener,
      std::shared_ptr<PromptSessionManager> const& prompt_session_manager) :
      surface_coordinator(surface_factory),
      app_container(container),
--    focus_setter(focus_setter),
      snapshot_strategy(snapshot_strategy),
      session_event_sink(session_event_sink),
      session_listener(session_listener),
@@ -56,7 +53,6 @@
+ {
      assert(surface_factory);
      assert(container);
--    assert(focus_setter);
      assert(session_listener);
+ }
@@ -80,7 +76,7 @@
          close_session(session);
+ }
--std::shared_ptr<mf::Session> ms::SessionManager::open_session(
++std::shared_ptr<ms::Session> ms::SessionManager::open_session(
      pid_t client_pid,
      std::string const& name,
      std::shared_ptr<mf::EventSink> const& sender)
@@ -93,37 +89,22 @@
      session_listener->starting(new_session);
--    set_focus_to(new_session);
--
      return new_session;
+ }
--inline void ms::SessionManager::set_focus_to_locked(std::unique_lock<std::mutex> const&, std::shared_ptr<Session> const& session)
--{
--    auto old_focus = focus_application.lock();
--
--    focus_application = session;
--
--    focus_setter->set_focus_to(session);
--    if (session)
--    {
--        session_event_sink->handle_focus_change(session);
--        session_listener->focused(session);
--    }
--    else
--    {
--        session_event_sink->handle_no_focus();
--        session_listener->unfocused();
--    }
--}
--
  void ms::SessionManager::set_focus_to(std::shared_ptr<Session> const& session)
+ {
--    std::unique_lock<std::mutex> lg(mutex);
--    set_focus_to_locked(lg, session);
--}
--
--void ms::SessionManager::close_session(std::shared_ptr<mf::Session> const& session)
++    session_event_sink->handle_focus_change(session);
++    session_listener->focused(session);
++}
++
++void ms::SessionManager::unset_focus()
++{
++    session_event_sink->handle_no_focus();
++    session_listener->unfocused();
++}
++
++void ms::SessionManager::close_session(std::shared_ptr<Session> const& session)
+ {
      auto scene_session = std::dynamic_pointer_cast<Session>(session);
@@ -136,37 +117,9 @@
      session_listener->stopping(scene_session);
      app_container->remove_session(scene_session);
--
--    std::unique_lock<std::mutex> lock(mutex);
--    set_focus_to_locked(lock, app_container->successor_of(std::shared_ptr<Session>()));
--}
--
--void ms::SessionManager::focus_next()
--{
--    std::unique_lock<std::mutex> lock(mutex);
--    auto focus = focus_application.lock();
--    if (!focus)
--    {
--        focus = app_container->successor_of(std::shared_ptr<Session>());
--    }
--    else
--    {
--        focus = app_container->successor_of(focus);
--    }
--    set_focus_to_locked(lock, focus);
--}
--
--std::weak_ptr<ms::Session> ms::SessionManager::focussed_application() const
--{
--    return focus_application;
--}
--
--void ms::SessionManager::handle_surface_created(std::shared_ptr<mf::Session> const& session)
--{
--    set_focus_to(std::dynamic_pointer_cast<Session>(session));
--}
--
--std::shared_ptr<mf::PromptSession> ms::SessionManager::start_prompt_session_for(std::shared_ptr<mf::Session> const& session,
++}
++
++std::shared_ptr<ms::PromptSession> ms::SessionManager::start_prompt_session_for(std::shared_ptr<Session> const& session,
      PromptSessionCreationParameters const& params)
+ {
      auto shell_session = std::dynamic_pointer_cast<Session>(session);
@@ -177,8 +130,8 @@
+ }
  void ms::SessionManager::add_prompt_provider_for(
--    std::shared_ptr<mf::PromptSession> const& prompt_session,
--    std::shared_ptr<frontend::Session> const& session)
++    std::shared_ptr<PromptSession> const& prompt_session,
++    std::shared_ptr<Session> const& session)
+ {
      auto scene_prompt_session = std::dynamic_pointer_cast<PromptSession>(prompt_session);
      auto scene_session = std::dynamic_pointer_cast<Session>(session);
@@ -186,65 +139,14 @@
      prompt_session_manager->add_prompt_provider(scene_prompt_session, scene_session);
+ }
--void ms::SessionManager::stop_prompt_session(std::shared_ptr<mf::PromptSession> const& prompt_session)
++void ms::SessionManager::stop_prompt_session(std::shared_ptr<PromptSession> const& prompt_session)
+ {
      auto scene_prompt_session = std::dynamic_pointer_cast<PromptSession>(prompt_session);
      prompt_session_manager->stop_prompt_session(scene_prompt_session);
+ }
--mf::SurfaceId ms::SessionManager::create_surface(std::shared_ptr<mf::Session> const& session, scene::SurfaceCreationParameters const& params)
--{
--    // TODO this downcasting is clunky, but is temporary wiring of the new interaction route to the old implementation
--    if (auto const sess = std::dynamic_pointer_cast<Session>(session))
--    {
--        return sess->create_surface(params);
--    }
--
--    BOOST_THROW_EXCEPTION(std::logic_error("invalid session"));
--}
--
--void ms::SessionManager::destroy_surface(std::shared_ptr<mf::Session> const& session, mf::SurfaceId surface)
--{
--    // TODO this downcasting is clunky, but is temporary wiring of the new interaction route to the old implementation
--    if (auto const sess = std::dynamic_pointer_cast<Session>(session))
--    {
--        return sess->destroy_surface(surface);
--    }
--
--    BOOST_THROW_EXCEPTION(std::logic_error("invalid session"));
--}
--
--int ms::SessionManager::set_surface_attribute(
--    std::shared_ptr<mf::Session> const& session,
--    mf::SurfaceId surface_id,
--    MirSurfaceAttrib attrib,
--    int value)
--{
--    // TODO this downcasting is clunky, but is temporary wiring of the new interaction route to the old implementation
--    if (!session)
--        BOOST_THROW_EXCEPTION(std::logic_error("invalid session"));
--
--    auto const surface = std::dynamic_pointer_cast<Surface>(session->get_surface(surface_id));
--
--    if (!surface)
--        BOOST_THROW_EXCEPTION(std::logic_error("invalid surface id"));
--
--    return surface->configure(attrib, value);
--}
--
--int ms::SessionManager::get_surface_attribute(
--    std::shared_ptr<mf::Session> const& session,
--    mf::SurfaceId surface_id,
--    MirSurfaceAttrib attrib)
--{
--    // TODO this downcasting is clunky, but is temporary wiring of the new interaction route to the old implementation
--    if (!session)
--        BOOST_THROW_EXCEPTION(std::logic_error("invalid session"));
--
--    auto const surface = std::dynamic_pointer_cast<Surface>(session->get_surface(surface_id));
--
--    if (!surface)
--        BOOST_THROW_EXCEPTION(std::logic_error("invalid surface id"));
--
--    return surface->query(attrib);
++std::shared_ptr<ms::Session> ms::SessionManager::successor_of(
++    std::shared_ptr<Session> const& session) const
++{
++    return app_container->successor_of(session);
+ }
 === modified file 'src/server/scene/session_manager.h'
 --- src/server/scene/session_manager.h	2015-01-19 11:36:40 +0000
 +++ src/server/scene/session_manager.h	2015-01-21 10:18:06 +0000
@@ -21,18 +21,11 @@
  #include "mir/scene/session_coordinator.h"
--#include <mutex>
  #include <memory>
  #include <vector>
  namespace mir
+ {
--
--namespace shell
--{
--class FocusSetter;
--}
--
  namespace scene
+ {
  class SessionContainer;
@@ -48,45 +41,29 @@
  public:
      explicit SessionManager(std::shared_ptr<SurfaceCoordinator> const& surface_coordinator,
                              std::shared_ptr<SessionContainer> const& app_container,
--                            std::shared_ptr<shell::FocusSetter> const& focus_setter,
                              std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
                              std::shared_ptr<SessionEventSink> const& session_event_sink,
                              std::shared_ptr<SessionListener> const& session_listener,
                              std::shared_ptr<PromptSessionManager> const& prompt_session_manager);
      virtual ~SessionManager() noexcept;
--    virtual std::shared_ptr<frontend::Session> open_session(
++    std::shared_ptr<Session> open_session(
          pid_t client_pid,
          std::string const& name,
          std::shared_ptr<frontend::EventSink> const& sink) override;
--    virtual void close_session(std::shared_ptr<frontend::Session> const& session) override;
--
--    void focus_next() override;
--    std::weak_ptr<Session> focussed_application() const override;
++    void close_session(std::shared_ptr<Session> const& session) override;
++
++    std::shared_ptr<Session> successor_of(std::shared_ptr<Session> const&) const override;
++
      void set_focus_to(std::shared_ptr<Session> const& focus) override;
--
--    void handle_surface_created(std::shared_ptr<frontend::Session> const& session) override;
--
--    std::shared_ptr<frontend::PromptSession> start_prompt_session_for(std::shared_ptr<frontend::Session> const& session,
++    void unset_focus() override;
++
++    std::shared_ptr<PromptSession> start_prompt_session_for(std::shared_ptr<Session> const& session,
                                                    PromptSessionCreationParameters const& params) override;
--    void add_prompt_provider_for(std::shared_ptr<frontend::PromptSession> const& prompt_session,
--                                 std::shared_ptr<frontend::Session> const& session) override;
--    void stop_prompt_session(std::shared_ptr<frontend::PromptSession> const& prompt_session) override;
--
--    int set_surface_attribute(
--        std::shared_ptr<frontend::Session> const& session,
--        frontend::SurfaceId surface_id,
--        MirSurfaceAttrib attrib,
--        int value) override;
--
--    int get_surface_attribute(
--        std::shared_ptr<frontend::Session> const& session,
--        frontend::SurfaceId surface_id,
--        MirSurfaceAttrib attrib) override;
--
--    frontend::SurfaceId create_surface(std::shared_ptr<frontend::Session> const& session, SurfaceCreationParameters const& params) override;
--    void destroy_surface(std::shared_ptr<frontend::Session> const& session, frontend::SurfaceId surface) override;
++    void add_prompt_provider_for(std::shared_ptr<PromptSession> const& prompt_session,
++                                 std::shared_ptr<Session> const& session) override;
++    void stop_prompt_session(std::shared_ptr<PromptSession> const& prompt_session) override;
  protected:
      SessionManager(const SessionManager&) = delete;
@@ -95,16 +72,10 @@
  private:
      std::shared_ptr<SurfaceCoordinator> const surface_coordinator;
      std::shared_ptr<SessionContainer> const app_container;
--    std::shared_ptr<shell::FocusSetter> const focus_setter;
      std::shared_ptr<SnapshotStrategy> const snapshot_strategy;
      std::shared_ptr<SessionEventSink> const session_event_sink;
      std::shared_ptr<SessionListener> const session_listener;
      std::shared_ptr<PromptSessionManager> const prompt_session_manager;
--
--    std::mutex mutex;
--    std::weak_ptr<Session> focus_application;
--
--    void set_focus_to_locked(std::unique_lock<std::mutex> const& lock, std::shared_ptr<Session> const& next_focus);
  };
+ }
 === modified file 'src/server/shell/CMakeLists.txt'
 --- src/server/shell/CMakeLists.txt	2015-01-14 06:39:13 +0000
 +++ src/server/shell/CMakeLists.txt	2015-01-21 10:18:06 +0000
@@ -5,6 +5,7 @@
    default_placement_strategy.cpp
    graphics_display_layout.cpp
    default_configuration.cpp
++  default_shell.cpp
    session_coordinator_wrapper.cpp
    surface_coordinator_wrapper.cpp
+ )
 === modified file 'src/server/shell/default_configuration.cpp'
 --- src/server/shell/default_configuration.cpp	2015-01-14 06:39:13 +0000
 +++ src/server/shell/default_configuration.cpp	2015-01-21 10:18:06 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright © 2013 Canonical Ltd.
++ * Copyright © 2013-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,
@@ -22,12 +22,36 @@
  #include "default_placement_strategy.h"
  #include "default_focus_mechanism.h"
++#include "default_shell.h"
  #include "graphics_display_layout.h"
  namespace ms = mir::scene;
  namespace msh = mir::shell;
  namespace mf = mir::frontend;
++auto mir::DefaultServerConfiguration::the_shell() -> std::shared_ptr<msh::DefaultShell>
++{
++    return default_shell([this]
++        {
++            return std::make_shared<msh::DefaultShell>(
++                the_shell_focus_setter(),
++                the_session_coordinator());
++        });
++}
++
++std::shared_ptr<mf::Shell>
++mir::DefaultServerConfiguration::the_frontend_shell()
++{
++    return the_shell();
++}
++
++
++std::shared_ptr<msh::FocusController>
++mir::DefaultServerConfiguration::the_focus_controller()
++{
++    return the_shell();
++}
++
  std::shared_ptr<ms::PlacementStrategy>
  mir::DefaultServerConfiguration::the_placement_strategy()
+ {
 === added file 'src/server/shell/default_shell.cpp'
 --- src/server/shell/default_shell.cpp	1970-01-01 00:00:00 +0000
 +++ src/server/shell/default_shell.cpp	2015-01-21 10:18:06 +0000
@@ -0,0 +1,178 @@
++/*
++ * 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 <alan@octopull.co.uk>
++ */
++
++#include "default_shell.h"
++#include "mir/shell/focus_setter.h"
++#include "mir/scene/prompt_session.h"
++#include "mir/scene/session_coordinator.h"
++#include "mir/scene/session.h"
++#include "mir/scene/surface.h"
++
++#include <boost/throw_exception.hpp>
++
++#include <stdexcept>
++
++namespace mf = mir::frontend;
++namespace ms = mir::scene;
++namespace msh = mir::shell;
++
++msh::DefaultShell::DefaultShell(
++    std::shared_ptr<FocusSetter> const& focus_setter,
++    std::shared_ptr<scene::SessionCoordinator> const& session_coordinator) :
++    focus_setter(focus_setter),
++    session_coordinator(session_coordinator)
++{
++}
++
++std::shared_ptr<mf::Session> msh::DefaultShell::open_session(
++    pid_t client_pid,
++    std::string const& name,
++    std::shared_ptr<mf::EventSink> const& sink)
++{
++    auto const new_session = session_coordinator->open_session(client_pid, name, sink);
++    set_focus_to(new_session);
++    return new_session;
++}
++
++void msh::DefaultShell::close_session(
++    std::shared_ptr<mf::Session> const& session)
++{
++    session_coordinator->close_session(std::dynamic_pointer_cast<ms::Session>(session));
++
++    std::unique_lock<std::mutex> lock(mutex);
++    set_focus_to_locked(lock, session_coordinator->successor_of(std::shared_ptr<ms::Session>()));
++}
++
++void msh::DefaultShell::focus_next()
++{
++    std::unique_lock<std::mutex> lock(mutex);
++    auto focus = focus_application.lock();
++
++    focus = session_coordinator->successor_of(focus);
++
++    set_focus_to_locked(lock, focus);
++}
++
++std::weak_ptr<ms::Session> msh::DefaultShell::focussed_application() const
++{
++    return focus_application;
++}
++
++void msh::DefaultShell::set_focus_to(
++    std::shared_ptr<scene::Session> const& focus)
++{
++    std::unique_lock<std::mutex> lg(mutex);
++    set_focus_to_locked(lg, focus);
++}
++
++void msh::DefaultShell::handle_surface_created(
++    std::shared_ptr<mf::Session> const& session)
++{
++    auto const focus = std::dynamic_pointer_cast<ms::Session>(session);
++    set_focus_to(focus);
++}
++
++std::shared_ptr<mf::PromptSession> msh::DefaultShell::start_prompt_session_for(
++    std::shared_ptr<mf::Session> const& session,
++    scene::PromptSessionCreationParameters const& params)
++{
++    auto const scene_session = std::dynamic_pointer_cast<ms::Session>(session);
++
++    return session_coordinator->start_prompt_session_for(scene_session, params);
++}
++
++void msh::DefaultShell::add_prompt_provider_for(
++    std::shared_ptr<mf::PromptSession> const& prompt_session,
++    std::shared_ptr<mf::Session> const& session)
++{
++    auto const scene_prompt_session = std::dynamic_pointer_cast<ms::PromptSession>(prompt_session);
++    auto const scene_session = std::dynamic_pointer_cast<ms::Session>(session);
++    session_coordinator->add_prompt_provider_for(scene_prompt_session, scene_session);
++}
++
++void msh::DefaultShell::stop_prompt_session(std::shared_ptr<mf::PromptSession> const& prompt_session)
++{
++    auto const scene_prompt_session = std::dynamic_pointer_cast<ms::PromptSession>(prompt_session);
++    session_coordinator->stop_prompt_session(scene_prompt_session);
++}
++
++mf::SurfaceId msh::DefaultShell::create_surface(std::shared_ptr<mf::Session> const& session, ms::SurfaceCreationParameters const& params)
++{
++    auto const scene_session = std::dynamic_pointer_cast<ms::Session>(session);
++    auto const result = scene_session->create_surface(params);
++    return result;
++}
++
++void msh::DefaultShell::destroy_surface(std::shared_ptr<mf::Session> const& session, mf::SurfaceId surface)
++{
++    auto const scene_session = std::dynamic_pointer_cast<ms::Session>(session);
++    scene_session->destroy_surface(surface);
++}
++
++int msh::DefaultShell::set_surface_attribute(
++    std::shared_ptr<mf::Session> const& session,
++    mf::SurfaceId surface_id,
++    MirSurfaceAttrib attrib,
++    int value)
++{
++    // TODO this downcasting is clunky, but is temporary wiring of the new interaction route to the old implementation
++    if (!session)
++        BOOST_THROW_EXCEPTION(std::logic_error("invalid session"));
++
++    auto const surface = std::dynamic_pointer_cast<ms::Surface>(session->get_surface(surface_id));
++
++    if (!surface)
++        BOOST_THROW_EXCEPTION(std::logic_error("invalid surface id"));
++
++    return surface->configure(attrib, value);
++}
++
++int msh::DefaultShell::get_surface_attribute(
++    std::shared_ptr<mf::Session> const& session,
++    mf::SurfaceId surface_id,
++    MirSurfaceAttrib attrib)
++{
++    // TODO this downcasting is clunky, but is temporary wiring of the new interaction route to the old implementation
++    if (!session)
++        BOOST_THROW_EXCEPTION(std::logic_error("invalid session"));
++
++    auto const surface = std::dynamic_pointer_cast<ms::Surface>(session->get_surface(surface_id));
++
++    if (!surface)
++        BOOST_THROW_EXCEPTION(std::logic_error("invalid surface id"));
++
++    return surface->query(attrib);
++}
++
++
++inline void msh::DefaultShell::set_focus_to_locked(std::unique_lock<std::mutex> const&, std::shared_ptr<ms::Session> const& session)
++{
++    auto old_focus = focus_application.lock();
++
++    focus_setter->set_focus_to(session);
++    focus_application = session;
++
++    if (session)
++    {
++        session_coordinator->set_focus_to(session);
++    }
++    else
++    {
++        session_coordinator->unset_focus();
++    }
++}
 === added file 'src/server/shell/default_shell.h'
 --- src/server/shell/default_shell.h	1970-01-01 00:00:00 +0000
 +++ src/server/shell/default_shell.h	2015-01-21 10:18:06 +0000
@@ -0,0 +1,94 @@
++/*
++ * 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 <alan@octopull.co.uk>
++ */
++
++#ifndef MIR_SHELL_DEFAULT_SHELL_H_
++#define MIR_SHELL_DEFAULT_SHELL_H_
++
++#include "mir/frontend/shell.h"
++#include "mir/shell/focus_controller.h"
++
++#include <mutex>
++
++namespace mir
++{
++namespace scene { class SessionCoordinator; }
++
++namespace shell
++{
++class FocusSetter;
++
++class DefaultShell : public frontend::Shell, public FocusController
++{
++public:
++    DefaultShell(
++        std::shared_ptr<FocusSetter> const& focus_setter,
++        std::shared_ptr<scene::SessionCoordinator> const& session_coordinator);
++
++    void focus_next() override;
++
++    std::weak_ptr<scene::Session> focussed_application() const override;
++
++    void set_focus_to(std::shared_ptr<scene::Session> const& focus) override;
++
++    virtual std::shared_ptr<frontend::Session> open_session(
++        pid_t client_pid,
++        std::string const& name,
++        std::shared_ptr<frontend::EventSink> const& sink) override;
++
++    virtual void close_session(std::shared_ptr<frontend::Session> const& session) override;
++
++    void handle_surface_created(std::shared_ptr<frontend::Session> const& session) override;
++
++    std::shared_ptr<frontend::PromptSession> start_prompt_session_for(
++        std::shared_ptr<frontend::Session> const& session,
++        scene::PromptSessionCreationParameters const& params) override;
++
++    void add_prompt_provider_for(
++        std::shared_ptr<frontend::PromptSession> const& prompt_session,
++        std::shared_ptr<frontend::Session> const& session) override;
++
++    void stop_prompt_session(std::shared_ptr<frontend::PromptSession> const& prompt_session) override;
++
++    frontend::SurfaceId create_surface(std::shared_ptr<frontend::Session> const& session, scene::SurfaceCreationParameters const& params) override;
++
++    void destroy_surface(std::shared_ptr<frontend::Session> const& session, frontend::SurfaceId surface) override;
++
++    int set_surface_attribute(
++        std::shared_ptr<frontend::Session> const& session,
++        frontend::SurfaceId surface_id,
++        MirSurfaceAttrib attrib,
++        int value) override;
++
++    int get_surface_attribute(
++        std::shared_ptr<frontend::Session> const& session,
++        frontend::SurfaceId surface_id,
++        MirSurfaceAttrib attrib) override;
++
++private:
++    std::shared_ptr<FocusSetter> const focus_setter;
++    std::shared_ptr<scene::SessionCoordinator> const session_coordinator;
++
++    std::mutex mutex;
++    std::weak_ptr<scene::Session> focus_application;
++
++    void set_focus_to_locked(std::unique_lock<std::mutex> const& lock, std::shared_ptr<scene::Session> const& next_focus);
++};
++}
++}
++
++#endif /* MIR_SHELL_DEFAULT_SHELL_H_ */
 === modified file 'src/server/shell/session_coordinator_wrapper.cpp'
 --- src/server/shell/session_coordinator_wrapper.cpp	2015-01-19 11:36:40 +0000
 +++ src/server/shell/session_coordinator_wrapper.cpp	2015-01-21 10:18:06 +0000
@@ -29,7 +29,7 @@
+ }
--std::shared_ptr<mf::Session> msh::SessionCoordinatorWrapper::open_session(
++std::shared_ptr<ms::Session> msh::SessionCoordinatorWrapper::open_session(
      pid_t client_pid,
      std::string const& name,
      std::shared_ptr<mf::EventSink> const& sink)
@@ -38,19 +38,15 @@
+ }
  void msh::SessionCoordinatorWrapper::close_session(
--    std::shared_ptr<mf::Session> const& session)
++    std::shared_ptr<ms::Session> const& session)
+ {
      wrapped->close_session(session);
+ }
--void msh::SessionCoordinatorWrapper::focus_next()
--{
--    wrapped->focus_next();
--}
--
--std::weak_ptr<ms::Session> msh::SessionCoordinatorWrapper::focussed_application() const
--{
--    return wrapped->focussed_application();
++std::shared_ptr<ms::Session> msh::SessionCoordinatorWrapper::successor_of(
++    std::shared_ptr<ms::Session> const& session) const
++{
++    return wrapped->successor_of(session);
+ }
  void msh::SessionCoordinatorWrapper::set_focus_to(
@@ -59,54 +55,26 @@
      wrapped->set_focus_to(focus);
+ }
--void msh::SessionCoordinatorWrapper::handle_surface_created(
--    std::shared_ptr<mf::Session> const& session)
++void msh::SessionCoordinatorWrapper::unset_focus()
+ {
--    wrapped->handle_surface_created(session);
++    wrapped->unset_focus();
+ }
--std::shared_ptr<mf::PromptSession> msh::SessionCoordinatorWrapper::start_prompt_session_for(
--    std::shared_ptr<mf::Session> const& session,
++std::shared_ptr<ms::PromptSession> msh::SessionCoordinatorWrapper::start_prompt_session_for(
++    std::shared_ptr<ms::Session> const& session,
      scene::PromptSessionCreationParameters const& params)
+ {
      return wrapped->start_prompt_session_for(session, params);
+ }
  void msh::SessionCoordinatorWrapper::add_prompt_provider_for(
--    std::shared_ptr<mf::PromptSession> const& prompt_session,
--    std::shared_ptr<mf::Session> const& session)
++    std::shared_ptr<ms::PromptSession> const& prompt_session,
++    std::shared_ptr<ms::Session> const& session)
+ {
      wrapped->add_prompt_provider_for(prompt_session, session);
+ }
--void msh::SessionCoordinatorWrapper::stop_prompt_session(std::shared_ptr<mf::PromptSession> const& prompt_session)
++void msh::SessionCoordinatorWrapper::stop_prompt_session(std::shared_ptr<ms::PromptSession> const& prompt_session)
+ {
      wrapped->stop_prompt_session(prompt_session);
+ }
--
--mf::SurfaceId msh::SessionCoordinatorWrapper::create_surface(std::shared_ptr<mf::Session> const& session, ms::SurfaceCreationParameters const& params)
--{
--    return wrapped->create_surface(session, params);
--}
--
--void msh::SessionCoordinatorWrapper::destroy_surface(std::shared_ptr<mf::Session> const& session, mf::SurfaceId surface)
--{
--    wrapped->destroy_surface(session, surface);
--}
--
--int msh::SessionCoordinatorWrapper::set_surface_attribute(
--    std::shared_ptr<mf::Session> const& session,
--    mf::SurfaceId surface_id,
--    MirSurfaceAttrib attrib,
--    int value)
--{
--    return wrapped->set_surface_attribute(session, surface_id, attrib, value);
--}
--
--int msh::SessionCoordinatorWrapper::get_surface_attribute(
--    std::shared_ptr<mf::Session> const& session,
--    mf::SurfaceId surface_id,
--    MirSurfaceAttrib attrib)
--{
--    return wrapped->get_surface_attribute(session, surface_id, attrib);
--}
 === modified file 'src/server/symbols.map'
 --- src/server/symbols.map	2015-01-21 08:38:18 +0000
 +++ src/server/symbols.map	2015-01-21 10:18:06 +0000
@@ -500,6 +500,8 @@
      mir::shell::SessionCoordinatorWrapper::set_surface_attribute*;
      mir::shell::SessionCoordinatorWrapper::start_prompt_session_for*;
      mir::shell::SessionCoordinatorWrapper::stop_prompt_session*;
++    mir::shell::SessionCoordinatorWrapper::successor_of*;
++    mir::shell::SessionCoordinatorWrapper::unset_focus*;
      mir::shell::SurfaceCoordinatorWrapper::add_surface*;
      mir::shell::SurfaceCoordinatorWrapper::raise*;
      mir::shell::SurfaceCoordinatorWrapper::remove_surface*;
 === modified file 'tests/acceptance-tests/server_configuration_wrapping.cpp'
 --- tests/acceptance-tests/server_configuration_wrapping.cpp	2014-11-06 03:56:24 +0000
 +++ tests/acceptance-tests/server_configuration_wrapping.cpp	2015-01-21 10:18:06 +0000
@@ -41,7 +41,7 @@
+ {
      using msh::SessionCoordinatorWrapper::SessionCoordinatorWrapper;
--    MOCK_METHOD0(focus_next, void());
++    MOCK_METHOD0(unset_focus, void());
  };
  struct ServerConfigurationWrapping : mir_test_framework::HeadlessTest
@@ -102,8 +102,8 @@
+ {
      auto const my_session_coordinator = std::dynamic_pointer_cast<MySessionCoordinator>(session_coordinator);
--    EXPECT_CALL(*my_session_coordinator, focus_next()).Times(1);
--    session_coordinator->focus_next();
++    EXPECT_CALL(*my_session_coordinator, unset_focus()).Times(1);
++    session_coordinator->unset_focus();
+ }
  TEST_F(ServerConfigurationWrapping, returns_same_session_coordinator_from_cache)
 === modified file 'tests/acceptance-tests/test_client_focus_notification.cpp'
 --- tests/acceptance-tests/test_client_focus_notification.cpp	2015-01-14 06:39:13 +0000
 +++ tests/acceptance-tests/test_client_focus_notification.cpp	2015-01-21 10:18:06 +0000
@@ -97,6 +97,7 @@
+ {
      run_in_client([&]
+         {
++            InSequence s;
              EXPECT_CALL(observer, see(Pointee(mt::SurfaceEvent(mir_surface_attrib_focus, mir_surface_focused)))).Times(1)
                  .WillOnce(mt::WakeUp(&all_events_received));
              // We may not see mir_surface_unfocused before connection closes
 === modified file 'tests/acceptance-tests/test_prompt_session_client_api.cpp'
 --- tests/acceptance-tests/test_prompt_session_client_api.cpp	2015-01-14 06:39:13 +0000
 +++ tests/acceptance-tests/test_prompt_session_client_api.cpp	2015-01-21 10:18:06 +0000
@@ -78,7 +78,7 @@
          pid_t client_pid,
          std::string const& name,
          std::shared_ptr<mf::EventSink> const& sink)
--            -> std::shared_ptr<mf::Session> override
++            -> std::shared_ptr<ms::Session> override
+     {
          auto const override_pid = (next != pids.end()) ? *next++ : client_pid;
 === modified file 'tests/integration-tests/CMakeLists.txt'
 --- tests/integration-tests/CMakeLists.txt	2015-01-14 06:39:13 +0000
 +++ tests/integration-tests/CMakeLists.txt	2015-01-21 10:18:06 +0000
@@ -34,7 +34,7 @@
    test_swapinterval.cpp
    test_server_client_types.cpp
    test_server_shutdown.cpp
--  test_session_manager.cpp
++  test_default_shell.cpp
    test_session.cpp
    session_management.cpp
    surface_composition.cpp
 === renamed file 'tests/integration-tests/test_session_manager.cpp' => 'tests/integration-tests/test_default_shell.cpp'
 --- tests/integration-tests/test_session_manager.cpp	2015-01-14 06:39:13 +0000
 +++ tests/integration-tests/test_default_shell.cpp	2015-01-21 10:18:06 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright © 2012 Canonical Ltd.
++ * Copyright © 2012-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
@@ -16,6 +16,7 @@
   * Authored by: Thomas Voss <thomas.voss@canonical.com>
   */
++#include "src/server/shell/default_shell.h"
  #include "src/server/scene/session_manager.h"
  #include "mir/scene/session.h"
  #include "mir/shell/focus_setter.h"
@@ -47,40 +48,36 @@
  namespace
+ {
--struct TestSessionManagerAndFocusSelectionStrategy : public testing::Test
++struct TestDefaultShellAndFocusSelectionStrategy : public testing::Test
+ {
--    TestSessionManagerAndFocusSelectionStrategy()
--        : session_manager(
--              mt::fake_shared(surface_coordinator),
--              mt::fake_shared(container),
--              mt::fake_shared(focus_setter),
--              std::make_shared<mtd::NullSnapshotStrategy>(),
--              std::make_shared<mtd::NullSessionEventSink>(),
--              mt::fake_shared(session_listener),
--              std::make_shared<mtd::NullPromptSessionManager>())
--    {
--
--    }
--
      mtd::MockSurfaceCoordinator surface_coordinator; // TODO this isn't used as a mock
      ms::DefaultSessionContainer container;
      mtd::MockFocusSetter focus_setter;
      std::shared_ptr<mf::Session> new_session;
      ms::NullSessionListener session_listener;
--    ms::SessionManager session_manager;
++    ms::SessionManager session_manager
++        {
++            mt::fake_shared(surface_coordinator),
++            mt::fake_shared(container),
++            std::make_shared<mtd::NullSnapshotStrategy>(),
++            std::make_shared<mtd::NullSessionEventSink>(),
++            mt::fake_shared(session_listener),
++            std::make_shared<mtd::NullPromptSessionManager>()
++        };
++
++    msh::DefaultShell shell{mt::fake_shared(focus_setter), mt::fake_shared(session_manager)};
  };
--
+ }
--TEST_F(TestSessionManagerAndFocusSelectionStrategy, cycle_focus)
++TEST_F(TestDefaultShellAndFocusSelectionStrategy, cycle_focus)
+ {
      using namespace ::testing;
      EXPECT_CALL(focus_setter, set_focus_to(_)).Times(3);
--    auto session1 = session_manager.open_session(__LINE__, "Visual Basic Studio", std::make_shared<mtd::NullEventSink>());
--    auto session2 = session_manager.open_session(__LINE__, "Microsoft Access", std::make_shared<mtd::NullEventSink>());
--    auto session3 = session_manager.open_session(__LINE__, "WordPerfect", std::make_shared<mtd::NullEventSink>());
++    auto session1 = shell.open_session(__LINE__, "Visual Basic Studio", std::make_shared<mtd::NullEventSink>());
++    auto session2 = shell.open_session(__LINE__, "Microsoft Access", std::make_shared<mtd::NullEventSink>());
++    auto session3 = shell.open_session(__LINE__, "WordPerfect", std::make_shared<mtd::NullEventSink>());
      Mock::VerifyAndClearExpectations(&focus_setter);
@@ -91,9 +88,9 @@
        EXPECT_CALL(focus_setter, set_focus_to(Eq(session3))).Times(1);
+     }
--    session_manager.focus_next();
--    session_manager.focus_next();
--    session_manager.focus_next();
++    shell.focus_next();
++    shell.focus_next();
++    shell.focus_next();
      Mock::VerifyAndClearExpectations(&focus_setter);
@@ -101,15 +98,15 @@
      EXPECT_CALL(focus_setter, set_focus_to(_)).Times(AtLeast(0));
+ }
--TEST_F(TestSessionManagerAndFocusSelectionStrategy, closing_applications_transfers_focus)
++TEST_F(TestDefaultShellAndFocusSelectionStrategy, closing_applications_transfers_focus)
+ {
      using namespace ::testing;
      EXPECT_CALL(focus_setter, set_focus_to(_)).Times(3);
--    auto session1 = session_manager.open_session(__LINE__, "Visual Basic Studio", std::make_shared<mtd::NullEventSink>());
--    auto session2 = session_manager.open_session(__LINE__, "Microsoft Access", std::make_shared<mtd::NullEventSink>());
--    auto session3 = session_manager.open_session(__LINE__, "WordPerfect", std::make_shared<mtd::NullEventSink>());
++    auto session1 = shell.open_session(__LINE__, "Visual Basic Studio", std::make_shared<mtd::NullEventSink>());
++    auto session2 = shell.open_session(__LINE__, "Microsoft Access", std::make_shared<mtd::NullEventSink>());
++    auto session3 = shell.open_session(__LINE__, "WordPerfect", std::make_shared<mtd::NullEventSink>());
      Mock::VerifyAndClearExpectations(&focus_setter);
@@ -119,8 +116,8 @@
        EXPECT_CALL(focus_setter, set_focus_to(Eq(session1))).Times(1);
+     }
--    session_manager.close_session(session3);
--    session_manager.close_session(session2);
++    shell.close_session(session3);
++    shell.close_session(session2);
      Mock::VerifyAndClearExpectations(&focus_setter);
 === modified file 'tests/unit-tests/scene/test_session_manager.cpp'
 --- tests/unit-tests/scene/test_session_manager.cpp	2015-01-19 11:36:40 +0000
 +++ tests/unit-tests/scene/test_session_manager.cpp	2015-01-21 10:18:06 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright © 2012-2014 Canonical Ltd.
++ * Copyright © 2012-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
@@ -33,7 +33,6 @@
  #include "mir_test/fake_shared.h"
  #include "mir_test_doubles/mock_buffer_stream.h"
  #include "mir_test_doubles/mock_surface_coordinator.h"
--#include "mir_test_doubles/mock_focus_setter.h"
  #include "mir_test_doubles/mock_session_listener.h"
  #include "mir_test_doubles/stub_buffer_stream.h"
  #include "mir_test_doubles/null_snapshot_strategy.h"
@@ -81,7 +80,6 @@
      SessionManagerSetup()
        : session_manager(mt::fake_shared(surface_coordinator),
                          mt::fake_shared(container),
--                        mt::fake_shared(focus_setter),
                          std::make_shared<mtd::NullSnapshotStrategy>(),
                          std::make_shared<mtd::NullSessionEventSink>(),
                          mt::fake_shared(session_listener),
@@ -104,7 +102,6 @@
          mir::report::null_scene_report());
      mtd::MockSurfaceCoordinator surface_coordinator;
      testing::NiceMock<MockSessionContainer> container;    // Inelegant but some tests need a stub
--    testing::NiceMock<mtd::MockFocusSetter> focus_setter; // Inelegant but some tests need a stub
      ms::NullSessionListener session_listener;
      ms::SessionManager session_manager;
@@ -118,8 +115,6 @@
      EXPECT_CALL(container, insert_session(_)).Times(1);
      EXPECT_CALL(container, remove_session(_)).Times(1);
--    EXPECT_CALL(focus_setter, set_focus_to(_));
--    EXPECT_CALL(focus_setter, set_focus_to(std::shared_ptr<ms::Session>())).Times(1);
      auto session = session_manager.open_session(__LINE__, "Visual Basic Studio", std::shared_ptr<mf::EventSink>());
      session_manager.close_session(session);
@@ -137,36 +132,19 @@
      EXPECT_CALL(container, insert_session(_)).Times(1);
      EXPECT_CALL(container, remove_session(_)).Times(1);
--    EXPECT_CALL(focus_setter, set_focus_to(_)).Times(1);
--    EXPECT_CALL(focus_setter, set_focus_to(std::shared_ptr<ms::Session>())).Times(1);
--
      auto session = session_manager.open_session(__LINE__, "Visual Basic Studio", std::shared_ptr<mf::EventSink>());
--    session_manager.create_surface(session, ms::a_surface().of_size(geom::Size{geom::Width{1024}, geom::Height{768}}));
++    session->create_surface(ms::a_surface().of_size(geom::Size{geom::Width{1024}, geom::Height{768}}));
      session_manager.close_session(session);
+ }
--TEST_F(SessionManagerSetup, new_applications_receive_focus)
--{
--    using namespace ::testing;
--    std::shared_ptr<ms::Session> new_session;
--
--    EXPECT_CALL(container, insert_session(_)).Times(1);
--    EXPECT_CALL(focus_setter, set_focus_to(_)).WillOnce(SaveArg<0>(&new_session));
--
--    auto session = session_manager.open_session(__LINE__, "Visual Basic Studio", std::shared_ptr<mf::EventSink>());
--    EXPECT_EQ(session, new_session);
--}
--
  namespace
+ {
--
  struct SessionManagerSessionListenerSetup : public testing::Test
+ {
      SessionManagerSessionListenerSetup()
        : session_manager(mt::fake_shared(surface_coordinator),
                          mt::fake_shared(container),
--                        mt::fake_shared(focus_setter),
                          std::make_shared<mtd::NullSnapshotStrategy>(),
                          std::make_shared<mtd::NullSessionEventSink>(),
                          mt::fake_shared(session_listener),
@@ -178,21 +156,18 @@
      mtd::MockSurfaceCoordinator surface_coordinator;
      testing::NiceMock<MockSessionContainer> container;    // Inelegant but some tests need a stub
--    testing::NiceMock<mtd::MockFocusSetter> focus_setter; // Inelegant but some tests need a stub
      testing::NiceMock<mtd::MockSessionListener> session_listener;
      ms::SessionManager session_manager;
  };
+ }
--TEST_F(SessionManagerSessionListenerSetup, session_listener_is_notified_of_lifecycle_and_focus)
++TEST_F(SessionManagerSessionListenerSetup, session_listener_is_notified_of_lifecycle)
+ {
      using namespace ::testing;
      EXPECT_CALL(session_listener, starting(_)).Times(1);
--    EXPECT_CALL(session_listener, focused(_)).Times(1);
      EXPECT_CALL(session_listener, stopping(_)).Times(1);
--    EXPECT_CALL(session_listener, unfocused()).Times(1);
      auto session = session_manager.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
      session_manager.close_session(session);
@@ -200,17 +175,9 @@
  namespace
+ {
--
  struct SessionManagerSessionEventsSetup : public testing::Test
+ {
--    SessionManagerSessionEventsSetup()
--      : session_manager(mt::fake_shared(surface_coordinator),
--                        mt::fake_shared(container),
--                        mt::fake_shared(focus_setter),
--                        std::make_shared<mtd::NullSnapshotStrategy>(),
--                        mt::fake_shared(session_event_sink),
--                        std::make_shared<ms::NullSessionListener>(),
--                        std::make_shared<mtd::NullPromptSessionManager>())
++    void SetUp() override
+     {
          using namespace ::testing;
          ON_CALL(container, successor_of(_)).WillByDefault(Return((std::shared_ptr<ms::Session>())));
@@ -218,22 +185,109 @@
      mtd::MockSurfaceCoordinator surface_coordinator;
      testing::NiceMock<MockSessionContainer> container;    // Inelegant but some tests need a stub
--    testing::NiceMock<mtd::MockFocusSetter> focus_setter; // Inelegant but some tests need a stub
      MockSessionEventSink session_event_sink;
--
--    ms::SessionManager session_manager;
--};
--
--}
--
--TEST_F(SessionManagerSessionEventsSetup, session_event_sink_is_notified_of_lifecycle_and_focus)
++    testing::NiceMock<mtd::MockSessionListener> session_listener;
++
++    ms::SessionManager session_manager{
++        mt::fake_shared(surface_coordinator),
++        mt::fake_shared(container),
++        std::make_shared<mtd::NullSnapshotStrategy>(),
++        mt::fake_shared(session_event_sink),
++        mt::fake_shared(session_listener),
++        std::make_shared<mtd::NullPromptSessionManager>()};
++};
++}
++
++TEST_F(SessionManagerSessionEventsSetup, session_event_sink_is_notified_of_lifecycle)
++{
++    using namespace ::testing;
++
++    auto session = session_manager.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
++    auto session1 = session_manager.open_session(__LINE__, "Bla", std::shared_ptr<mf::EventSink>());
++
++    Mock::VerifyAndClearExpectations(&session_event_sink);
++
++    EXPECT_CALL(session_event_sink, handle_focus_change(_)).Times(AnyNumber());
++    EXPECT_CALL(session_event_sink, handle_no_focus()).Times(AnyNumber());
++
++    InSequence s;
++    EXPECT_CALL(session_event_sink, handle_session_stopping(_)).Times(1);
++    EXPECT_CALL(session_event_sink, handle_session_stopping(_)).Times(1);
++
++    session_manager.close_session(session1);
++    session_manager.close_session(session);
++}
++
++// TODO the following tests replace unit tests of "window management" functions
++// TODO that were implemented by SessionManager.
++// TODO They are now actually integration tests of DefaultShell + SessionManager
++// TODO but as I'm reworking that interaction and they use mocks that only exist
++// TODO in this file (e.g. MockSessionContainer) I've left them here temporarily.
++#include "src/server/shell/default_shell.h"
++#include "src/server/shell/default_focus_mechanism.h"
++#include "mir_test_doubles/mock_focus_setter.h"
++
++namespace msh = mir::shell;
++using namespace ::testing;
++
++namespace
++{
++struct DefaultShell : Test
++{
++    mtd::MockSurfaceCoordinator surface_coordinator;
++    NiceMock<MockSessionContainer> container;
++    NiceMock<MockSessionEventSink> session_event_sink;
++    NiceMock<mtd::MockSessionListener> session_listener;
++
++    ms::SessionManager session_manager{
++        mt::fake_shared(surface_coordinator),
++        mt::fake_shared(container),
++        std::make_shared<mtd::NullSnapshotStrategy>(),
++        mt::fake_shared(session_event_sink),
++        mt::fake_shared(session_listener),
++        std::make_shared<mtd::NullPromptSessionManager>()};
++
++    NiceMock<mtd::MockFocusSetter> focus_setter;
++    msh::DefaultShell shell{mt::fake_shared(focus_setter), mt::fake_shared(session_manager)};
++
++    void SetUp() override
++    {
++        ON_CALL(container, successor_of(_)).WillByDefault(Return((std::shared_ptr<ms::Session>())));
++    }
++};
++}
++
++TEST_F(DefaultShell, new_applications_receive_focus)
++{
++    using namespace ::testing;
++    std::shared_ptr<ms::Session> new_session;
++
++    EXPECT_CALL(container, insert_session(_)).Times(1);
++    EXPECT_CALL(focus_setter, set_focus_to(_)).WillOnce(SaveArg<0>(&new_session));
++
++    auto session = shell.open_session(__LINE__, "Visual Basic Studio", std::shared_ptr<mf::EventSink>());
++    EXPECT_EQ(session, new_session);
++}
++
++TEST_F(DefaultShell, session_listener_is_notified_of_focus)
++{
++    using namespace ::testing;
++
++    EXPECT_CALL(session_listener, focused(_)).Times(1);
++    EXPECT_CALL(session_listener, unfocused()).Times(1);
++
++    auto session = shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
++    shell.close_session(session);
++}
++
++TEST_F(DefaultShell, session_event_sink_is_notified_of_focus)
+ {
      using namespace ::testing;
      EXPECT_CALL(session_event_sink, handle_focus_change(_)).Times(2);
--    auto session = session_manager.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
--    auto session1 = session_manager.open_session(__LINE__, "Bla", std::shared_ptr<mf::EventSink>());
++    auto session = shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
++    auto session1 = shell.open_session(__LINE__, "Bla", std::shared_ptr<mf::EventSink>());
      Mock::VerifyAndClearExpectations(&session_event_sink);
@@ -247,6 +301,6 @@
          WillOnce(Return(std::shared_ptr<ms::Session>()));
      EXPECT_CALL(session_event_sink, handle_no_focus()).Times(1);
--    session_manager.close_session(session1);
--    session_manager.close_session(session);
++    shell.close_session(session1);
++    shell.close_session(session);
+ }