Merge lp:~afrantzis/unity-system-compositor/grand-refactoring-first-steps into lp:unity-system-compositor

[Alexandros Frantzis]

First steps of refactoring to improve code comprehensibility and testability

First steps of refactoring to improve code comprehensibility and testability

There is still a lot of work to be done, mainly to allow acceptance and integration testing, but it's a start. In this MP I focused on refactoring the high-level wiring of the application components
and on our session switching algorithm (rewritten test-first from scratch).

Tested on the latest N4 image.

[Alexandros Frantzis (afrantzis)]

I noticed I messed up/forgot copyrights in some cases. Will address that tomorrow along with other review comments.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:151
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/131/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/27
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/27/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-system-compositor-ci/131/rebuild

review: Needs Fixing (continuous-integration)

[Alexandros Frantzis (afrantzis)]

> FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/27/console

Some kind of build dependency failure (libgtest.a not built in proper order). Will take a look tomorrow, but feel free to review the code in the meantime.

[Michael Terry (mterry)]

Thanks for this work, it's great. Comments inline.

review: Needs Fixing

[Alexandros Frantzis (afrantzis)]

> I noticed I messed up/forgot copyrights in some cases. Will address that tomorrow along with other review comments.

Fixed.

> Some kind of build dependency failure (libgtest.a not built in proper order).

Fixed.

> > + google-mock,
>
> Guh, why not nicely sorted?

Fixed.

> > + surface_coordinator.cpp
>
> You sort the new stuff but not the old stuff. I know it wasn't sorted before you got there,
> but it's a good chance to fix that.

Fixed.

> > # Link against libmirserver
> > +qt5_use_modules(usc Core DBus)
>
> This separates the comment above it from the code it comments.
> Though really, you could probably delete the comment, as it doesn't add much
> to the line it comments.

Fixed.

> > === added file 'src/asio_dm_connection.cpp'
>
> Please do a "bzr mv" instead of a delete and add for this file. That way, we keep bzr history.

Fixed.

> > +TEST_F(ASessionSwitcher, displays_ready_next_session)
>
> We shouldn't display a next session without a ready active session.

Fixed. Updated test name is "does_not_display_ready_next_session_without_ready_active_session".

> > +TEST_F(ASessionSwitcher, displays_spinner_if_next_is_not_ready)
>
> This test probably wants an active session configured too.
> Because without one, next should never be shown anyway.
> But I think you have that same test below.

Fixed. Kept test (renamed to "does_not_display_spinner_if_next_is_not_ready") to check behavior when we only have a "next" session.

> > +TEST_F(ASessionSwitcher, starts_and_stops_spinner_as_needed)
>
> Do you even need a next session for this test?

Fixed.

> > +TEST_F(ASessionSwitcher, displays_next_when_active_is_removed)
>
> No, if the active session is not set, we should show spinner (or nothing, if no spinner).

Fixed. "does_not_display_next_when_active_is_removed"

> > +TEST_F(ASessionSwitcher, displays_active_when_next_is_removed)
>
> Do we need spinner in this test?

Updated test name to better communicate its intent (and why we need a spinner): "displays_only_active_not_spinner_when_next_is_removed". Contrast with related test: "displays_spinner_under_active_if_next_is_removed_unexpectedly"

> > +TEST_F(ASessionSwitcher, can_handle_spinner_resurrection_under_different_name)
>
> Might also want to test that we handle it being resurrected under a different pid,
> which is more common.

Added: "can_handle_spinner_resurrection_under_different_pid"

> > +TEST_F(ASessionSwitcher, is_not_confused_by_other_session_with_name_of_dead_spinner)
>
> And again, might want to add test for a process that uses a dead spinner's pid.

Added: "is_not_confused_by_other_session_with_pid_of_dead_spinner"

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:152
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/132/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/28
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/28

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-system-compositor-ci/132/rebuild

review: Approve (continuous-integration)

[Michael Terry (mterry)]

Excellent, thanks Alexandros!

review: Approve

[Alan Griffiths (alan-griffiths)]

Not a complete review but what I've followed looks like an improvement. (And makes my fingers itch to fix more.)

review: Approve

[Alexandros Frantzis (afrantzis)]

* Did you test your feature/code change/bug fix ? what device(s) ?

  YES, Desktop and N4

* Did you break mir server API or ABI and have the relevant bumps to .so and debian docs been made ?

  No (Not applicable)

* Did you break mir client API or ABI and have you followed up with the known clients & announced on mir-devel mailing list ?
  No (Not applicable)

[Alberto Aguirre (albaguirre)]

1507 + std::thread{action}.detach();

Neat! :)

Looks good, now I need to add some tests for all the display state/inactivity policy stuff :)

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-07-03 17:52:36 +0000
+++ CMakeLists.txt	2014-07-18 09:49:03 +0000
@@ -52,3 +52,13 @@
 
 add_subdirectory(spinner/)
 add_subdirectory(src/)
+
+enable_testing()
+
+option(MIR_ENABLE_TESTS "Build tests" ON)
+
+if (MIR_ENABLE_TESTS)
+  find_package(Gtest REQUIRED)
+  include_directories(${GMOCK_INCLUDE_DIR} ${GTEST_INCLUDE_DIR})
+  add_subdirectory(tests/)
+endif ()

=== added file 'cmake/FindGtest.cmake'
--- cmake/FindGtest.cmake	1970-01-01 00:00:00 +0000
+++ cmake/FindGtest.cmake	2014-07-18 09:49:03 +0000
@@ -0,0 +1,53 @@
+include(ExternalProject)
+include(FindPackageHandleStandardArgs)
+
+#gtest
+set(GTEST_INSTALL_DIR /usr/src/gmock/gtest/include)
+find_path(GTEST_INCLUDE_DIR gtest/gtest.h
+            HINTS ${GTEST_INSTALL_DIR})
+
+#gmock
+find_path(GMOCK_INSTALL_DIR gmock/CMakeLists.txt
+          HINTS /usr/src)
+if(${GMOCK_INSTALL_DIR} STREQUAL "GMOCK_INSTALL_DIR-NOTFOUND")
+    message(FATAL_ERROR "google-mock package not found")
+endif()
+
+set(GMOCK_INSTALL_DIR ${GMOCK_INSTALL_DIR}/gmock)
+find_path(GMOCK_INCLUDE_DIR gmock/gmock.h)
+
+set(GMOCK_PREFIX gmock)
+set(GMOCK_BINARY_DIR ${CMAKE_BINARY_DIR}/${GMOCK_PREFIX}/libs)
+set(GTEST_BINARY_DIR ${GMOCK_BINARY_DIR}/gtest)
+
+set(GTEST_CMAKE_ARGS "")
+if (${CMAKE_CROSSCOMPILING})
+    set(GTEST_CMAKE_ARGS
+        -DCMAKE_TOOLCHAIN_FILE=${CMAKE_MODULE_PATH}/LinuxCrossCompile.cmake)
+endif()
+
+ExternalProject_Add(
+    GMock
+    #where to build in source tree
+    PREFIX ${GMOCK_PREFIX}
+    #where the source is external to the project
+    SOURCE_DIR ${GMOCK_INSTALL_DIR}
+    #forward the compilers to the subproject so cross-arch builds work
+    CMAKE_ARGS ${GTEST_CMAKE_ARGS}
+    BINARY_DIR ${GMOCK_BINARY_DIR}
+
+    #we don't need to install, so skip
+    INSTALL_COMMAND ""
+)
+
+set(GMOCK_LIBRARY ${GMOCK_BINARY_DIR}/libgmock.a)
+set(GMOCK_MAIN_LIBRARY ${GMOCK_BINARY_DIR}/libgmock_main.a)
+set(GMOCK_BOTH_LIBRARIES ${GMOCK_LIBRARY} ${GMOCK_MAIN_LIBRARY})
+set(GTEST_LIBRARY ${GTEST_BINARY_DIR}/libgtest.a)
+set(GTEST_MAIN_LIBRARY ${GTEST_BINARY_DIR}/libgtest_main.a)
+set(GTEST_BOTH_LIBRARIES ${GTEST_LIBRARY} ${GTEST_MAIN_LIBRARY})
+set(GTEST_ALL_LIBRARIES ${GTEST_BOTH_LIBRARIES} ${GMOCK_BOTH_LIBRARIES})
+
+find_package_handle_standard_args(GTest  DEFAULT_MSG
+                                    GMOCK_INCLUDE_DIR
+                                    GTEST_INCLUDE_DIR)

=== modified file 'debian/control'
--- debian/control	2014-07-15 13:50:07 +0000
+++ debian/control	2014-07-18 09:49:03 +0000
@@ -5,6 +5,7 @@
 Build-Depends: cmake,
                cmake-data,
                debhelper (>= 9),
+               google-mock,
                libandroid-properties-dev [i386 amd64 armhf],
                libboost-chrono-dev,
                libboost-date-time-dev,

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2014-06-16 16:53:55 +0000
+++ src/CMakeLists.txt	2014-07-18 09:49:03 +0000
@@ -15,18 +15,17 @@
 # Authored by: Robert Ancell <[e-mail]>
 
 set(USC_SRCS
-  main.cpp
+  asio_dm_connection.cpp
   dbus_screen.cpp
-  dbus_screen.h
+  external_spinner.cpp
   powerd_mediator.cpp
-  dm_connection.cpp
-  dm_connection.h
+  powerkey_handler.cpp
+  screen_state_handler.cpp
+  server_configuration.cpp
+  session_coordinator.cpp
+  session_switcher.cpp
+  surface_coordinator.cpp
   system_compositor.cpp
-  system_compositor.h
-  screen_state_handler.cpp
-  screen_state_handler.h
-  powerkey_handler.cpp
-  powerkey_handler.h
 )
 
 qt5_generate_dbus_interface(dbus_screen.h com.canonical.Unity.Screen.xml)
@@ -36,9 +35,14 @@
                      dbus_screen_adaptor DBusScreenAdaptor)
 
 # Compile system compositor
+add_library(
+  usc STATIC
+  ${USC_SRCS}
+)
+
 add_executable(
   unity-system-compositor
-  ${USC_SRCS}
+  main.cpp
 )
 
 include_directories(
@@ -52,15 +56,20 @@
   -DDEFAULT_SPINNER="${CMAKE_INSTALL_FULL_BINDIR}/unity-system-compositor-spinner"
 )
 
-# Link against libmirserver
+qt5_use_modules(usc Core DBus)
+
 link_directories(${MIRSERVER_LIBRARY_DIRS})
-target_link_libraries(unity-system-compositor
+
+target_link_libraries(usc
   ${MIRSERVER_LDFLAGS}
   pthread
   ${Boost_LIBRARIES}
   ${GLESv2_LIBRARIES}
 )
-qt5_use_modules(unity-system-compositor Core DBus)
+
+target_link_libraries(unity-system-compositor
+  usc
+)
 
 # Install into bin directory
 install(TARGETS unity-system-compositor

=== renamed file 'src/dm_connection.cpp' => 'src/asio_dm_connection.cpp'
--- src/dm_connection.cpp	2013-07-09 19:18:59 +0000
+++ src/asio_dm_connection.cpp	2014-07-18 09:49:03 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -14,37 +14,62 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Robert Ancell <[e-mail]>
+ *              Alexandros Frantzis <[e-mail]>
  */
 
-#include "dm_connection.h"
+#include "asio_dm_connection.h"
 
-#include <boost/signals2.hpp>
 #include <iostream>
+#include <thread>
 
 namespace ba = boost::asio;
 namespace bs = boost::system;
 
-void DMConnection::start()
+usc::AsioDMConnection::AsioDMConnection(
+    int from_dm_fd, int to_dm_fd,
+    std::shared_ptr<DMMessageHandler> const& dm_message_handler)
+    : from_dm_pipe{io_service, from_dm_fd},
+      to_dm_pipe{io_service, to_dm_fd},
+      dm_message_handler{dm_message_handler}
+{
+}
+
+usc::AsioDMConnection::~AsioDMConnection()
+{
+    io_service.stop();
+    if (io_thread.joinable())
+        io_thread.join();
+}
+
+void usc::AsioDMConnection::start()
 {
     std::cerr << "dm_connection_start" << std::endl;
+
+    send_ready();
     read_header();
+
+    io_thread = std::thread{
+        [this]
+        {
+            io_service.run();
+        }};
 }
 
-void DMConnection::send_ready()
+void usc::AsioDMConnection::send_ready()
 {
     send(USCMessageID::ready, "");
 }
 
-void DMConnection::read_header()
+void usc::AsioDMConnection::read_header()
 {
     ba::async_read(from_dm_pipe,
                    ba::buffer(message_header_bytes),
-                   boost::bind(&DMConnection::on_read_header,
-                               this,
-                               ba::placeholders::error));
+                   std::bind(&AsioDMConnection::on_read_header,
+                             this,
+                             std::placeholders::_1));
 }
 
-void DMConnection::on_read_header(const bs::error_code& ec)
+void usc::AsioDMConnection::on_read_header(bs::error_code const& ec)
 {
     if (!ec)
     {
@@ -52,15 +77,15 @@
         ba::async_read(from_dm_pipe,
                        message_payload_buffer,
                        ba::transfer_exactly(payload_length),
-                       boost::bind(&DMConnection::on_read_payload,
-                                   this,
-                                   ba::placeholders::error));
+                       std::bind(&AsioDMConnection::on_read_payload,
+                                 this,
+                                 std::placeholders::_1));
     }
     else
         std::cerr << "Failed to read header" << std::endl;
 }
 
-void DMConnection::on_read_payload(const bs::error_code& ec)
+void usc::AsioDMConnection::on_read_payload(const bs::error_code& ec)
 {
     if (!ec)
     {
@@ -86,8 +111,7 @@
             ss << &message_payload_buffer;
             auto client_name = ss.str();
             std::cerr << "set_active_session '" << client_name << "'" << std::endl;
-            if (handler)
-                handler->set_active_session(client_name);
+            dm_message_handler->set_active_session(client_name);
             break;
         }
         case USCMessageID::set_next_session:
@@ -96,8 +120,7 @@
             ss << &message_payload_buffer;
             auto client_name = ss.str();
             std::cerr << "set_next_session '" << client_name << "'" << std::endl;
-            if (handler)
-                handler->set_next_session(client_name);
+            dm_message_handler->set_next_session(client_name);
             break;
         }
         default:
@@ -111,7 +134,7 @@
     read_header();
 }
 
-void DMConnection::send(USCMessageID id, std::string const& body)
+void usc::AsioDMConnection::send(USCMessageID id, std::string const& body)
 {
     const size_t size = body.size();
     const uint16_t _id = (uint16_t) id;

=== added file 'src/asio_dm_connection.h'
--- src/asio_dm_connection.h	1970-01-01 00:00:00 +0000
+++ src/asio_dm_connection.h	2014-07-18 09:49:03 +0000
@@ -0,0 +1,73 @@
+/*
+ * Copyright © 2013-2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Ancell <[e-mail]>
+ *              Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef USC_ASIO_DM_CONNECTION_H_
+#define USC_ASIO_DM_CONNECTION_H_
+
+#include "dm_connection.h"
+
+#include <boost/asio.hpp>
+#include <thread>
+
+namespace usc
+{
+
+class AsioDMConnection : public DMConnection
+{
+public:
+    AsioDMConnection(
+        int from_dm_fd, int to_dm_fd,
+        std::shared_ptr<DMMessageHandler> const& dm_message_handler);
+    ~AsioDMConnection();
+
+    void start() override;
+
+private:
+    enum class USCMessageID
+    {
+        ping = 0,
+        pong = 1,
+        ready = 2,
+        session_connected = 3,
+        set_active_session = 4,
+        set_next_session = 5,
+    };
+
+    void send_ready();
+    void read_header();
+    void on_read_header(const boost::system::error_code& ec);
+    void on_read_payload(const boost::system::error_code& ec);
+    void send(USCMessageID id, std::string const& body);
+
+    boost::asio::io_service io_service;
+    boost::asio::posix::stream_descriptor from_dm_pipe;
+    boost::asio::posix::stream_descriptor to_dm_pipe;
+    std::thread io_thread;
+    std::shared_ptr<DMMessageHandler> const dm_message_handler;
+
+    static size_t const size_of_header = 4;
+    unsigned char message_header_bytes[size_of_header];
+    boost::asio::streambuf message_payload_buffer;
+    std::vector<char> write_buffer;
+
+};
+
+}
+
+#endif /* USC_ASIO_DM_CONNECTION_H_ */

=== modified file 'src/dm_connection.h'
--- src/dm_connection.h	2013-11-13 13:53:51 +0000
+++ src/dm_connection.h	2014-07-18 09:49:03 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -13,60 +13,37 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
- * Authored by: Robert Ancell <[e-mail]>
+ * Authored by: Alexandros Frantzis <[e-mail]>
  */
 
-#ifndef DM_CONNECTION_H_
-#define DM_CONNECTION_H_
-
-#include <boost/asio.hpp>
+#ifndef USC_DM_CONNECTION_H_
+#define USC_DM_CONNECTION_H_
+
+#include <string>
+
+namespace usc
+{
 
 class DMMessageHandler
 {
 public:
-    virtual void set_active_session(std::string client_name) = 0;
-    virtual void set_next_session(std::string client_name) = 0;
-};
-
-enum class USCMessageID
-{
-    ping = 0,
-    pong = 1,
-    ready = 2,
-    session_connected = 3,
-    set_active_session = 4,
-    set_next_session = 5,
+    virtual void set_active_session(std::string const& client_name) = 0;
+    virtual void set_next_session(std::string const& client_name) = 0;
 };
 
 class DMConnection
 {
 public:
-    DMConnection(boost::asio::io_service& io_service, int from_dm_fd, int to_dm_fd) :
-        from_dm_pipe(io_service, from_dm_fd),
-        to_dm_pipe(io_service, to_dm_fd) {};
-
-    void set_handler(DMMessageHandler *handler)
-    {
-        this->handler = handler;
-    }
-
-    void start();
-
-    void send_ready();
-
-private:
-    DMMessageHandler *handler;
-    boost::asio::posix::stream_descriptor from_dm_pipe;
-    boost::asio::posix::stream_descriptor to_dm_pipe;
-    static size_t const size_of_header = 4;
-    unsigned char message_header_bytes[size_of_header];
-    boost::asio::streambuf message_payload_buffer;
-    std::vector<char> write_buffer;
-
-    void read_header();
-    void on_read_header(const boost::system::error_code& ec);
-    void on_read_payload(const boost::system::error_code& ec);
-    void send(USCMessageID id, std::string const& body);
+    virtual ~DMConnection() = default;
+
+    virtual void start() = 0;
+
+protected:
+    DMConnection() = default;
+    DMConnection(DMConnection const&) = delete;
+    DMConnection& operator=(DMConnection const&) = delete;
 };
 
-#endif /* DM_CONNECTION_H_ */
+}
+
+#endif /* USC_DM_CONNECTION_H_ */

=== added file 'src/external_spinner.cpp'
--- src/external_spinner.cpp	1970-01-01 00:00:00 +0000
+++ src/external_spinner.cpp	2014-07-18 09:49:03 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "external_spinner.h"
+
+usc::ExternalSpinner::ExternalSpinner(
+    std::string const& executable,
+    std::string const& mir_socket)
+    : executable{executable},
+      mir_socket{mir_socket}
+{
+}
+
+usc::ExternalSpinner::~ExternalSpinner()
+{
+    kill();
+}
+
+void usc::ExternalSpinner::ensure_running()
+{
+    if (executable.empty() || process.state() != QProcess::NotRunning)
+        return;
+
+    // Launch spinner process to provide default background when a session isn't ready
+    QStringList env = QProcess::systemEnvironment();
+    env << "MIR_SOCKET=" + QString::fromStdString(mir_socket);
+    process.setEnvironment(env);
+    process.start(executable.c_str());
+}
+
+void usc::ExternalSpinner::kill()
+{
+    process.close();
+}
+
+pid_t usc::ExternalSpinner::pid()
+{
+    return process.processId();
+}

=== added file 'src/external_spinner.h'
--- src/external_spinner.h	1970-01-01 00:00:00 +0000
+++ src/external_spinner.h	2014-07-18 09:49:03 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef USC_EXTERNAL_SPINNER_H_
+#define USC_EXTERNAL_SPINNER_H_
+
+#include "spinner.h"
+
+#include <QProcess>
+#include <string>
+
+namespace usc
+{
+
+class ExternalSpinner : public Spinner
+{
+public:
+    ExternalSpinner(std::string const& executable,
+                    std::string const& mir_socket);
+    ~ExternalSpinner();
+
+    void ensure_running() override;
+    void kill() override;
+    pid_t pid() override;
+
+private:
+    std::string const executable;
+    std::string const mir_socket;
+    QProcess process;
+};
+
+}
+
+#endif

=== modified file 'src/main.cpp'
--- src/main.cpp	2013-10-31 22:00:19 +0000
+++ src/main.cpp	2014-07-18 09:49:03 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -14,17 +14,22 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Robert Ancell <[e-mail]>
+ *              Alexandros Frantzis <[e-mail]>
  */
 
 #include "system_compositor.h"
+#include "server_configuration.h"
+
 #include <mir/report_exception.h>
 #include <iostream>
 
 int main(int argc, char *argv[])
 try
 {
-    SystemCompositor system_compositor;
-    system_compositor.run(argc, argv);
+    auto const config = std::make_shared<usc::ServerConfiguration>(argc, argv);
+
+    usc::SystemCompositor system_compositor{config};
+    system_compositor.run();
 
     return 0;
 }

=== added file 'src/server_configuration.cpp'
--- src/server_configuration.cpp	1970-01-01 00:00:00 +0000
+++ src/server_configuration.cpp	2014-07-18 09:49:03 +0000
@@ -0,0 +1,196 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "server_configuration.h"
+#include "external_spinner.h"
+#include "session_coordinator.h"
+#include "surface_coordinator.h"
+#include "asio_dm_connection.h"
+#include "session_switcher.h"
+
+#include <mir/options/default_configuration.h>
+#include <mir/input/cursor_listener.h>
+#include <mir/server_status_listener.h>
+#include <mir/shell/focus_controller.h>
+#include <mir/scene/session.h>
+
+#include <boost/program_options.hpp>
+
+namespace msh = mir::shell;
+namespace ms = mir::scene;
+namespace mf = mir::frontend;
+namespace mi = mir::input;
+namespace mo = mir::options;
+namespace po = boost::program_options;
+
+namespace
+{
+
+class ConfigurationOptions : public mo::DefaultConfiguration
+{
+public:
+    ConfigurationOptions(int argc, char const* argv[]) :
+        DefaultConfiguration(argc, argv)
+    {
+        add_options()
+            ("from-dm-fd", po::value<int>(),  "File descriptor of read end of pipe from display manager [int]")
+            ("to-dm-fd", po::value<int>(),  "File descriptor of write end of pipe to display manager [int]")
+            ("blacklist", po::value<std::string>(), "Video blacklist regex to use")
+            ("version", "Show version of Unity System Compositor")
+            ("spinner", po::value<std::string>(), "Path to spinner executable")
+            ("public-socket", po::value<bool>(), "Make the socket file publicly writable")
+            ("enable-hardware-cursor", po::value<bool>(), "Enable the hardware cursor (disabled by default)")
+            ("inactivity-display-off-timeout", po::value<int>(), "The time in seconds before the screen is turned off when there are no active sessions")
+            ("inactivity-display-dim-timeout", po::value<int>(), "The time in seconds before the screen is dimmed when there are no active sessions")
+            ("shutdown-timeout", po::value<int>(), "The time in milli-seconds the power key must be held to initiate a clean system shutdown")
+            ("power-key-ignore-timeout", po::value<int>(), "The time in milli-seconds the power key must be held to ignore - must be less than shutdown-timeout")
+            ("disable-inactivity-policy", po::value<bool>(), "Disables handling user inactivity and power key");
+    }
+
+    void parse_config_file(
+        boost::program_options::options_description& options_description,
+        mo::ProgramOption& options) const override
+    {
+        options.parse_file(options_description, "unity-system-compositor.conf");
+    }
+};
+
+}
+
+usc::ServerConfiguration::ServerConfiguration(int argc, char** argv)
+    : mir::DefaultServerConfiguration(
+        std::make_shared<ConfigurationOptions>(argc, const_cast<char const **>(argv)))
+{
+}
+
+std::shared_ptr<mi::CursorListener>
+usc::ServerConfiguration::the_cursor_listener()
+{
+    struct NullCursorListener : public mi::CursorListener
+    {
+        void cursor_moved_to(float, float) override
+        {
+        }
+    };
+
+    // This is a workaround for u8 desktop preview in 14.04 for the lack of client cursor API.
+    // We need to disable the cursor for XMir but leave it on for the desktop preview.
+    // Luckily as it stands they run inside seperate instances of USC. ~racarr
+    if (enable_hardware_cursor())
+        return mir::DefaultServerConfiguration::the_cursor_listener();
+    else
+        return std::make_shared<NullCursorListener>();
+}
+
+std::shared_ptr<mir::ServerStatusListener>
+usc::ServerConfiguration::the_server_status_listener()
+{
+    struct ServerStatusListener : public mir::ServerStatusListener
+    {
+        ServerStatusListener(
+            std::shared_ptr<msh::FocusController> const& focus_controller)
+            : focus_controller{focus_controller}
+        {
+        }
+
+        void paused() override
+        {
+            std::cerr << "pause" << std::endl;
+
+            if (auto active_session = weak_active_session().lock())
+                active_session->set_lifecycle_state(mir_lifecycle_state_will_suspend);
+        }
+
+        void resumed() override
+        {
+            std::cerr << "resume" << std::endl;
+
+            if (auto active_session = weak_active_session().lock())
+                active_session->set_lifecycle_state(mir_lifecycle_state_resumed);
+        }
+
+        void started() override
+        {
+        }
+
+        std::weak_ptr<ms::Session> weak_active_session()
+        {
+            return focus_controller->focussed_application();
+        }
+
+        std::shared_ptr<msh::FocusController> const focus_controller;
+    };
+
+    return std::make_shared<ServerStatusListener>(the_focus_controller());
+}
+
+std::shared_ptr<mir::scene::SessionCoordinator>
+usc::ServerConfiguration::wrap_session_coordinator(
+    std::shared_ptr<ms::SessionCoordinator> const& wrapped)
+{
+    return std::make_shared<SessionCoordinator>(
+        wrapped,
+        the_session_switcher());
+}
+
+std::shared_ptr<mir::scene::SurfaceCoordinator>
+usc::ServerConfiguration::wrap_surface_coordinator(
+    std::shared_ptr<ms::SurfaceCoordinator> const& wrapped)
+{
+    return std::make_shared<SurfaceCoordinator>(
+        wrapped,
+        the_session_switcher());
+}
+
+std::shared_ptr<usc::Spinner> usc::ServerConfiguration::the_spinner()
+{
+    return spinner(
+        [this]
+        {
+            return std::make_shared<ExternalSpinner>(
+                spinner_executable(),
+                get_socket_file());
+        });
+}
+
+std::shared_ptr<usc::SessionSwitcher> usc::ServerConfiguration::the_session_switcher()
+{
+    return session_switcher(
+        [this]
+        {
+            return std::make_shared<SessionSwitcher>(
+                the_spinner());
+        });
+}
+
+std::shared_ptr<usc::DMMessageHandler> usc::ServerConfiguration::the_dm_message_handler()
+{
+    return the_session_switcher();
+}
+
+std::shared_ptr<usc::DMConnection> usc::ServerConfiguration::the_dm_connection()
+{
+    return dm_connection(
+        [this]
+        {
+            return std::make_shared<AsioDMConnection>(
+                the_options()->get("from-dm-fd", -1),
+                the_options()->get("to-dm-fd", -1),
+                the_dm_message_handler());
+        });
+}

=== added file 'src/server_configuration.h'
--- src/server_configuration.h	1970-01-01 00:00:00 +0000
+++ src/server_configuration.h	2014-07-18 09:49:03 +0000
@@ -0,0 +1,119 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef USC_SERVER_CONFIGURATION_H_
+#define USC_SERVER_CONFIGURATION_H_
+
+#include <mir/default_server_configuration.h>
+#include <mir/options/option.h>
+
+namespace usc
+{
+class Spinner;
+class SessionSwitcher;
+class DMMessageHandler;
+class DMConnection;
+
+class ServerConfiguration : public mir::DefaultServerConfiguration
+{
+public:
+    ServerConfiguration(int argc, char** argv);
+
+    virtual std::shared_ptr<Spinner> the_spinner();
+    virtual std::shared_ptr<DMMessageHandler> the_dm_message_handler();
+    virtual std::shared_ptr<DMConnection> the_dm_connection();
+
+    bool show_version()
+    {
+        return the_options()->is_set("version");
+    }
+
+    int inactivity_display_off_timeout()
+    {
+       return the_options()->get("inactivity-display-off-timeout", 60);
+    }
+
+    int inactivity_display_dim_timeout()
+    {
+       return the_options()->get("inactivity-display-dim-timeout", 45);
+    }
+
+    int shutdown_timeout()
+    {
+       return the_options()->get("shutdown-timeout", 5000);
+    }
+
+    int power_key_ignore_timeout()
+    {
+       return the_options()->get("power-key-ignore-timeout", 1500);
+    }
+
+    bool enable_hardware_cursor()
+    {
+        return the_options()->get("enable-hardware-cursor", false);
+    }
+
+    bool disable_inactivity_policy()
+    {
+        return the_options()->get("disable-inactivity-policy", false);
+    }
+
+    std::string blacklist()
+    {
+        auto x = the_options()->get("blacklist", "");
+        //boost::trim(x);
+        return x;
+    }
+
+    std::string spinner_executable()
+    {
+        // TODO: once our default spinner is ready for use everywhere, replace
+        // default value with DEFAULT_SPINNER instead of the empty string.
+        auto x = the_options()->get("spinner", "");
+        //boost::trim(x);
+        return x;
+    }
+
+    bool public_socket()
+    {
+        return !the_options()->is_set("no-file") && the_options()->get("public-socket", true);
+    }
+
+    std::string get_socket_file()
+    {
+        // the_socket_file is private, so we have to re-implement it here
+        return the_options()->get("file", "/tmp/mir_socket");
+    }
+
+protected:
+    virtual std::shared_ptr<SessionSwitcher> the_session_switcher();
+    std::shared_ptr<mir::input::CursorListener> the_cursor_listener() override;
+    std::shared_ptr<mir::ServerStatusListener> the_server_status_listener() override;
+    std::shared_ptr<mir::scene::SessionCoordinator> wrap_session_coordinator(
+        std::shared_ptr<mir::scene::SessionCoordinator> const& wrapped) override;
+    std::shared_ptr<mir::scene::SurfaceCoordinator> wrap_surface_coordinator(
+        std::shared_ptr<mir::scene::SurfaceCoordinator> const& wrapped) override;
+
+    mir::CachedPtr<Spinner> spinner;
+    mir::CachedPtr<DMConnection> dm_connection;
+    mir::CachedPtr<SessionSwitcher> session_switcher;
+};
+
+}
+
+#endif

=== added file 'src/session_coordinator.cpp'
--- src/session_coordinator.cpp	1970-01-01 00:00:00 +0000
+++ src/session_coordinator.cpp	2014-07-18 09:49:03 +0000
@@ -0,0 +1,117 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "session_coordinator.h"
+#include "session_switcher.h"
+
+#include <mir/scene/session.h>
+
+#include <iostream>
+
+namespace msh = mir::shell;
+namespace ms = mir::scene;
+namespace mf = mir::frontend;
+
+namespace
+{
+
+class UscSession : public usc::Session
+{
+public:
+    UscSession(
+        std::shared_ptr<ms::Session> const& scene_session,
+        msh::FocusController& focus_controller)
+        : scene_session{scene_session},
+          focus_controller(focus_controller)
+    {
+    }
+
+    std::string name()
+    {
+        return scene_session->name();
+    }
+
+    void show() override
+    {
+        scene_session->show();
+    }
+
+    void hide() override
+    {
+        scene_session->hide();
+    }
+
+    void raise_and_focus() override
+    {
+        focus_controller.set_focus_to(scene_session);
+    }
+
+    bool corresponds_to(mir::scene::Session const* s) override
+    {
+        return scene_session.get() == s;
+    }
+
+    std::shared_ptr<ms::Session> const scene_session;
+    msh::FocusController& focus_controller;
+};
+
+}
+
+usc::SessionCoordinator::SessionCoordinator(
+    std::shared_ptr<ms::SessionCoordinator> const& wrapped,
+    std::shared_ptr<SessionSwitcher> const& session_switcher)
+    : msh::SessionCoordinatorWrapper{wrapped},
+      session_switcher{session_switcher}
+{
+}
+
+std::shared_ptr<mf::Session>
+usc::SessionCoordinator::open_session(
+    pid_t client_pid,
+    std::string const& name,
+    std::shared_ptr<mf::EventSink> const& sink)
+{
+    std::cerr << "Opening session " << name << std::endl;
+
+    // We need ms::Session objects because that is what the focus controller
+    // works with.  But the mf::SessionCoordinator interface deals with mf::Session objects.
+    // So we cast here since in practice, these objects are also ms::Sessions.
+    auto orig = std::dynamic_pointer_cast<ms::Session>(
+        msh::SessionCoordinatorWrapper::open_session(client_pid, name, sink));
+    if (!orig)
+    {
+        std::cerr << "Unexpected non-shell session" << std::endl;
+        return std::shared_ptr<mf::Session>();
+    }
+
+    auto const usc_session = std::make_shared<UscSession>(orig, *this);
+
+    session_switcher->add(usc_session, client_pid);
+
+    return orig;
+}
+
+void usc::SessionCoordinator::close_session(
+    std::shared_ptr<mf::Session> const& session)
+{
+    std::cerr << "Closing session " << session->name() << std::endl;
+
+    msh::SessionCoordinatorWrapper::close_session(session);
+
+    session_switcher->remove(session->name());
+}

=== added file 'src/session_coordinator.h'
--- src/session_coordinator.h	1970-01-01 00:00:00 +0000
+++ src/session_coordinator.h	2014-07-18 09:49:03 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef USC_SESSION_COORDINATOR_H_
+#define USC_SESSION_COORDINATOR_H_
+
+#include <mir/shell/session_coordinator_wrapper.h>
+
+#include <memory>
+
+namespace mir
+{
+namespace scene { class SurfaceCoordinator; }
+}
+
+namespace usc
+{
+class SessionSwitcher;
+
+class SessionCoordinator : public mir::shell::SessionCoordinatorWrapper
+{
+public:
+    SessionCoordinator(
+        std::shared_ptr<mir::scene::SessionCoordinator> const& wrapped,
+        std::shared_ptr<SessionSwitcher> const& session_switcher);
+
+private:
+    std::shared_ptr<mir::frontend::Session> open_session(
+        pid_t client_pid,
+        std::string const& name,
+        std::shared_ptr<mir::frontend::EventSink> const& sink) override;
+    void close_session(std::shared_ptr<mir::frontend::Session> const& session) override;
+
+    std::shared_ptr<SessionSwitcher> const session_switcher;
+};
+
+}
+
+#endif

=== added file 'src/session_switcher.cpp'
--- src/session_switcher.cpp	1970-01-01 00:00:00 +0000
+++ src/session_switcher.cpp	2014-07-18 09:49:03 +0000
@@ -0,0 +1,190 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "session_switcher.h"
+#include "spinner.h"
+
+usc::SessionSwitcher::SessionSwitcher(std::shared_ptr<Spinner> const& spinner)
+    : spinner_process{spinner},
+      booting{true}
+{
+}
+
+void usc::SessionSwitcher::add(std::shared_ptr<Session> const& session, pid_t pid)
+{
+    std::lock_guard<std::mutex> lock{mutex};
+
+    if (pid == spinner_process->pid())
+        spinner_name = session->name();
+
+    sessions[session->name()] = SessionInfo(session);
+    update_displayed_sessions();
+}
+
+void usc::SessionSwitcher::remove(std::string const& name)
+{
+    std::lock_guard<std::mutex> lock{mutex};
+
+    if (name == spinner_name)
+        spinner_name = "";
+
+    sessions.erase(name);
+    update_displayed_sessions();
+}
+
+void usc::SessionSwitcher::set_active_session(std::string const& name)
+{
+    std::lock_guard<std::mutex> lock{mutex};
+
+    active_name = name;
+    update_displayed_sessions();
+}
+
+void usc::SessionSwitcher::set_next_session(std::string const& name)
+{
+    std::lock_guard<std::mutex> lock{mutex};
+
+    next_name = name;
+    update_displayed_sessions();
+}
+
+void usc::SessionSwitcher::mark_ready(mir::scene::Session const* scene_session)
+{
+    std::lock_guard<std::mutex> lock{mutex};
+
+    for (auto& pair : sessions)
+    {
+        if (pair.second.session && pair.second.session->corresponds_to(scene_session))
+            pair.second.ready = true;
+    }
+
+    update_displayed_sessions();
+}
+
+void usc::SessionSwitcher::update_displayed_sessions()
+{
+    hide_uninteresting_sessions();
+
+    bool show_spinner = false;
+    ShowMode show_spinner_mode{ShowMode::as_next};
+    bool const allowed_to_display_active =
+        is_session_ready_for_display(next_name) ||
+        !is_session_expected_to_become_ready(next_name) ||
+        !booting;
+    bool show_active = false;
+
+    if (allowed_to_display_active && is_session_ready_for_display(active_name))
+    {
+        show_session(active_name, ShowMode::as_active);
+        show_active = true;
+        booting = false;
+    }
+    else if (is_session_expected_to_become_ready(active_name))
+    {
+        show_spinner = true;
+        show_spinner_mode = ShowMode::as_active;
+    }
+
+    bool const allowed_to_display_next = !show_spinner && show_active;
+
+    if (allowed_to_display_next)
+    {
+        if (is_session_ready_for_display(next_name))
+        {
+            show_session(next_name, ShowMode::as_next);
+        }
+        else if (is_session_expected_to_become_ready(next_name))
+        {
+            show_spinner = true;
+            show_spinner_mode = ShowMode::as_next;
+        }
+    }
+    else if (is_session_ready_for_display(next_name))
+    {
+        hide_session(next_name);
+    }
+
+    if (show_spinner)
+        ensure_spinner_will_be_shown(show_spinner_mode);
+    else
+        ensure_spinner_is_not_running();
+}
+
+void usc::SessionSwitcher::hide_uninteresting_sessions()
+{
+    for (auto const& pair : sessions)
+    {
+        if (pair.second.session->name() != active_name &&
+            pair.second.session->name() != next_name)
+        {
+            pair.second.session->hide();
+        }
+    }
+}
+
+bool usc::SessionSwitcher::is_session_ready_for_display(std::string const& name)
+{
+    auto const iter = sessions.find(name);
+    if (iter == sessions.end())
+        return false;
+
+    return iter->second.session && iter->second.ready;
+}
+
+bool usc::SessionSwitcher::is_session_expected_to_become_ready(std::string const& name)
+{
+    return !name.empty();
+}
+
+void usc::SessionSwitcher::show_session(
+    std::string const& name,
+    ShowMode show_mode)
+{
+    auto& session = sessions[name].session;
+
+    if (show_mode == ShowMode::as_active)
+        session->raise_and_focus();
+
+    session->show();
+}
+
+void usc::SessionSwitcher::hide_session(std::string const& name)
+{
+    auto& session = sessions[name].session;
+    session->hide();
+}
+
+void usc::SessionSwitcher::ensure_spinner_will_be_shown(ShowMode show_mode)
+{
+    auto const iter = sessions.find(spinner_name);
+    if (iter == sessions.end())
+    {
+        spinner_process->ensure_running();
+    }
+    else
+    {
+        if (show_mode == ShowMode::as_active)
+            iter->second.session->raise_and_focus();
+        iter->second.session->show();
+    }
+}
+
+void usc::SessionSwitcher::ensure_spinner_is_not_running()
+{
+    spinner_process->kill();
+}

=== added file 'src/session_switcher.h'
--- src/session_switcher.h	1970-01-01 00:00:00 +0000
+++ src/session_switcher.h	2014-07-18 09:49:03 +0000
@@ -0,0 +1,98 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef USC_SESSION_SWITCHER_H_
+#define USC_SESSION_SWITCHER_H_
+
+#include "dm_connection.h"
+
+#include <map>
+#include <memory>
+#include <mutex>
+
+namespace mir { namespace scene { class Session; }};
+namespace usc
+{
+class Spinner;
+
+class Session
+{
+public:
+    virtual ~Session() = default;
+
+    virtual std::string name() = 0;
+    virtual void show() = 0;
+    virtual void hide() = 0;
+    virtual void raise_and_focus() = 0;
+    virtual bool corresponds_to(mir::scene::Session const*) = 0;
+
+protected:
+    Session() = default;
+    Session(Session const&) = delete;
+    Session& operator=(Session const&) = delete;
+};
+
+class SessionSwitcher : public DMMessageHandler
+{
+public:
+    SessionSwitcher(std::shared_ptr<Spinner> const& spinner);
+
+    void add(std::shared_ptr<Session> const& session, pid_t pid);
+    void remove(std::string const& name);
+    void mark_ready(mir::scene::Session const*);
+
+    /* From DMMessageHandler */
+    void set_active_session(std::string const& name) override;
+    void set_next_session(std::string const& name) override;
+
+private:
+    enum class ShowMode { as_active, as_next };
+
+    void update_displayed_sessions();
+    void hide_uninteresting_sessions();
+    bool is_session_ready_for_display(std::string const& name);
+    bool is_session_expected_to_become_ready(std::string const& name);
+    void show_session(std::string const& name, ShowMode show_mode);
+    void hide_session(std::string const& name);
+    void ensure_spinner_will_be_shown(ShowMode show_mode);
+    void ensure_spinner_is_not_running();
+
+    struct SessionInfo
+    {
+        SessionInfo() = default;
+        SessionInfo(std::shared_ptr<Session> session)
+            : session{session}
+        {
+        }
+        std::shared_ptr<Session> session;
+        bool ready = false;
+    };
+
+    std::mutex mutex;
+    std::shared_ptr<Spinner> const spinner_process;
+    std::map<std::string, SessionInfo> sessions;
+    std::string active_name;
+    std::string next_name;
+    std::string spinner_name;
+    bool booting;
+};
+
+}
+
+#endif
+

=== added file 'src/spinner.h'
--- src/spinner.h	1970-01-01 00:00:00 +0000
+++ src/spinner.h	2014-07-18 09:49:03 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef USC_SPINNER_H_
+#define USC_SPINNER_H_
+
+#include <sys/types.h>
+
+namespace usc
+{
+
+class Spinner
+{
+public:
+    virtual ~Spinner() = default;
+
+    virtual void ensure_running() = 0;
+    virtual void kill() = 0;
+    virtual pid_t pid() = 0;
+
+protected:
+    Spinner() = default;
+    Spinner(Spinner const&) = delete;
+    Spinner& operator=(Spinner const&) = delete;
+};
+
+}
+
+#endif

=== added file 'src/surface_coordinator.cpp'
--- src/surface_coordinator.cpp	1970-01-01 00:00:00 +0000
+++ src/surface_coordinator.cpp	2014-07-18 09:49:03 +0000
@@ -0,0 +1,86 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "surface_coordinator.h"
+#include "session_switcher.h"
+
+#include <mir/scene/null_surface_observer.h>
+#include <mir/scene/surface.h>
+
+namespace ms = mir::scene;
+namespace msh = mir::shell;
+
+namespace
+{
+
+struct SessionReadyObserver : ms::NullSurfaceObserver,
+                              std::enable_shared_from_this<SessionReadyObserver>
+{
+    SessionReadyObserver(
+        std::shared_ptr<usc::SessionSwitcher> const& switcher,
+        std::shared_ptr<ms::Surface> const& surface,
+        ms::Session const* session)
+        : switcher{switcher},
+          surface{surface},
+          session{session}
+    {
+    }
+
+    void frame_posted(int) override
+    {
+        ++num_frames_posted;
+        if (num_frames_posted == num_frames_for_session_ready)
+        {
+            switcher->mark_ready(session);
+            surface->remove_observer(shared_from_this());
+        }
+    }
+
+    std::shared_ptr<usc::SessionSwitcher> const switcher;
+    std::shared_ptr<ms::Surface> const surface;
+    ms::Session const* const session;
+    // We need to wait for the second frame before marking the session
+    // as ready. The first frame posted from sessions is a blank frame.
+    // TODO: Solve this issue at its root and remove this workaround
+    int const num_frames_for_session_ready{2};
+    int num_frames_posted{0};
+};
+
+}
+
+usc::SurfaceCoordinator::SurfaceCoordinator(
+    std::shared_ptr<ms::SurfaceCoordinator> const& wrapped,
+    std::shared_ptr<SessionSwitcher> const& session_switcher)
+    : msh::SurfaceCoordinatorWrapper{wrapped},
+      session_switcher{session_switcher}
+{
+}
+
+std::shared_ptr<ms::Surface> usc::SurfaceCoordinator::add_surface(
+    ms::SurfaceCreationParameters const& params,
+    ms::Session* session)
+{
+    auto const surface = msh::SurfaceCoordinatorWrapper::add_surface(params, session);
+
+    auto const session_ready_observer = std::make_shared<SessionReadyObserver>(
+        session_switcher, surface, session);
+
+    surface->add_observer(session_ready_observer);
+
+    return surface;
+}

=== added file 'src/surface_coordinator.h'
--- src/surface_coordinator.h	1970-01-01 00:00:00 +0000
+++ src/surface_coordinator.h	2014-07-18 09:49:03 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef USC_SURFACE_COORDINATOR_H_
+#define USC_SURFACE_COORDINATOR_H_
+
+#include <mir/shell/surface_coordinator_wrapper.h>
+
+#include <memory>
+
+namespace usc
+{
+class SessionSwitcher;
+
+class SurfaceCoordinator : public mir::shell::SurfaceCoordinatorWrapper
+{
+public:
+    SurfaceCoordinator(
+        std::shared_ptr<mir::scene::SurfaceCoordinator> const& wrapped,
+        std::shared_ptr<SessionSwitcher> const& session_switcher);
+
+private:
+    std::shared_ptr<mir::scene::Surface> add_surface(
+        mir::scene::SurfaceCreationParameters const& params,
+        mir::scene::Session* session) override;
+
+    std::shared_ptr<SessionSwitcher> const session_switcher;
+};
+
+}
+
+#endif

=== modified file 'src/system_compositor.cpp'
--- src/system_compositor.cpp	2014-07-15 19:26:10 +0000
+++ src/system_compositor.cpp	2014-07-18 09:49:03 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -14,10 +14,14 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Robert Ancell <[e-mail]>
+ *              Alexandros Frantzis <[e-mail]>
  */
 
 
 #include "system_compositor.h"
+#include "server_configuration.h"
+#include "dm_connection.h"
+#include "spinner.h"
 #include "screen_state_handler.h"
 #include "powerkey_handler.h"
 
@@ -26,21 +30,9 @@
 // method declarations
 #undef signals
 
+#include <mir/input/composite_event_filter.h>
 #include <mir/run_mir.h>
 #include <mir/abnormal_exit.h>
-#include <mir/compositor/compositor_id.h>
-#include <mir/compositor/scene.h>
-#include <mir/compositor/scene_element.h>
-#include <mir/default_server_configuration.h>
-#include <mir/options/default_configuration.h>
-#include <mir/frontend/shell.h>
-#include <mir/scene/surface.h>
-#include <mir/scene/surface_coordinator.h>
-#include <mir/scene/session.h>
-#include <mir/server_status_listener.h>
-#include <mir/shell/focus_controller.h>
-#include <mir/input/cursor_listener.h>
-#include <mir/input/composite_event_filter.h>
 #include <mir/main_loop.h>
 
 #include <cerrno>
@@ -49,664 +41,16 @@
 #include <thread>
 #include <regex.h>
 #include <GLES2/gl2.h>
-#include <boost/algorithm/string.hpp>
 #include <QCoreApplication>
 
-namespace geom = mir::geometry;
-namespace mc = mir::compositor;
-namespace msh = mir::shell;
-namespace msc = mir::scene;
-namespace mf = mir::frontend;
-namespace mg = mir::graphics;
-namespace mi = mir::input;
-namespace mo = mir::options;
-namespace po = boost::program_options;
-
-class SystemCompositorSurface;
-
-class SystemCompositorSession : public msc::Session
-{
-public:
-    SystemCompositorSession(std::shared_ptr<msc::Session> const& self,
-                            SystemCompositorShell *shell)
-        : self{self}, shell{shell}, ready{false} {}
-
-    // These are defined below, since they reference methods defined in other classes
-    void mark_ready();
-    void raise(std::shared_ptr<msc::SurfaceCoordinator> const& coordinator);
-    std::shared_ptr<mf::Surface> get_surface(mf::SurfaceId surface) const override;
-    mf::SurfaceId create_surface(msc::SurfaceCreationParameters const& params) override;
-
-    bool is_ready() const
-    {
-        return ready;
-    }
-
-    std::shared_ptr<msc::Session> get_orig()
-    {
-        return self;
-    }
-
-    void destroy_surface(mf::SurfaceId surface) override
-    {
-        surfaces.erase(surface);
-        self->destroy_surface(surface);
-    }
-
-    // This is just for convience of USC
-    std::vector<std::shared_ptr<SystemCompositorSurface>> get_surfaces()
-    {
-        std::vector<std::shared_ptr<SystemCompositorSurface>> vector;
-        for(auto surface: surfaces)
-            vector.push_back(surface.second);
-        return vector;
-    }
-
-    std::string name() const override {return self->name();}
-    void hide() override {self->hide();}
-    void show() override {self->show();}
-    void send_display_config(mg::DisplayConfiguration const&config) override {self->send_display_config(config);}
-    pid_t process_id() const override {return self->process_id();}
-    void force_requests_to_complete() override {self->force_requests_to_complete();}
-    void take_snapshot(msc::SnapshotCallback const& snapshot_taken) override {self->take_snapshot(snapshot_taken);}
-    std::shared_ptr<msc::Surface> default_surface() const override {return self->default_surface();}
-    void set_lifecycle_state(MirLifecycleState state) override {self->set_lifecycle_state(state);}
-
-    void start_prompt_session() override { self->start_prompt_session(); }
-    void stop_prompt_session() override { self->stop_prompt_session(); }
-
-private:
-    std::shared_ptr<msc::Session> const self;
-    SystemCompositorShell *shell;
-    std::map<mf::SurfaceId, std::shared_ptr<SystemCompositorSurface>> surfaces;
-    bool ready;
-};
-
-class SystemCompositorSurface : public msc::Surface
-{
-public:
-    SystemCompositorSurface(std::shared_ptr<msc::Surface> const& self,
-                            SystemCompositorSession *session)
-        : self{self}, session{session}, buffer_count{0} {}
-
-    std::shared_ptr<msc::Surface> get_orig()
-    {
-        return self;
-    }
-
-    void swap_buffers(mg::Buffer* old_buffer, std::function<void(mg::Buffer* new_buffer)> complete) override
-    {
-        self->swap_buffers(old_buffer, complete);
-        // Mark it available only after some content has been rendered
-        if (old_buffer != NULL && !session->is_ready() && buffer_count++ == 1)
-            session->mark_ready();
-    }
-
-    // mf::Surface methods
-    void force_requests_to_complete() override {self->force_requests_to_complete();}
-    geom::Size size() const override {return self->size();}
-    MirPixelFormat pixel_format() const override {return self->pixel_format();}
-    bool supports_input() const override {return self->supports_input();}
-    int client_input_fd() const override {return self->client_input_fd();}
-    int configure(MirSurfaceAttrib attrib, int value) override {return self->configure(attrib, value);}
-
-    // msc::Surface methods
-    std::string name() const override {return self->name();}
-    geom::Size client_size() const override { return self->client_size(); };
-    geom::Rectangle input_bounds() const override { return self->input_bounds(); };
-
-    MirSurfaceType type() const override {return self->type();}
-    MirSurfaceState state() const override {return self->state();}
-    void hide() override {self->hide();}
-    void show() override {self->show();}
-    void move_to(geom::Point const& top_left) override {self->move_to(top_left);}
-    geom::Point top_left() const override {return self->top_left();}
-    void take_input_focus(std::shared_ptr<msh::InputTargeter> const& targeter) override {self->take_input_focus(targeter);}
-    void set_input_region(std::vector<geom::Rectangle> const& region) override {self->set_input_region(region);}
-    void allow_framedropping(bool allow) override {self->allow_framedropping(allow);}
-    void resize(geom::Size const& size) override {self->resize(size);}
-    void set_transformation(glm::mat4 const& t) override {self->set_transformation(t);}
-    float alpha() const override {return self->alpha();}
-    void set_alpha(float alpha) override {self->set_alpha(alpha);}
-    void with_most_recent_buffer_do(std::function<void(mg::Buffer&)> const& exec) override {self->with_most_recent_buffer_do(exec);}
-
-    // msc::Surface methods
-    std::shared_ptr<mi::InputChannel> input_channel() const override {return self->input_channel();}
-    void set_reception_mode(mi::InputReceptionMode mode) override { self->set_reception_mode(mode); }
-    void add_observer(std::shared_ptr<msc::SurfaceObserver> const& observer) override {self->add_observer(observer);}
-    void remove_observer(std::weak_ptr<msc::SurfaceObserver> const& observer) override {self->remove_observer(observer);}
-    void consume(MirEvent const& event) override {self->consume(event);}
-    void set_orientation(MirOrientation orientation) override {self->set_orientation(orientation);}
-
-    // mi::Surface methods
-    bool input_area_contains(geom::Point const& point) const override {return self->input_area_contains(point);}
-    mi::InputReceptionMode reception_mode() const override { return self->reception_mode(); }
-
-    // mg::Renderable methods
-    std::unique_ptr<mg::Renderable> compositor_snapshot(void const* compositor_id) const override { return self->compositor_snapshot(compositor_id); }
-
-    void set_cursor_image(std::shared_ptr<mg::CursorImage> const& image) override { self->set_cursor_image(image); }
-    std::shared_ptr<mg::CursorImage> cursor_image() const override { return self->cursor_image(); }
-
-private:
-    std::shared_ptr<msc::Surface> const self;
-    SystemCompositorSession *session;
-    int buffer_count;
-};
-
-class SystemCompositorShell : public mf::Shell
-{
-public:
-    SystemCompositorShell(SystemCompositor *compositor,
-                          std::shared_ptr<mf::Shell> const& self,
-                          std::shared_ptr<msh::FocusController> const& focus_controller,
-                          std::shared_ptr<msc::SurfaceCoordinator> const& surface_coordinator)
-        : compositor{compositor}, self(self), focus_controller{focus_controller}, surface_coordinator{surface_coordinator}, active_ever_used{false} {}
-
-    std::shared_ptr<mf::Session> session_named(std::string const& name)
-    {
-        return sessions[name];
-    }
-
-    void set_active_session(std::string const& name)
-    {
-        active_name = name;
-        update_session_focus();
-    }
-
-    void set_next_session(std::string const& name)
-    {
-        next_name = name;
-        update_session_focus();
-    }
-
-    std::shared_ptr<SystemCompositorSession> get_active_session()
-    {
-        return active_session;
-    }
-
-    std::shared_ptr<SystemCompositorSession> get_next_session()
-    {
-        return next_session;
-    }
-
-    void update_session_focus()
-    {
-        auto spinner = sessions[spinner_name];
-        auto next = sessions[next_name];
-        auto active = sessions[active_name];
-        bool need_spinner = false;
-
-        if (spinner)
-            spinner->hide();
-
-        if (next && next->is_ready())
-        {
-            std::cerr << "Setting next focus to session " << next_name;
-            next->hide();
-            next->raise(surface_coordinator);
-            next_session = next;
-        }
-        else if (!next_name.empty() && spinner)
-        {
-            std::cerr << "Setting next focus to spinner";
-            spinner->raise(surface_coordinator);
-            next_session = spinner;
-            need_spinner = true;
-        }
-        else
-        {
-            need_spinner = !next_name.empty();
-            std::cerr << "Setting no next focus";
-            next_session.reset();
-        }
-
-        // If we are booting, we want to wait for next session to be ready to
-        // go (it's a smoother experience if user is able to immediately swipe
-        // greeter out of way -- enough that it's worth the tiny wait).  So
-        // check here to see if next is all ready for us (or we've already
-        // focused the active before in which case we're not booting anymore).
-        bool next_all_set = next_name.empty() || (next && next->is_ready());
-        if (active && active->is_ready() && (next_all_set || active_ever_used))
-        {
-            std::cerr << "; active focus to session " << active_name;
-            focus_controller->set_focus_to(active); // raises and focuses
-            active_ever_used = true;
-            active_session = active;
-            if (active_session == next_session)
-                next_session.reset();
-        }
-        else if (!active_name.empty() && spinner)
-        {
-            std::cerr << "; active focus to spinner";
-            focus_controller->set_focus_to(spinner); // raises and focuses
-            active_session = spinner;
-            next_session.reset();
-            need_spinner = true;
-        }
-        else
-        {
-            need_spinner = need_spinner || !active_name.empty();
-            std::cerr << "; no active focus";
-            active_session.reset();
-            next_session.reset();
-        }
-
-        if (active_session)
-            active_session->show();
-        if (next_session)
-            next_session->show();
-
-        if (need_spinner)
-            compositor->ensure_spinner();
-        else
-            compositor->kill_spinner();
-
-        std::cerr << std::endl;
-    }
-
-    std::shared_ptr<mf::PromptSession> start_prompt_session_for(
-        std::shared_ptr<mf::Session> const& session,
-        msc::PromptSessionCreationParameters const& params) override
-    {
-        return self->start_prompt_session_for(session, params);
-    }
-
-    void add_prompt_provider_for(
-        std::shared_ptr<mf::PromptSession> const& prompt_session,
-        std::shared_ptr<mf::Session> const& session) override
-    {
-        self->add_prompt_provider_for(prompt_session, session);
-    }
-
-    void stop_prompt_session(std::shared_ptr<mf::PromptSession> const& prompt_session) override
-    {
-        self->stop_prompt_session(prompt_session);
-    }
-
-private:
-    std::shared_ptr<mf::Session> open_session(
-        pid_t client_pid,
-        std::string const& name,
-        std::shared_ptr<mf::EventSink> const& sink) override
-    {
-        std::cerr << "Opening session " << name << std::endl;
-
-        // We need msc::Session objects because that is what the focus controller
-        // works with.  But the mf::Shell interface deals with mf::Session objects.
-        // So we cast here since in practice, these objects are also msc::Sessions.
-        auto orig = std::dynamic_pointer_cast<msc::Session>(self->open_session(client_pid, name, sink));
-        if (!orig)
-        {
-            std::cerr << "Unexpected non-shell session" << std::endl;
-            return std::shared_ptr<mf::Session>();
-        }
-
-        auto result = std::make_shared<SystemCompositorSession>(orig, this);
-        sessions[name] = result;
-
-        if (client_pid == compositor->get_spinner_pid())
-            spinner_name = name;
-
-        return result;
-    }
-
-    void close_session(std::shared_ptr<mf::Session> const& session_in) override
-    {
-        std::cerr << "Closing session " << session_in->name() << std::endl;
-
-        auto session = std::dynamic_pointer_cast<SystemCompositorSession>(session_in);
-        if (!session)
-            return; // shouldn't happen
-
-        if (session->name() == spinner_name)
-            spinner_name = "";
-
-        self->close_session(session->get_orig());
-        sessions.erase(session->name());
-    }
-
-    mf::SurfaceId create_surface_for(
-        std::shared_ptr<mf::Session> const& session,
-        msc::SurfaceCreationParameters const& params) override
-    {
-        return self->create_surface_for(session, params);
-    }
-
-    void handle_surface_created(std::shared_ptr<mf::Session> const& session) override
-    {
-        self->handle_surface_created(session);
-
-        // Opening a new surface will steal focus from our active surface, so
-        // restore the focus if needed.
-        update_session_focus();
-    }
-
-    SystemCompositor *compositor;
-    std::shared_ptr<mf::Shell> const self;
-    std::shared_ptr<msh::FocusController> const focus_controller;
-    std::shared_ptr<msc::SurfaceCoordinator> const surface_coordinator;
-    std::map<std::string, std::shared_ptr<SystemCompositorSession>> sessions;
-    std::string active_name;
-    std::string next_name;
-    std::string spinner_name;
-    std::shared_ptr<SystemCompositorSession> active_session;
-    std::shared_ptr<SystemCompositorSession> next_session;
-    bool active_ever_used;
-};
-
-class SurfaceSceneElement : public mc::SceneElement
-{
-public:
-    SurfaceSceneElement(std::shared_ptr<mg::Renderable> renderable)
-        : renderable_{renderable}
-    {
-    }
-
-    std::shared_ptr<mg::Renderable> renderable() const override
-    {
-        return renderable_;
-    }
-
-    void rendered_in(mc::CompositorID) override {}
-    void occluded_in(mc::CompositorID) override {}
-
-private:
-    std::shared_ptr<mg::Renderable> const renderable_;
-};
-
-class SystemCompositorScene : public mc::Scene
-{
-public:
-    SystemCompositorScene(std::shared_ptr<mc::Scene> const& self)
-        : self{self}, shell{nullptr} {}
-
-    void set_shell(std::shared_ptr<SystemCompositorShell> const& the_shell)
-    {
-        shell = the_shell;
-    }
-
-    mc::SceneElementSequence scene_elements_for(mc::CompositorID id) override
-    {
-        if (shell == nullptr)
-            return self->scene_elements_for(id);
-
-        mc::SceneElementSequence elements;
-        std::shared_ptr<SystemCompositorSession> session;
-
-        session = shell->get_next_session();
-        if (session)
-        {
-            for (auto const& surface : session->get_surfaces()) {
-                // An open question is whether this memory allocation overhead (as this method is
-                // called for every rendered frame) is perceivable/significant at all to warrant
-                // an optimization here.
-                auto element = std::make_shared<SurfaceSceneElement>(surface->compositor_snapshot(id));
-                elements.emplace_back(element);
-            }
-        }
-
-        session = shell->get_active_session();
-        if (session)
-        {
-            for (auto const& surface : session->get_surfaces()) {
-                // see comment previous comment
-                auto element = std::make_shared<SurfaceSceneElement>(surface->compositor_snapshot(id));
-                elements.emplace_back(element);
-            }
-        }
-
-        return elements;
-    }
-
-    void add_observer(std::shared_ptr<msc::Observer> const& observer) override { self->add_observer(observer); }
-    void remove_observer(std::weak_ptr<msc::Observer> const& observer) override { self->remove_observer(observer); }
-
-    void register_compositor(mc::CompositorID id) override { self->register_compositor(id); }
-    void unregister_compositor(mc::CompositorID id) override { self->unregister_compositor(id); }
-
-
-private:
-    std::shared_ptr<mc::Scene> const self;
-    std::shared_ptr<SystemCompositorShell> shell;
-};
-
-
-void SystemCompositorSession::mark_ready()
-{
-    if (!ready)
-    {
-        ready = true;
-        shell->update_session_focus();
-    }
-}
-
-void SystemCompositorSession::raise(std::shared_ptr<msc::SurfaceCoordinator> const& coordinator)
-{
-    std::map<mf::SurfaceId, std::shared_ptr<SystemCompositorSurface>>::iterator iter;
-    for (iter = surfaces.begin(); iter != surfaces.end(); ++iter)
-    {
-        // This will iterate by creation order, which is fine.  New surfaces on top
-        coordinator->raise(iter->second->get_orig());
-    }
-}
-
-std::shared_ptr<mf::Surface> SystemCompositorSession::get_surface(mf::SurfaceId surface) const
-{
-    return surfaces.at(surface);
-}
-
-mf::SurfaceId SystemCompositorSession::create_surface(msc::SurfaceCreationParameters const& params)
-{
-    mf::SurfaceId id = self->create_surface(params);
-    std::shared_ptr<mf::Surface> mf_surface = self->get_surface(id);
-
-    auto surface = std::dynamic_pointer_cast<msc::Surface>(mf_surface);
-    if (!surface)
-    {
-        std::cerr << "Unexpected non-scene surface" << std::endl;
-        self->destroy_surface(id);
-        return mf::SurfaceId(0);
-    }
-
-    surfaces[id] = std::make_shared<SystemCompositorSurface>(surface, this);
-    return id;
-}
-
-class SystemCompositorServerConfiguration : public mir::DefaultServerConfiguration
-{
-public:
-    SystemCompositorServerConfiguration(SystemCompositor *compositor, std::shared_ptr<mo::Configuration> options)
-        : mir::DefaultServerConfiguration(options), compositor{compositor}
-    {
-    }
-
-    int from_dm_fd()
-    {
-        return the_options()->get("from-dm-fd", -1);
-    }
-
-    int to_dm_fd()
-    {
-        return the_options()->get("to-dm-fd", -1);
-    }
-
-    bool show_version()
-    {
-        return the_options()->is_set("version");
-    }
-
-    int inactivity_display_off_timeout()
-    {
-       return the_options()->get("inactivity-display-off-timeout", 60);
-    }
-
-    int inactivity_display_dim_timeout()
-    {
-       return the_options()->get("inactivity-display-dim-timeout", 45);
-    }
-
-    int shutdown_timeout()
-    {
-       return the_options()->get("shutdown-timeout", 5000);
-    }
-
-    int power_key_ignore_timeout()
-    {
-       return the_options()->get("power-key-ignore-timeout", 1500);
-    }
-
-    bool enable_hardware_cursor()
-    {
-        return the_options()->get("enable-hardware-cursor", false);
-    }
-
-    bool disable_inactivity_policy()
-    {
-        return the_options()->get("disable-inactivity-policy", false);
-    }
-
-    std::string blacklist()
-    {
-        auto x = the_options()->get("blacklist", "");
-        boost::trim(x);
-        return x;
-    }
-
-    std::string spinner()
-    {
-        // TODO: once our default spinner is ready for use everywhere, replace
-        // default value with DEFAULT_SPINNER instead of the empty string.
-        auto x = the_options()->get("spinner", "");
-        boost::trim(x);
-        return x;
-    }
-
-    bool public_socket()
-    {
-        return !the_options()->is_set("no-file") && the_options()->get("public-socket", true);
-    }
-
-    std::shared_ptr<mi::CursorListener> the_cursor_listener() override
-    {
-        struct NullCursorListener : public mi::CursorListener
-        {
-            void cursor_moved_to(float, float) override
-            {
-            }
-        };
-
-        // This is a workaround for u8 desktop preview in 14.04 for the lack of client cursor API.
-        // We need to disable the cursor for XMir but leave it on for the desktop preview.
-        // Luckily as it stands they run inside seperate instances of USC. ~racarr
-        if (enable_hardware_cursor())
-            return mir::DefaultServerConfiguration::the_cursor_listener();
-        else
-            return std::make_shared<NullCursorListener>();
-    }
-
-    std::shared_ptr<mir::ServerStatusListener> the_server_status_listener() override
-    {
-        struct ServerStatusListener : public mir::ServerStatusListener
-        {
-            ServerStatusListener (SystemCompositor *compositor) : compositor{compositor} {}
-
-            void paused() override
-            {
-                compositor->pause();
-            }
-
-            void resumed() override
-            {
-                compositor->resume();
-            }
-
-            void started() override
-            {
-            }
-
-            SystemCompositor *compositor;
-        };
-        return std::make_shared<ServerStatusListener>(compositor);
-    }
-
-    std::string get_socket_file()
-    {
-        // the_socket_file is private, so we have to re-implement it here
-        return the_options()->get("file", "/tmp/mir_socket");
-    }
-
-    std::shared_ptr<SystemCompositorShell> the_system_compositor_shell()
-    {
-        auto shell =  sc_shell([this]
-        {
-            return std::make_shared<SystemCompositorShell>(
-                compositor,
-                mir::DefaultServerConfiguration::the_frontend_shell(),
-                the_focus_controller(),
-                the_surface_coordinator());
-        });
-
-        the_system_compositor_scene()->set_shell(shell);
-        return shell;
-    }
-
-    std::shared_ptr<SystemCompositorScene> the_system_compositor_scene()
-    {
-        return sc_scene([this]
-        {
-            return std::make_shared<SystemCompositorScene>(
-                mir::DefaultServerConfiguration::the_scene());
-        });
-    }
-
-    std::shared_ptr<mc::Scene> the_scene()
-    {
-        return the_system_compositor_scene();
-    }
-
-private:
-    mir::CachedPtr<SystemCompositorShell> sc_shell;
-    mir::CachedPtr<SystemCompositorScene> sc_scene;
-
-    std::shared_ptr<mf::Shell> the_frontend_shell() override
-    {
-        return the_system_compositor_shell();
-    }
-
-    SystemCompositor *compositor;
-};
-
-class SystemCompositorConfigurationOptions : public mo::DefaultConfiguration
-{
-public:
-    SystemCompositorConfigurationOptions(int argc, char const* argv[]) :
-        DefaultConfiguration(argc, argv)
-    {
-        add_options()
-            ("from-dm-fd", po::value<int>(),  "File descriptor of read end of pipe from display manager [int]")
-            ("to-dm-fd", po::value<int>(),  "File descriptor of write end of pipe to display manager [int]")
-            ("blacklist", po::value<std::string>(), "Video blacklist regex to use")
-            ("version", "Show version of Unity System Compositor")
-            ("spinner", po::value<std::string>(), "Path to spinner executable")
-            ("public-socket", po::value<bool>(), "Make the socket file publicly writable")
-            ("enable-hardware-cursor", po::value<bool>(), "Enable the hardware cursor (disabled by default)")
-            ("inactivity-display-off-timeout", po::value<int>(), "The time in seconds before the screen is turned off when there are no active sessions")
-            ("inactivity-display-dim-timeout", po::value<int>(), "The time in seconds before the screen is dimmed when there are no active sessions")
-            ("shutdown-timeout", po::value<int>(), "The time in milli-seconds the power key must be held to initiate a clean system shutdown")
-            ("power-key-ignore-timeout", po::value<int>(), "The time in milli-seconds the power key must be held to ignore - must be less than shutdown-timeout")
-            ("disable-inactivity-policy", po::value<bool>(), "Disables handling user inactivity and power key");
-    }
-
-    void parse_config_file(
-        boost::program_options::options_description& options_description,
-        mo::ProgramOption& options) const override
-    {
-        options.parse_file(options_description, "unity-system-compositor.conf");
-    }
-};
-
-bool check_blacklist(std::string blacklist, const char *vendor, const char *renderer, const char *version)
+namespace
+{
+
+bool check_blacklist(
+    std::string const& blacklist,
+    const char *vendor,
+    const char *renderer,
+    const char *version)
 {
     if (blacklist.empty())
         return true;
@@ -739,35 +83,37 @@
     return true;
 }
 
-void SystemCompositor::run(int argc, char **argv)
-{
-    auto const options = std::make_shared<SystemCompositorConfigurationOptions>(argc, const_cast<char const **>(argv));
-    config = std::make_shared<SystemCompositorServerConfiguration>(this, options);
-
+}
+
+usc::SystemCompositor::SystemCompositor(
+    std::shared_ptr<ServerConfiguration> const& config)
+    : config{config},
+      dm_connection{config->the_dm_connection()},
+      spinner{config->the_spinner()}
+{
+}
+
+void usc::SystemCompositor::run()
+{
     if (config->show_version())
     {
         std::cerr << "unity-system-compositor " << USC_VERSION << std::endl;
         return;
     }
 
-    dm_connection = std::make_shared<DMConnection>(io_service, config->from_dm_fd(), config->to_dm_fd());
-
     struct ScopeGuard
     {
-        explicit ScopeGuard(boost::asio::io_service& io_service) : io_service(io_service) {}
         ~ScopeGuard()
         {
-            io_service.stop();
-            if (io_thread.joinable())
-                io_thread.join();
             if (qt_thread.joinable())
+            {
+                QCoreApplication::quit();
                 qt_thread.join();
+            }
         }
 
-        boost::asio::io_service& io_service;
-        std::thread io_thread;
         std::thread qt_thread;
-    } guard(io_service);
+    } guard;
 
     mir::run_mir(*config, [&](mir::DisplayServer&)
         {
@@ -781,46 +127,12 @@
             if (!check_blacklist(config->blacklist(), vendor, renderer, version))
                 throw mir::AbnormalExit ("Video driver is blacklisted, exiting");
 
-            shell = config->the_system_compositor_shell();
-            guard.io_thread = std::thread(&SystemCompositor::main, this);
-            guard.qt_thread = std::thread(&SystemCompositor::qt_main, this, argc, argv);
+            main();
+            guard.qt_thread = std::thread(&SystemCompositor::qt_main, this);
         });
 }
 
-void SystemCompositor::pause()
-{
-    std::cerr << "pause" << std::endl;
-
-    if (auto active_session = config->the_focus_controller()->focussed_application().lock())
-        active_session->set_lifecycle_state(mir_lifecycle_state_will_suspend);
-}
-
-void SystemCompositor::resume()
-{
-    std::cerr << "resume" << std::endl;
-
-    if (auto active_session = config->the_focus_controller()->focussed_application().lock())
-        active_session->set_lifecycle_state(mir_lifecycle_state_resumed);
-}
-
-pid_t SystemCompositor::get_spinner_pid() const
-{
-    return spinner_process.pid();
-}
-
-void SystemCompositor::set_active_session(std::string client_name)
-{
-    std::cerr << "set_active_session" << std::endl;
-    shell->set_active_session(client_name);
-}
-
-void SystemCompositor::set_next_session(std::string client_name)
-{
-    std::cerr << "set_next_session" << std::endl;
-    shell->set_next_session(client_name);
-}
-
-void SystemCompositor::main()
+void usc::SystemCompositor::main()
 {
     // Make socket world-writable, since users need to talk to us.  No worries
     // about race condition, since we are adding permissions, not restricting
@@ -828,33 +140,13 @@
     if (config->public_socket() && chmod(config->get_socket_file().c_str(), 0777) == -1)
         std::cerr << "Unable to chmod socket file " << config->get_socket_file() << ": " << strerror(errno) << std::endl;
 
-    dm_connection->set_handler(this);
     dm_connection->start();
-    dm_connection->send_ready();
-
-    io_service.run();
-}
-
-void SystemCompositor::ensure_spinner()
-{
-    if (config->spinner().empty() || spinner_process.state() != QProcess::NotRunning)
-        return;
-
-    // Launch spinner process to provide default background when a session isn't ready
-    QStringList env = QProcess::systemEnvironment();
-    env << "MIR_SOCKET=" + QString(config->get_socket_file().c_str());
-    spinner_process.setEnvironment(env);
-    spinner_process.start(config->spinner().c_str());
-}
-
-void SystemCompositor::kill_spinner()
-{
-    spinner_process.close();
-}
-
-void SystemCompositor::qt_main(int argc, char **argv)
-{
-    QCoreApplication app(argc, argv);
+}
+
+void usc::SystemCompositor::qt_main()
+{
+    int argc{0};
+    QCoreApplication app(argc, nullptr);
 
     if (!config->disable_inactivity_policy())
     {
@@ -877,6 +169,11 @@
         composite_filter->append(power_key_handler);
     }
 
-    ensure_spinner();
     app.exec();
+
+    // Destroy components that depend on Qt event handling inside the Qt thread,
+    // to silence warnings during shutdown
+
+    // ScreenStateHandler uses the Qt DBus infrastructure
+    screen_state_handler.reset();
 }

=== modified file 'src/system_compositor.h'
--- src/system_compositor.h	2014-06-20 16:35:15 +0000
+++ src/system_compositor.h	2014-07-18 09:49:03 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -14,44 +14,41 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Robert Ancell <[e-mail]>
+ *              Alexandros Frantzis <[e-mail]>
  */
 
-#ifndef SYSTEM_COMPOSITOR_H_
-#define SYSTEM_COMPOSITOR_H_
-
-#include "dm_connection.h"
-#include <QProcess>
-
-namespace mir { namespace scene { class Session; } }
-
-class SystemCompositorShell;
-class SystemCompositorServerConfiguration;
+#ifndef USC_SYSTEM_COMPOSITOR_H_
+#define USC_SYSTEM_COMPOSITOR_H_
+
+#include <memory>
+
 class ScreenStateHandler;
 class PowerKeyHandler;
 
-class SystemCompositor : public DMMessageHandler
+namespace usc
+{
+
+class ServerConfiguration;
+class DMConnection;
+class Spinner;
+
+class SystemCompositor
 {
 public:
-    void run(int argc, char **argv);
-    void pause();
-    void resume();
-    pid_t get_spinner_pid() const;
-    void ensure_spinner();
-    void kill_spinner();
+    SystemCompositor(std::shared_ptr<ServerConfiguration> const& config);
+    void run();
 
 private:
-    std::shared_ptr<SystemCompositorServerConfiguration> config;
-    std::shared_ptr<SystemCompositorShell> shell;
-    boost::asio::io_service io_service;
-    std::shared_ptr<DMConnection> dm_connection;
+    void main();
+    void qt_main();
+
+    std::shared_ptr<ServerConfiguration> const config;
+    std::shared_ptr<DMConnection> const dm_connection;
+    std::shared_ptr<Spinner> const spinner;
     std::shared_ptr<ScreenStateHandler> screen_state_handler;
     std::shared_ptr<PowerKeyHandler> power_key_handler;
-    QProcess spinner_process;
-
-    void set_active_session(std::string client_name);
-    void set_next_session(std::string client_name);
-    void main();
-    void qt_main(int argc, char **argv);
 };
 
-#endif /* SYSTEM_COMPOSITOR_H_ */
+}
+
+#endif /* USC_SYSTEM_COMPOSITOR_H_ */

=== added file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/CMakeLists.txt	2014-07-18 09:49:03 +0000
@@ -0,0 +1,17 @@
+# Copyright © 2014 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authored by: Alexandros Frantzis <[e-mail]>
+
+add_subdirectory(unit-tests/)

=== added directory 'tests/unit-tests'
=== added file 'tests/unit-tests/CMakeLists.txt'
--- tests/unit-tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/CMakeLists.txt	2014-07-18 09:49:03 +0000
@@ -0,0 +1,39 @@
+# Copyright © 2014 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authored by: Alexandros Frantzis <[e-mail]>
+
+include_directories(
+ ${CMAKE_SOURCE_DIR}
+ ${MIRSERVER_INCLUDE_DIRS}
+)
+
+add_executable(
+  usc_unit_tests
+
+  test_session_switcher.cpp
+)
+
+target_link_libraries(
+   usc_unit_tests
+
+   usc
+   ${GTEST_BOTH_LIBRARIES}
+   ${GMOCK_LIBRARY}
+   ${GMOCK_MAIN_LIBRARY}
+)
+
+add_test(usc_unit_tests ${EXECUTABLE_OUTPUT_PATH}/usc_unit_tests)
+
+add_dependencies(usc_unit_tests GMock)

=== added file 'tests/unit-tests/test_session_switcher.cpp'
--- tests/unit-tests/test_session_switcher.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/test_session_switcher.cpp	2014-07-18 09:49:03 +0000
@@ -0,0 +1,656 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "src/session_switcher.h"
+#include "src/spinner.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <memory>
+#include <vector>
+#include <tuple>
+
+namespace
+{
+
+class FakeScene
+{
+public:
+    void add(usc::Session* session)
+    {
+        sessions.emplace_back(session, true);
+    }
+
+    void remove(usc::Session* session)
+    {
+        sessions.erase(find(session));
+    }
+
+    void show(usc::Session* session)
+    {
+        find(session)->second = true;
+    }
+
+    void hide(usc::Session* session)
+    {
+        find(session)->second = false;
+    }
+
+    void raise(usc::Session* session)
+    {
+        auto const iter = find(session);
+        auto const pair = *iter;
+        sessions.erase(iter);
+        sessions.push_back(pair);
+    }
+
+    std::vector<std::string> displayed_sessions()
+    {
+        std::vector<std::string> ret;
+        for (auto const& pair : sessions)
+        {
+            bool session_visible = pair.second;
+            if (session_visible)
+                ret.push_back(pair.first->name());
+        }
+
+        return ret;
+    }
+
+private:
+    std::vector<std::pair<usc::Session*,bool>> sessions;
+
+    decltype(sessions)::iterator find(usc::Session* session)
+    {
+        return std::find_if(
+            sessions.begin(), sessions.end(),
+            [session] (decltype(sessions)::value_type const& p)
+            {
+                return p.first == session;
+            });
+    }
+};
+
+class StubSession : public usc::Session
+{
+public:
+    StubSession(FakeScene& fake_scene, std::string const& name)
+        : fake_scene(fake_scene),
+          name_{name}
+    {
+        fake_scene.add(this);
+    }
+
+    ~StubSession()
+    {
+        fake_scene.remove(this);
+    }
+
+    std::string name() override
+    {
+        return name_;
+    }
+
+    void show() override
+    {
+        fake_scene.show(this);
+    }
+
+    void hide() override
+    {
+        fake_scene.hide(this);
+    }
+
+    void raise_and_focus() override
+    {
+        fake_scene.raise(this);
+    }
+
+    bool corresponds_to(mir::scene::Session const* s) override
+    {
+        return s == corresponding_scene_session();
+    }
+
+    mir::scene::Session const* corresponding_scene_session()
+    {
+        return reinterpret_cast<mir::scene::Session const*>(this);
+    }
+
+private:
+    FakeScene& fake_scene;
+    std::string const name_;
+};
+
+struct StubSpinner : usc::Spinner
+{
+    void ensure_running() override { is_running_ = true; }
+    void kill() override { is_running_ = false; }
+    pid_t pid() override { return pid_; }
+
+    void set_pid(pid_t new_pid) { pid_ = new_pid; }
+    bool is_running() { return is_running_; }
+
+private:
+    bool is_running_ = false;
+    pid_t pid_ = 666;
+};
+
+struct ASessionSwitcher : testing::Test
+{
+    std::shared_ptr<StubSession> create_stub_session(std::string const& name)
+    {
+        return std::make_shared<StubSession>(fake_scene, name);
+    }
+
+    std::tuple<std::string,std::string> boot()
+    {
+        std::string const boot_active_name{"boot_active"};
+        std::string const boot_next_name{"boot_next"};
+
+        auto const boot_active = create_stub_session(boot_active_name);
+        auto const boot_next = create_stub_session(boot_next_name);
+
+        switcher.add(boot_active, active_pid);
+        switcher.add(boot_next, next_pid);
+
+        switcher.set_next_session(boot_next_name);
+        switcher.set_active_session(boot_active_name);
+        switcher.mark_ready(boot_active->corresponding_scene_session());
+        switcher.mark_ready(boot_next->corresponding_scene_session());
+
+        return std::make_tuple(boot_active_name, boot_next_name);
+    }
+
+    FakeScene fake_scene;
+    std::shared_ptr<StubSpinner> const stub_spinner{std::make_shared<StubSpinner>()};
+    usc::SessionSwitcher switcher{stub_spinner};
+    std::string const active_name{"active"};
+    std::string const next_name{"next"};
+    std::string const spinner_name{"spinner"};
+    pid_t const invalid_pid{0};
+    pid_t const active_pid{1000};
+    pid_t const next_pid{1001};
+    pid_t const other_pid{1002};
+};
+
+}
+
+TEST_F(ASessionSwitcher, does_not_display_any_session_if_active_and_next_not_set)
+{
+    using namespace testing;
+
+    switcher.add(create_stub_session("s1"), invalid_pid);
+    switcher.add(create_stub_session("s2"), invalid_pid);
+
+    EXPECT_THAT(fake_scene.displayed_sessions(), IsEmpty());
+}
+
+TEST_F(ASessionSwitcher, does_not_display_not_ready_active_session)
+{
+    using namespace testing;
+
+    auto const active = create_stub_session(active_name);
+
+    switcher.add(active, active_pid);
+    switcher.set_active_session(active_name);
+
+    EXPECT_THAT(fake_scene.displayed_sessions(), IsEmpty());
+}
+
+TEST_F(ASessionSwitcher, does_not_display_not_ready_next_session)
+{
+    using namespace testing;
+
+    auto const next = create_stub_session(next_name);
+
+    switcher.add(next, next_pid);
+    switcher.set_next_session(next_name);
+
+    EXPECT_THAT(fake_scene.displayed_sessions(), IsEmpty());
+}
+
+TEST_F(ASessionSwitcher, does_not_display_ready_next_session_without_ready_active_session)
+{
+    using namespace testing;
+
+    auto const next = create_stub_session(next_name);
+
+    switcher.add(next, next_pid);
+    switcher.set_next_session(next_name);
+    switcher.mark_ready(next->corresponding_scene_session());
+
+    EXPECT_THAT(fake_scene.displayed_sessions(), IsEmpty());
+}
+
+TEST_F(ASessionSwitcher,
+       does_not_display_any_session_on_boot_if_not_both_active_and_next_are_ready)
+{
+    using namespace testing;
+
+    auto const active = create_stub_session(active_name);
+    auto const next = create_stub_session(next_name);
+
+    switcher.add(active, active_pid);
+    switcher.add(next, next_pid);
+
+    switcher.set_active_session(active_name);
+    switcher.set_next_session(next_name);
+    switcher.mark_ready(active->corresponding_scene_session());
+
+    EXPECT_THAT(fake_scene.displayed_sessions(), IsEmpty());
+}
+
+TEST_F(ASessionSwitcher,
+       displays_the_active_session_on_boot_if_it_is_ready_and_there_is_no_next_session)
+{
+    using namespace testing;
+
+    auto const active = create_stub_session(active_name);
+    auto const spinner = create_stub_session(spinner_name);
+
+    switcher.add(active, active_pid);
+    switcher.add(spinner, stub_spinner->pid());
+
+    switcher.set_active_session(active_name);
+    switcher.mark_ready(active->corresponding_scene_session());
+
+    EXPECT_THAT(fake_scene.displayed_sessions(),
+                ElementsAre(active_name));
+}
+
+TEST_F(ASessionSwitcher, displays_the_active_session_after_boot_if_it_is_ready)
+{
+    using namespace testing;
+
+    boot();
+
+    auto const active = create_stub_session(active_name);
+    auto const next = create_stub_session(next_name);
+
+    switcher.add(active, active_pid);
+    switcher.add(next, next_pid);
+
+    switcher.set_next_session(next_name);
+    switcher.set_active_session(active_name);
+    switcher.mark_ready(active->corresponding_scene_session());
+
+    EXPECT_THAT(fake_scene.displayed_sessions(),
+                ElementsAre(active_name));
+}
+
+TEST_F(ASessionSwitcher, displays_active_over_next_if_both_are_ready)
+{
+    using namespace testing;
+
+    auto const active = create_stub_session(active_name);
+    auto const next = create_stub_session(next_name);
+
+    switcher.add(active, active_pid);
+    switcher.add(next, next_pid);
+
+    switcher.set_next_session(next_name);
+    switcher.set_active_session(active_name);
+    switcher.mark_ready(active->corresponding_scene_session());
+    switcher.mark_ready(next->corresponding_scene_session());
+
+    EXPECT_THAT(fake_scene.displayed_sessions(),
+                ElementsAre(next_name, active_name));
+}
+
+
+TEST_F(ASessionSwitcher, displays_only_active_if_next_equals_active)
+{
+    using namespace testing;
+
+    auto const active = create_stub_session(active_name);
+
+    switcher.add(active, active_pid);
+
+    switcher.set_next_session(active_name);
+    switcher.set_active_session(active_name);
+    switcher.mark_ready(active->corresponding_scene_session());
+
+    EXPECT_THAT(fake_scene.displayed_sessions(),
+                ElementsAre(active_name));
+}
+
+TEST_F(ASessionSwitcher, displays_only_active_and_next_sessions)
+{
+    using namespace testing;
+
+    auto const active = create_stub_session(active_name);
+    auto const next = create_stub_session(next_name);
+    auto const other = create_stub_session("other");
+
+    switcher.add(active, active_pid);
+    switcher.add(next, next_pid);
+    switcher.add(other, other_pid);
+
+    switcher.set_next_session(next_name);
+    switcher.set_active_session(active_name);
+    switcher.mark_ready(active->corresponding_scene_session());
+    switcher.mark_ready(next->corresponding_scene_session());
+    switcher.mark_ready(other->corresponding_scene_session());
+
+    EXPECT_THAT(fake_scene.displayed_sessions(),
+                ElementsAre(next_name, active_name));
+}
+
+TEST_F(ASessionSwitcher, displays_spinner_if_active_is_not_ready)
+{
+    using namespace testing;
+
+    auto const active = create_stub_session(active_name);
+    auto const spinner = create_stub_session(spinner_name);
+
+    switcher.add(active, active_pid);
+    switcher.add(spinner, stub_spinner->pid());
+
+    switcher.set_active_session(active_name);
+
+    EXPECT_THAT(fake_scene.displayed_sessions(),
+                ElementsAre(spinner_name));
+}
+
+TEST_F(ASessionSwitcher, does_not_display_spinner_if_next_is_not_ready)
+{
+    using namespace testing;
+
+    auto const next = create_stub_session(next_name);
+    auto const spinner = create_stub_session(spinner_name);
+
+    switcher.add(next, next_pid);
+    switcher.add(spinner, stub_spinner->pid());
+
+    switcher.set_next_session(next_name);
+
+    EXPECT_THAT(fake_scene.displayed_sessions(), IsEmpty());
+}
+
+TEST_F(ASessionSwitcher, displays_only_spinner_when_active_is_not_ready_but_next_is_ready)
+{
+    using namespace testing;
+
+    auto const active = create_stub_session(active_name);
+    auto const next = create_stub_session(next_name);
+    auto const spinner = create_stub_session(spinner_name);
+
+    switcher.add(active, active_pid);
+    switcher.add(next, next_pid);
+    switcher.add(spinner, stub_spinner->pid());
+
+    switcher.set_active_session(active_name);
+    switcher.set_next_session(next_name);
+    switcher.mark_ready(next->corresponding_scene_session());
+
+    EXPECT_THAT(fake_scene.displayed_sessions(),
+                ElementsAre(spinner_name));
+}
+
+TEST_F(ASessionSwitcher,
+       displays_only_spinner_when_booting_if_not_both_active_and_next_are_ready)
+{
+    using namespace testing;
+
+    auto const active = create_stub_session(active_name);
+    auto const next = create_stub_session(next_name);
+    auto const spinner = create_stub_session(spinner_name);
+
+    switcher.add(active, active_pid);
+    switcher.add(next, next_pid);
+    switcher.add(spinner, stub_spinner->pid());
+
+    switcher.set_active_session(active_name);
+    switcher.set_next_session(next_name);
+    switcher.mark_ready(active->corresponding_scene_session());
+
+    EXPECT_THAT(fake_scene.displayed_sessions(),
+                ElementsAre(spinner_name));
+}
+
+TEST_F(ASessionSwitcher,
+       displays_spinner_behind_active_after_boot_if_active_is_ready_but_next_is_not_ready)
+{
+    using namespace testing;
+
+    boot();
+
+    auto const active = create_stub_session(active_name);
+    auto const next = create_stub_session(next_name);
+    auto const spinner = create_stub_session(spinner_name);
+
+    switcher.add(active, active_pid);
+    switcher.add(next, next_pid);
+    switcher.add(spinner, stub_spinner->pid());
+
+    switcher.set_active_session(active_name);
+    switcher.set_next_session(next_name);
+    switcher.mark_ready(active->corresponding_scene_session());
+
+    EXPECT_THAT(fake_scene.displayed_sessions(),
+                ElementsAre(spinner_name, active_name));
+}
+
+TEST_F(ASessionSwitcher, starts_and_stops_spinner_as_needed)
+{
+    using namespace testing;
+
+    auto const active = create_stub_session(active_name);
+
+    switcher.add(active, active_pid);
+    switcher.set_active_session(active_name);
+
+    EXPECT_TRUE(stub_spinner->is_running());
+
+    switcher.mark_ready(active->corresponding_scene_session());
+
+    EXPECT_FALSE(stub_spinner->is_running());
+}
+
+TEST_F(ASessionSwitcher, does_not_display_next_when_active_is_removed)
+{
+    using namespace testing;
+
+    std::string const no_session_name;
+
+    std::string boot_active_name;
+    std::string boot_next_name;
+    std::tie(boot_active_name, boot_next_name) = boot();
+
+    auto const spinner = create_stub_session(spinner_name);
+    switcher.add(spinner, stub_spinner->pid());
+
+    switcher.remove(boot_active_name);
+    switcher.set_active_session(no_session_name);
+
+    EXPECT_THAT(fake_scene.displayed_sessions(), IsEmpty());
+}
+
+TEST_F(ASessionSwitcher, displays_only_active_not_spinner_when_next_is_removed)
+{
+    using namespace testing;
+
+    std::string const no_session_name;
+
+    std::string boot_active_name;
+    std::string boot_next_name;
+    std::tie(boot_active_name, boot_next_name) = boot();
+
+    auto const spinner = create_stub_session(spinner_name);
+    switcher.add(spinner, stub_spinner->pid());
+
+    switcher.remove(boot_next_name);
+    switcher.set_next_session(no_session_name);
+
+    EXPECT_THAT(fake_scene.displayed_sessions(),
+                ElementsAre(boot_active_name));
+}
+
+TEST_F(ASessionSwitcher, displays_spinner_when_active_is_removed_unexpectedly)
+{
+    using namespace testing;
+
+    std::string const no_session_name;
+
+    std::string boot_active_name;
+    std::string boot_next_name;
+    std::tie(boot_active_name, boot_next_name) = boot();
+
+    auto const spinner = create_stub_session(spinner_name);
+    switcher.add(spinner, stub_spinner->pid());
+
+    switcher.remove(boot_active_name);
+
+    EXPECT_THAT(fake_scene.displayed_sessions(),
+                ElementsAre(spinner_name));
+}
+
+TEST_F(ASessionSwitcher, displays_spinner_under_active_if_next_is_removed_unexpectedly)
+{
+    using namespace testing;
+
+    std::string const no_session_name;
+
+    std::string boot_active_name;
+    std::string boot_next_name;
+    std::tie(boot_active_name, boot_next_name) = boot();
+
+    auto const spinner = create_stub_session(spinner_name);
+    switcher.add(spinner, stub_spinner->pid());
+
+    switcher.remove(boot_next_name);
+
+    EXPECT_THAT(fake_scene.displayed_sessions(),
+                ElementsAre(spinner_name, boot_active_name));
+}
+
+TEST_F(ASessionSwitcher,
+       does_not_display_any_session_when_spinner_is_removed_and_no_sessions_are_ready)
+{
+    using namespace testing;
+
+    auto const active = create_stub_session(active_name);
+    auto spinner = create_stub_session(spinner_name);
+
+    switcher.add(active, active_pid);
+    switcher.add(spinner, stub_spinner->pid());
+
+    switcher.set_active_session(active_name);
+
+    EXPECT_THAT(fake_scene.displayed_sessions(), ElementsAre(spinner_name));
+
+    spinner.reset();
+    switcher.remove(spinner_name);
+
+    EXPECT_THAT(fake_scene.displayed_sessions(), IsEmpty());
+}
+
+TEST_F(ASessionSwitcher, can_handle_spinner_resurrection_under_different_name)
+{
+    using namespace testing;
+
+    auto const active = create_stub_session(active_name);
+    auto spinner = create_stub_session(spinner_name);
+
+    switcher.add(active, active_pid);
+    switcher.add(spinner, stub_spinner->pid());
+
+    switcher.set_active_session(active_name);
+
+    EXPECT_THAT(fake_scene.displayed_sessions(), ElementsAre(spinner_name));
+
+    spinner.reset();
+    switcher.remove(spinner_name);
+
+    std::string const new_spinner_name{"new_spinner_name"};
+    spinner = create_stub_session(new_spinner_name);
+    switcher.add(spinner, stub_spinner->pid());
+
+    EXPECT_THAT(fake_scene.displayed_sessions(), ElementsAre(new_spinner_name));
+}
+
+TEST_F(ASessionSwitcher, can_handle_spinner_resurrection_under_different_pid)
+{
+    using namespace testing;
+
+    auto const active = create_stub_session(active_name);
+    auto spinner = create_stub_session(spinner_name);
+
+    switcher.add(active, active_pid);
+    switcher.add(spinner, stub_spinner->pid());
+    switcher.set_active_session(active_name);
+
+    EXPECT_THAT(fake_scene.displayed_sessions(), ElementsAre(spinner_name));
+
+    spinner.reset();
+    switcher.remove(spinner_name);
+
+    pid_t const new_pid{1234};
+    stub_spinner->set_pid(new_pid);
+
+    spinner = create_stub_session(spinner_name);
+    switcher.add(spinner, stub_spinner->pid());
+
+    EXPECT_THAT(fake_scene.displayed_sessions(), ElementsAre(spinner_name));
+}
+
+TEST_F(ASessionSwitcher, is_not_confused_by_other_session_with_name_of_dead_spinner)
+{
+    using namespace testing;
+
+    auto const active = create_stub_session(active_name);
+    auto spinner = create_stub_session(spinner_name);
+
+    switcher.add(active, active_pid);
+    switcher.add(spinner, stub_spinner->pid());
+
+    switcher.set_active_session(active_name);
+
+    spinner.reset();
+    switcher.remove(spinner_name);
+    stub_spinner->set_pid(invalid_pid);
+
+    auto const other = create_stub_session(spinner_name);
+    switcher.add(other, other_pid);
+
+    EXPECT_THAT(fake_scene.displayed_sessions(), IsEmpty());
+}
+
+TEST_F(ASessionSwitcher, is_not_confused_by_other_session_with_pid_of_dead_spinner)
+{
+    using namespace testing;
+
+    auto const active = create_stub_session(active_name);
+    auto spinner = create_stub_session(spinner_name);
+
+    switcher.add(active, active_pid);
+    switcher.add(spinner, stub_spinner->pid());
+
+    switcher.set_active_session(active_name);
+
+    auto const old_spinner_pid = stub_spinner->pid();
+    stub_spinner->set_pid(invalid_pid);
+    spinner.reset();
+    switcher.remove(spinner_name);
+
+    auto const other = create_stub_session(spinner_name);
+    switcher.add(other, old_spinner_pid);
+
+    EXPECT_THAT(fake_scene.displayed_sessions(), IsEmpty());
+}