Merge lp:~alan-griffiths/unity-system-compositor/migrate-to-mir-Server-API into lp:unity-system-compositor

[Alan Griffiths]

Migration of unity-system-compositor from the legacy Mir API

Migration of unity-system-compositor from the legacy Mir API

[lp:~alan-griffiths/unity-system-compositor/migrate-to-mir-Server-API]

195. By Alan Griffiths on 2014-11-28

Restore lifetme of dm_connection

[Alan Griffiths (alan-griffiths)]

Works fine on krillin/15.04(r39)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:194
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/167/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-vivid-amd64-ci/4
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-vivid-armhf-ci/4

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:195
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/168/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-vivid-amd64-ci/5
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-vivid-armhf-ci/5

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

review: Approve (continuous-integration)

[Alexandros Frantzis (afrantzis)]

Looks good.

review: Approve

[Alberto Aguirre (albaguirre)]

LGTM. Tested on mako vivid #33

[Alberto Aguirre (albaguirre)]

review: Approve

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2014-09-16 00:20:05 +0000
+++ src/CMakeLists.txt	2014-11-28 13:19:40 +0000
@@ -21,7 +21,7 @@
   powerd_mediator.cpp
   powerkey_handler.cpp
   screen_state_handler.cpp
-  server_configuration.cpp
+  server.cpp
   session_coordinator.cpp
   session_switcher.cpp
   surface_coordinator.cpp

=== modified file 'src/main.cpp'
--- src/main.cpp	2014-07-09 06:58:05 +0000
+++ src/main.cpp	2014-11-28 13:19:40 +0000
@@ -18,7 +18,7 @@
  */
 
 #include "system_compositor.h"
-#include "server_configuration.h"
+#include "server.h"
 
 #include <mir/report_exception.h>
 #include <iostream>
@@ -26,7 +26,7 @@
 int main(int argc, char *argv[])
 try
 {
-    auto const config = std::make_shared<usc::ServerConfiguration>(argc, argv);
+    auto const config = std::make_shared<usc::Server>(argc, argv);
 
     usc::SystemCompositor system_compositor{config};
     system_compositor.run();

=== modified file 'src/powerkey_handler.h'
--- src/powerkey_handler.h	2014-07-21 21:33:35 +0000
+++ src/powerkey_handler.h	2014-11-28 13:19:40 +0000
@@ -26,7 +26,6 @@
 
 namespace mir
 {
-class DefaultServerConfiguration;
 namespace time
 {
 class Alarm;

=== modified file 'src/screen_state_handler.cpp'
--- src/screen_state_handler.cpp	2014-09-22 17:19:52 +0000
+++ src/screen_state_handler.cpp	2014-11-28 13:19:40 +0000
@@ -19,7 +19,6 @@
 #include <mir/main_loop.h>
 #include <mir/time/timer.h>
 #include <mir/compositor/compositor.h>
-#include <mir/default_server_configuration.h>
 #include <mir/graphics/display.h>
 #include <mir/graphics/display_configuration.h>
 #include <mir/input/touch_visualizer.h>
@@ -29,12 +28,13 @@
 #include "dbus_screen_observer.h"
 #include "powerd_mediator.h"
 #include "power_state_change_reason.h"
+#include "server.h"
 
 namespace mi = mir::input;
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
 
-ScreenStateHandler::ScreenStateHandler(std::shared_ptr<mir::DefaultServerConfiguration> const& config,
+ScreenStateHandler::ScreenStateHandler(std::shared_ptr<usc::Server> const& server,
                                        std::chrono::milliseconds poweroff_timeout,
                                        std::chrono::milliseconds dimmer_timeout)
     : current_power_mode{MirPowerMode::mir_power_mode_on},
@@ -42,10 +42,10 @@
       power_off_timeout{poweroff_timeout},
       dimming_timeout{dimmer_timeout},
       powerd_mediator{new PowerdMediator()},
-      config{config},
-      power_off_alarm{config->the_main_loop()->create_alarm(
+      server{server},
+      power_off_alarm{server->the_main_loop()->create_alarm(
               std::bind(&ScreenStateHandler::power_off_alarm_notification, this))},
-      dimmer_alarm{config->the_main_loop()->create_alarm(
+      dimmer_alarm{server->the_main_loop()->create_alarm(
               std::bind(&ScreenStateHandler::dimmer_alarm_notification, this))},
       dbus_screen{new DBusScreen(*this)}
 {
@@ -148,9 +148,9 @@
     if (current_power_mode == mode)
         return;
 
-    std::shared_ptr<mg::Display> display = config->the_display();
+    std::shared_ptr<mg::Display> display = server->the_display();
     std::shared_ptr<mg::DisplayConfiguration> displayConfig = display->configuration();
-    std::shared_ptr<mc::Compositor> compositor = config->the_compositor();
+    std::shared_ptr<mc::Compositor> compositor = server->the_compositor();
 
     displayConfig->for_each_output(
         [&](const mg::UserDisplayConfigurationOutput displayConfigOutput) {
@@ -229,7 +229,7 @@
 {
     std::lock_guard<std::mutex> lock{guard};
     
-    auto visualizer = config->the_touch_visualizer();
+    auto visualizer = server->the_touch_visualizer();
     if (enabled)
         visualizer->enable();
     else

=== modified file 'src/screen_state_handler.h'
--- src/screen_state_handler.h	2014-09-04 22:30:24 +0000
+++ src/screen_state_handler.h	2014-11-28 13:19:40 +0000
@@ -27,10 +27,10 @@
 class DBusScreen;
 class PowerdMediator;
 enum class PowerStateChangeReason;
+namespace usc { class Server; }
 
 namespace mir
 {
-class DefaultServerConfiguration;
 namespace time
 {
 class Alarm;
@@ -41,7 +41,7 @@
 class ScreenStateHandler: public mir::input::EventFilter, public DBusScreenObserver
 {
 public:
-    ScreenStateHandler(std::shared_ptr<mir::DefaultServerConfiguration> const& config,
+    ScreenStateHandler(std::shared_ptr<usc::Server> const& server,
                        std::chrono::milliseconds power_off_timeout,
                        std::chrono::milliseconds dimmer_timeout);
     virtual ~ScreenStateHandler();
@@ -81,7 +81,7 @@
     std::chrono::milliseconds dimming_timeout;
 
     std::unique_ptr<PowerdMediator> powerd_mediator;
-    std::shared_ptr<mir::DefaultServerConfiguration> config;
+    std::shared_ptr<usc::Server> server;
 
     std::unique_ptr<mir::time::Alarm> power_off_alarm;
     std::unique_ptr<mir::time::Alarm> dimmer_alarm;

=== renamed file 'src/server_configuration.cpp' => 'src/server.cpp'
--- src/server_configuration.cpp	2014-10-22 19:31:57 +0000
+++ src/server.cpp	2014-11-28 13:19:40 +0000
@@ -16,28 +16,24 @@
  * Authored by: Alexandros Frantzis <[e-mail]>
  */
 
-#include "server_configuration.h"
+#include "server.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>
 #include <iostream>
 
 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
 {
@@ -50,123 +46,109 @@
     std::cout << std::endl;
 }
 
-class ConfigurationOptions : public mo::DefaultConfiguration
-{
-public:
-    ConfigurationOptions(int argc, char const* argv[]) :
-        DefaultConfiguration(argc, argv, &ignore_unknown_arguments)
-    {
-        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
-    {
-        explicit 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()
+struct NullCursorListener : public mi::CursorListener
+{
+    void cursor_moved_to(float, float) override
+    {
+    }
+};
+
+struct ServerStatusListener : public mir::ServerStatusListener
+{
+    explicit 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;
+};
+}
+
+usc::Server::Server(int argc, char** argv)
+{
+    add_configuration_option("from-dm-fd", "File descriptor of read end of pipe from display manager [int]", mir::OptionType::integer);
+    add_configuration_option("to-dm-fd",   "File descriptor of write end of pipe to display manager [int]",  mir::OptionType::integer);
+    add_configuration_option("blacklist", "Video blacklist regex to use",  mir::OptionType::string);
+    add_configuration_option("version", "Show version of Unity System Compositor",  mir::OptionType::null);
+    add_configuration_option("spinner", "Path to spinner executable",  mir::OptionType::string);
+    add_configuration_option("public-socket", "Make the socket file publicly writable",  mir::OptionType::boolean);
+    add_configuration_option("enable-hardware-cursor", "Enable the hardware cursor (disabled by default)",  mir::OptionType::boolean);
+    add_configuration_option("inactivity-display-off-timeout", "The time in seconds before the screen is turned off when there are no active sessions",  mir::OptionType::integer);
+    add_configuration_option("inactivity-display-dim-timeout", "The time in seconds before the screen is dimmed when there are no active sessions",  mir::OptionType::integer);
+    add_configuration_option("shutdown-timeout", "The time in milli-seconds the power key must be held to initiate a clean system shutdown",  mir::OptionType::integer);
+    add_configuration_option("power-key-ignore-timeout", "The time in milli-seconds the power key must be held to ignore - must be less than shutdown-timeout",  mir::OptionType::integer);
+    add_configuration_option("disable-inactivity-policy", "Disables handling user inactivity and power key",  mir::OptionType::boolean);
+
+    set_command_line(argc, const_cast<char const **>(argv));
+
+    set_command_line_handler(&ignore_unknown_arguments);
+
+    wrap_cursor_listener([this](std::shared_ptr<mir::input::CursorListener> const& default_)
+        -> std::shared_ptr<mir::input::CursorListener>
+        {
+            // 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 default_;
+            else
+                return std::make_shared<NullCursorListener>();
+        });
+
+    override_the_server_status_listener([this]()
+        -> std::shared_ptr<mir::ServerStatusListener>
+        {
+            return std::make_shared<ServerStatusListener>(the_focus_controller());
+        });
+
+    wrap_session_coordinator([this](std::shared_ptr<ms::SessionCoordinator> const& wrapped)
+        -> std::shared_ptr<ms::SessionCoordinator>
+        {
+            return std::make_shared<SessionCoordinator>(
+                wrapped,
+                the_session_switcher());
+        });
+
+    wrap_surface_coordinator([this](std::shared_ptr<ms::SurfaceCoordinator> const& wrapped)
+        -> std::shared_ptr<mir::scene::SurfaceCoordinator>
+        {
+            return std::make_shared<SurfaceCoordinator>(
+                wrapped,
+                the_session_switcher());
+        });
+
+    set_config_filename("unity-system-compositor.conf");
+
+    apply_settings();
+}
+
+std::shared_ptr<usc::Spinner> usc::Server::the_spinner()
 {
     return spinner(
         [this]
@@ -177,7 +159,7 @@
         });
 }
 
-std::shared_ptr<usc::SessionSwitcher> usc::ServerConfiguration::the_session_switcher()
+std::shared_ptr<usc::SessionSwitcher> usc::Server::the_session_switcher()
 {
     return session_switcher(
         [this]
@@ -187,12 +169,12 @@
         });
 }
 
-std::shared_ptr<usc::DMMessageHandler> usc::ServerConfiguration::the_dm_message_handler()
+std::shared_ptr<usc::DMMessageHandler> usc::Server::the_dm_message_handler()
 {
     return the_session_switcher();
 }
 
-std::shared_ptr<usc::DMConnection> usc::ServerConfiguration::the_dm_connection()
+std::shared_ptr<usc::DMConnection> usc::Server::the_dm_connection()
 {
     return dm_connection(
         [this]

=== renamed file 'src/server_configuration.h' => 'src/server.h'
--- src/server_configuration.h	2014-10-22 19:31:57 +0000
+++ src/server.h	2014-11-28 13:19:40 +0000
@@ -16,10 +16,11 @@
  * Authored by: Alexandros Frantzis <[e-mail]>
  */
 
-#ifndef USC_SERVER_CONFIGURATION_H_
-#define USC_SERVER_CONFIGURATION_H_
+#ifndef USC_SERVER_H_
+#define USC_SERVER_H_
 
-#include <mir/default_server_configuration.h>
+#include <mir/server.h>
+#include <mir/cached_ptr.h>
 #include <mir/options/option.h>
 
 namespace usc
@@ -29,10 +30,18 @@
 class DMMessageHandler;
 class DMConnection;
 
-class ServerConfiguration : public mir::DefaultServerConfiguration
+class Server : private mir::Server
 {
 public:
-    explicit ServerConfiguration(int argc, char** argv);
+    explicit Server(int argc, char** argv);
+
+    using mir::Server::add_init_callback;
+    using mir::Server::run;
+    using mir::Server::the_main_loop;
+    using mir::Server::the_composite_event_filter;
+    using mir::Server::the_display;
+    using mir::Server::the_compositor;
+    using mir::Server::the_touch_visualizer;
 
     virtual std::shared_ptr<Spinner> the_spinner();
     virtual std::shared_ptr<DMMessageHandler> the_dm_message_handler();
@@ -100,14 +109,12 @@
         return the_options()->get("file", "/tmp/mir_socket");
     }
 
-protected:
+private:
+    inline auto the_options()
+    -> decltype(mir::Server::get_options())
+    { return mir::Server::get_options(); }
+
     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;

=== modified file 'src/system_compositor.cpp'
--- src/system_compositor.cpp	2014-10-22 18:23:08 +0000
+++ src/system_compositor.cpp	2014-11-28 13:19:40 +0000
@@ -19,7 +19,7 @@
 
 
 #include "system_compositor.h"
-#include "server_configuration.h"
+#include "server.h"
 #include "dm_connection.h"
 #include "spinner.h"
 #include "screen_state_handler.h"
@@ -86,16 +86,15 @@
 }
 
 usc::SystemCompositor::SystemCompositor(
-    std::shared_ptr<ServerConfiguration> const& config)
-    : config{config},
-      dm_connection{config->the_dm_connection()},
-      spinner{config->the_spinner()}
+    std::shared_ptr<Server> const& server)
+    : server{server},
+      spinner{server->the_spinner()}
 {
 }
 
 void usc::SystemCompositor::run()
 {
-    if (config->show_version())
+    if (server->show_version())
     {
         std::cerr << "unity-system-compositor " << USC_VERSION << std::endl;
         return;
@@ -115,7 +114,7 @@
         std::thread qt_thread;
     } guard;
 
-    mir::run_mir(*config, [&](mir::DisplayServer&)
+    server->add_init_callback([&]
         {
             auto vendor = (char *) glGetString(GL_VENDOR);
             auto renderer = (char *) glGetString (GL_RENDERER);
@@ -124,23 +123,23 @@
             std::cerr << "GL_RENDERER = " << renderer << std::endl;
             std::cerr << "GL_VERSION = " << version << std::endl;
 
-            if (!check_blacklist(config->blacklist(), vendor, renderer, version))
+            if (!check_blacklist(server->blacklist(), vendor, renderer, version))
                 throw mir::AbnormalExit ("Video driver is blacklisted, exiting");
 
-            main();
+            dm_connection = server->the_dm_connection();
+
+            // Make socket world-writable, since users need to talk to us.  No worries
+            // about race condition, since we are adding permissions, not restricting
+            // them.
+            if (server->public_socket() && chmod(server->get_socket_file().c_str(), 0777) == -1)
+                std::cerr << "Unable to chmod socket file " << server->get_socket_file() << ": " << strerror(errno) << std::endl;
+
+            dm_connection->start();
+
             guard.qt_thread = std::thread(&SystemCompositor::qt_main, this);
         });
-}
-
-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
-    // them.
-    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->start();
+
+    server->run();
 }
 
 void usc::SystemCompositor::qt_main()
@@ -148,23 +147,23 @@
     int argc{0};
     QCoreApplication app(argc, nullptr);
 
-    if (!config->disable_inactivity_policy())
+    if (!server->disable_inactivity_policy())
     {
-        std::chrono::seconds inactivity_display_off_timeout{config->inactivity_display_off_timeout()};
-        std::chrono::seconds inactivity_display_dim_timeout{config->inactivity_display_dim_timeout()};
-        std::chrono::milliseconds power_key_ignore_timeout{config->power_key_ignore_timeout()};
-        std::chrono::milliseconds shutdown_timeout{config->shutdown_timeout()};
+        std::chrono::seconds inactivity_display_off_timeout{server->inactivity_display_off_timeout()};
+        std::chrono::seconds inactivity_display_dim_timeout{server->inactivity_display_dim_timeout()};
+        std::chrono::milliseconds power_key_ignore_timeout{server->power_key_ignore_timeout()};
+        std::chrono::milliseconds shutdown_timeout{server->shutdown_timeout()};
 
-        screen_state_handler = std::make_shared<ScreenStateHandler>(config,
+        screen_state_handler = std::make_shared<ScreenStateHandler>(server,
             std::chrono::duration_cast<std::chrono::milliseconds>(inactivity_display_off_timeout),
             std::chrono::duration_cast<std::chrono::milliseconds>(inactivity_display_dim_timeout));
 
-        power_key_handler = std::make_shared<PowerKeyHandler>(*(config->the_main_loop()),
+        power_key_handler = std::make_shared<PowerKeyHandler>(*(server->the_main_loop()),
             power_key_ignore_timeout,
             shutdown_timeout,
             *screen_state_handler);
 
-        auto composite_filter = config->the_composite_event_filter();
+        auto composite_filter = server->the_composite_event_filter();
         composite_filter->append(screen_state_handler);
         composite_filter->append(power_key_handler);
     }

=== modified file 'src/system_compositor.h'
--- src/system_compositor.h	2014-10-22 19:31:57 +0000
+++ src/system_compositor.h	2014-11-28 13:19:40 +0000
@@ -28,22 +28,21 @@
 namespace usc
 {
 
-class ServerConfiguration;
+class Server;
 class DMConnection;
 class Spinner;
 
 class SystemCompositor
 {
 public:
-    explicit SystemCompositor(std::shared_ptr<ServerConfiguration> const& config);
+    explicit SystemCompositor(std::shared_ptr<Server> const& server);
     void run();
 
 private:
-    void main();
     void qt_main();
 
-    std::shared_ptr<ServerConfiguration> const config;
-    std::shared_ptr<DMConnection> const dm_connection;
+    std::shared_ptr<Server> const server;
+    std::shared_ptr<DMConnection> dm_connection;
     std::shared_ptr<Spinner> const spinner;
     std::shared_ptr<ScreenStateHandler> screen_state_handler;
     std::shared_ptr<PowerKeyHandler> power_key_handler;