Merge lp:unity-system-compositor into lp:unity-system-compositor/ubuntu

[Alan Griffiths]

Release in step with Mir 0.13.0

Release in step with Mir 0.13.0

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:211
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-ci/1/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-vivid-amd64-ci/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-vivid-armhf-ci/1/console

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

review: Needs Fixing (continuous-integration)

[Alan Griffiths (alan-griffiths)]

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

Yes. manta, mako

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

Yes

  o Did you break mir client API or ABI and have you followed up with the known clients & announced on mir-devel mailing list ?

No

[Alexandros Frantzis (afrantzis)]

OK.

review: Approve

[Cemil Azizoglu (cemil-azizoglu)]

43 - libmirclient-dev (>= 0.6.0),
44 - libmirserver-dev (>= 0.11.0),
45 + libmirclient-dev (>= 0.13.0~),
46 + libmirserver-dev (>= 0.13.0~),

Are we actually using API from client and server 0.13.0 packages. What's the '~' for?

review: Needs Information

[Alan Griffiths (alan-griffiths)]

> 43 - libmirclient-dev (>= 0.6.0),
> 44 - libmirserver-dev (>= 0.11.0),
> 45 + libmirclient-dev (>= 0.13.0~),
> 46 + libmirserver-dev (>= 0.13.0~),
>
> Are we actually using API from client and server 0.13.0 packages.

Yes. (we're using the "new" event functions in client API and lots of server stuff).

> What's the '~' for?

It's "magic" to me, but has been needed in the past.

[lp:unity-system-compositor]

212. By Alan Griffiths on 2015-05-06

Lose the magic '~'

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:212
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-ci/2/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-vivid-amd64-ci/2/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-vivid-armhf-ci/2/console

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

review: Needs Fixing (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-11-28 11:39:04 +0000
+++ CMakeLists.txt	2015-05-06 16:09:34 +0000
@@ -44,11 +44,10 @@
 pkg_check_modules(GLIB REQUIRED glib-2.0)
 pkg_check_modules(MIRCLIENT REQUIRED mirclient)
 pkg_check_modules(MIRSERVER REQUIRED mirserver)
+pkg_check_modules(DBUS REQUIRED dbus-1)
 
-find_package(Boost 1.48.0 COMPONENTS chrono date_time filesystem system thread program_options regex REQUIRED)
+find_package(Boost 1.48.0 COMPONENTS system REQUIRED)
 find_package(GLESv2 REQUIRED)
-find_package(Qt5Core)
-find_package(Qt5DBus)
 
 add_subdirectory(spinner/)
 add_subdirectory(src/)

=== modified file 'debian/control'
--- debian/control	2015-01-27 17:47:31 +0000
+++ debian/control	2015-05-06 16:09:34 +0000
@@ -4,29 +4,23 @@
 Maintainer: Ubuntu Developers <[e-mail]>
 Build-Depends: cmake,
                cmake-data,
+               dbus,
                debhelper (>= 9),
                g++-4.9,
                google-mock,
                libandroid-properties-dev [i386 amd64 armhf],
-               libboost-chrono-dev,
-               libboost-date-time-dev,
-               libboost-filesystem-dev,
-               libboost-program-options-dev,
-               libboost-regex-dev,
+               libboost-dev,
                libboost-system-dev,
-               libboost-thread-dev,
                libcairo2-dev,
+               libdbus-1-dev,
                libglib2.0-dev,
                libgles2-mesa-dev,
-               libmirclient-dev (>= 0.6.0),
-               libmirserver-dev (>= 0.11.0),
+               libmirclient-dev (>= 0.13.0),
+               libmirserver-dev (>= 0.13.0),
                libprotobuf-dev,
                pkg-config,
                python:any (>= 2.7),
                python-setuptools,
-               qt5-default,
-               qtbase5-dev,
-               qtbase5-dev-tools,
 Standards-Version: 3.9.4
 Homepage: https://launchpad.net/unity-system-compositor
 # if you don't have have commit access to this branch but would like to upload

=== modified file 'spinner/eglapp.c'
--- spinner/eglapp.c	2014-03-28 13:02:02 +0000
+++ spinner/eglapp.c	2015-05-06 16:09:34 +0000
@@ -92,8 +92,9 @@
 {
     (void) surface;
     (void) context;
-    if (ev->type == mir_event_type_resize)
+    if (mir_event_get_type(ev) == mir_event_type_resize)
     {
+        MirResizeEvent const* resize = mir_event_get_resize_event(ev);
         /*
          * FIXME: https://bugs.launchpad.net/mir/+bug/1194384
          * It is unsafe to set the width and height here because we're in a
@@ -101,7 +102,9 @@
          * support for event queuing (directing them to another thread) or
          * full single-threaded callbacks. (LP: #1194384).
          */
-        printf("Resized to %dx%d\n", ev->resize.width, ev->resize.height);
+        printf("Resized to %dx%d\n",
+               mir_resize_event_get_width(resize),
+               mir_resize_event_get_height(resize));
     }
 }
 
@@ -144,11 +147,6 @@
         mir_buffer_usage_hardware,
         mir_display_output_id_invalid
     };
-    MirEventDelegate delegate = 
-    {
-        mir_eglapp_handle_event,
-        NULL
-    };
     EGLConfig eglconfig;
     EGLint neglconfigs;
     EGLContext eglctx;
@@ -323,7 +321,7 @@
     surface = mir_connection_create_surface_sync(connection, &surfaceparm);
     CHECK(mir_surface_is_valid(surface), "Can't create a surface");
 
-    mir_surface_set_event_handler(surface, &delegate);
+    mir_surface_set_event_handler(surface, mir_eglapp_handle_event, NULL);
 
     egldisplay = eglGetDisplay(
                     (EGLNativeDisplayType) mir_connection_get_egl_native_display(connection));
@@ -337,8 +335,7 @@
     CHECK(neglconfigs > 0, "No EGL config available");
 
     eglsurface = eglCreateWindowSurface(egldisplay, eglconfig,
-            (EGLNativeWindowType)mir_surface_get_egl_native_window(surface),
-            NULL);
+        (EGLNativeWindowType)mir_buffer_stream_get_egl_native_window(mir_surface_get_buffer_stream(surface)), NULL);
     CHECK(eglsurface != EGL_NO_SURFACE, "eglCreateWindowSurface failed");
 
     eglctx = eglCreateContext(egldisplay, eglconfig, EGL_NO_CONTEXT,

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-01-27 17:43:17 +0000
+++ src/CMakeLists.txt	2015-05-06 16:09:34 +0000
@@ -16,23 +16,30 @@
 
 set(USC_SRCS
   asio_dm_connection.cpp
-  dbus_screen.cpp
+  dbus_connection_handle.cpp
+  dbus_event_loop.cpp
+  dbus_message_handle.cpp
   external_spinner.cpp
+  mir_screen.cpp
   powerd_mediator.cpp
-  powerkey_handler.cpp
-  screen_state_handler.cpp
+  screen_event_handler.cpp
   server.cpp
-  shell.cpp
   session_switcher.cpp
   system_compositor.cpp
-  worker_thread.cpp
+  thread_name.cpp
+  unity_screen_service.cpp
+  unity_screen_service_introspection.h
+  window_manager.cpp
 )
 
-qt5_generate_dbus_interface(dbus_screen.h com.canonical.Unity.Screen.xml)
-qt5_add_dbus_adaptor(USC_SRCS
-                     ${CMAKE_CURRENT_BINARY_DIR}/com.canonical.Unity.Screen.xml
-                     dbus_screen.h DBusScreen
-                     dbus_screen_adaptor DBusScreenAdaptor)
+# Generate unity_screen_service_introspection.h from the introspection XML file
+add_custom_command(
+  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/unity_screen_service_introspection.h
+  COMMAND sh generate_header_with_string_from_file.sh ${CMAKE_CURRENT_BINARY_DIR}/unity_screen_service_introspection.h unity_screen_service_introspection com.canonical.Unity.Screen.xml
+  DEPENDS com.canonical.Unity.Screen.xml generate_header_with_string_from_file.sh
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+  VERBATIM
+)
 
 # Compile system compositor
 add_library(
@@ -51,13 +58,12 @@
   ${Boost_INCLUDE_DIRS}
   ${GLESv2_INCLUDE_DIRS}
   ${MIRSERVER_INCLUDE_DIRS}
+  ${DBUS_INCLUDE_DIRS}
 )
 add_definitions(
   -DDEFAULT_SPINNER="${CMAKE_INSTALL_FULL_BINDIR}/unity-system-compositor-spinner"
 )
 
-qt5_use_modules(usc Core DBus)
-
 link_directories(${MIRSERVER_LIBRARY_DIRS})
 
 target_link_libraries(usc
@@ -65,6 +71,7 @@
   pthread
   ${Boost_LIBRARIES}
   ${GLESv2_LIBRARIES}
+  ${DBUS_LIBRARIES}
 )
 
 target_link_libraries(unity-system-compositor
@@ -80,6 +87,6 @@
 install(FILES com.canonical.Unity.Screen.conf
   DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/dbus-1/system.d
 )
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/com.canonical.Unity.Screen.xml
+install(FILES com.canonical.Unity.Screen.xml
   DESTINATION ${CMAKE_INSTALL_DATADIR}/dbus-1/interfaces
 )

=== added file 'src/com.canonical.Unity.Screen.xml'
--- src/com.canonical.Unity.Screen.xml	1970-01-01 00:00:00 +0000
+++ src/com.canonical.Unity.Screen.xml	2015-05-06 16:09:34 +0000
@@ -0,0 +1,29 @@
+<!DOCTYPE node PUBLIC '-//freedesktop//DTD D-BUS Object Introspection 1.0//EN' 'http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd'>
+<node>
+  <interface name='com.canonical.Unity.Screen'>
+    <method name='setScreenPowerMode'>
+      <arg type='b' direction='out'/>
+      <arg name='mode' type='s' direction='in'/>
+      <arg name='reason' type='i' direction='in'/>
+    </method>
+    <method name='keepDisplayOn'>
+      <arg type='i' direction='out'/>
+    </method>
+    <method name='removeDisplayOnRequest'>
+      <arg name='id' type='i' direction='in'/>
+    </method>
+    <method name='setUserBrightness'>
+      <arg name='brightness' type='i' direction='in'/>
+    </method>
+    <method name='userAutobrightnessEnable'>
+      <arg name='enable' type='b' direction='in'/>
+    </method>
+    <method name='setInactivityTimeouts'>
+      <arg name='poweroff_timeout' type='i' direction='in'/>
+      <arg name='dimmer_timeout' type='i' direction='in'/>
+    </method>
+    <method name='setTouchVisualizationEnabled'>
+      <arg name='enabled' type='b' direction='in'/>
+    </method>
+  </interface>
+</node>

=== added file 'src/dbus_connection_handle.cpp'
--- src/dbus_connection_handle.cpp	1970-01-01 00:00:00 +0000
+++ src/dbus_connection_handle.cpp	2015-05-06 16:09:34 +0000
@@ -0,0 +1,102 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "dbus_connection_handle.h"
+#include "scoped_dbus_error.h"
+
+#include <stdexcept>
+#include <boost/throw_exception.hpp>
+
+usc::DBusConnectionHandle::DBusConnectionHandle(const char* address)
+{
+    dbus_threads_init_default();
+    ScopedDBusError error;
+
+    connection = dbus_connection_open_private(address, &error);
+    if (!connection || error)
+    {
+        BOOST_THROW_EXCEPTION(
+            std::runtime_error("dbus_connection_open: " + error.message_str()));
+    }
+
+    if (!dbus_bus_register(connection, &error))
+    {
+        BOOST_THROW_EXCEPTION(
+            std::runtime_error("dbus_bus_register: " + error.message_str()));
+    }
+}
+
+usc::DBusConnectionHandle::~DBusConnectionHandle()
+{
+    if (dbus_connection_get_is_connected(connection))
+        dbus_connection_close(connection);
+    dbus_connection_unref(connection);
+}
+
+void usc::DBusConnectionHandle::request_name(char const* name) const
+{
+    ScopedDBusError error;
+
+    auto const request_result = dbus_bus_request_name(
+        connection, name, DBUS_NAME_FLAG_DO_NOT_QUEUE, &error);
+    if (error)
+    {
+        BOOST_THROW_EXCEPTION(
+            std::runtime_error("dbus_request_name: " + error.message_str()));
+    }
+
+    if (request_result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
+    {
+        BOOST_THROW_EXCEPTION(
+            std::runtime_error("dbus_request_name: Failed to become primary owner"));
+    }
+}
+
+void usc::DBusConnectionHandle::add_match(char const* match) const
+{
+    ScopedDBusError error;
+
+    dbus_bus_add_match(connection, match, &error);
+    if (error)
+    {
+        BOOST_THROW_EXCEPTION(
+            std::runtime_error("dbus_add_match: " + error.message_str()));
+    }
+}
+
+void usc::DBusConnectionHandle::add_filter(
+    DBusHandleMessageFunction filter_func,
+    void* user_data) const
+{
+    auto const added = dbus_connection_add_filter(
+        connection,
+        filter_func,
+        user_data,
+        nullptr);
+
+    if (!added)
+    {
+        BOOST_THROW_EXCEPTION(
+            std::runtime_error("dbus_connection_add_filter: Failed to add filter"));
+    }
+}
+
+usc::DBusConnectionHandle::operator ::DBusConnection*() const
+{
+    return connection;
+}

=== added file 'src/dbus_connection_handle.h'
--- src/dbus_connection_handle.h	1970-01-01 00:00:00 +0000
+++ src/dbus_connection_handle.h	2015-05-06 16:09:34 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef USC_DBUS_CONNECTION_HANDLE_H_
+#define USC_DBUS_CONNECTION_HANDLE_H_
+
+#include <dbus/dbus.h>
+
+namespace usc
+{
+
+class DBusConnectionHandle
+{
+public:
+    DBusConnectionHandle(char const* address);
+    ~DBusConnectionHandle();
+
+    void request_name(char const* name) const;
+    void add_match(char const* match) const;
+    void add_filter(DBusHandleMessageFunction filter_func, void* user_data) const;
+
+    operator ::DBusConnection*() const;
+
+private:
+    DBusConnectionHandle(DBusConnectionHandle const&) = delete;
+    DBusConnectionHandle& operator=(DBusConnectionHandle const&) = delete;
+
+    ::DBusConnection* connection;
+};
+
+}
+
+#endif

=== added file 'src/dbus_event_loop.cpp'
--- src/dbus_event_loop.cpp	1970-01-01 00:00:00 +0000
+++ src/dbus_event_loop.cpp	2015-05-06 16:09:34 +0000
@@ -0,0 +1,444 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include "dbus_event_loop.h"
+
+#include <algorithm>
+
+#include <sys/epoll.h>
+#include <sys/timerfd.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <system_error>
+#include <boost/throw_exception.hpp>
+
+namespace
+{
+
+uint32_t dbus_flags_to_epoll_events(DBusWatch* bus_watch)
+{
+    unsigned int flags;
+    uint32_t events{0};
+
+    if (!dbus_watch_get_enabled(bus_watch))
+        return 0;
+
+    flags = dbus_watch_get_flags(bus_watch);
+    if (flags & DBUS_WATCH_READABLE)
+        events |= EPOLLIN;
+    if (flags & DBUS_WATCH_WRITABLE)
+        events |= EPOLLOUT;
+
+    return events | EPOLLHUP | EPOLLERR;
+}
+
+unsigned int epoll_events_to_dbus_flags(uint32_t events)
+{
+    unsigned int flags{0};
+
+    if (events & EPOLLIN)
+        flags |= DBUS_WATCH_READABLE;
+    if (events & EPOLLOUT)
+        flags |= DBUS_WATCH_WRITABLE;
+    if (events & EPOLLHUP)
+        flags |= DBUS_WATCH_HANGUP;
+    if (events & EPOLLERR)
+        flags |= DBUS_WATCH_ERROR;
+
+    return flags;
+}
+
+timespec msec_to_timespec(int msec)
+{
+    static long const milli_to_nano = 1000000;
+    time_t const sec = msec / 1000;
+    long const nsec = (msec % 1000) * milli_to_nano;
+    return timespec{sec, nsec};
+}
+
+}
+
+usc::DBusEventLoop::DBusEventLoop(DBusConnection* connection)
+    : connection{connection},
+      running{false},
+      epoll_fd{epoll_create1(EPOLL_CLOEXEC)}
+{
+    if (epoll_fd == -1)
+    {
+        BOOST_THROW_EXCEPTION(
+            std::system_error(errno, std::system_category(), "epoll_create1"));
+    }
+
+    int pipefd[2]{};
+
+    if (pipe2(pipefd, O_CLOEXEC) == -1)
+    {
+        BOOST_THROW_EXCEPTION(
+            std::system_error(errno, std::system_category(), "pipe2"));
+
+    }
+
+    wake_up_fd_r = mir::Fd{pipefd[0]};
+    wake_up_fd_w = mir::Fd{pipefd[1]};
+
+    epoll_event ev{};
+    ev.data.fd = wake_up_fd_r;
+    ev.events = EPOLLIN;
+    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, ev.data.fd, &ev) == -1)
+    {
+        BOOST_THROW_EXCEPTION(
+            std::system_error(errno, std::system_category(), "epoll_ctl"));
+    }
+
+    dbus_connection_set_watch_functions(
+        connection,
+        DBusEventLoop::static_add_watch,
+        DBusEventLoop::static_remove_watch,
+        DBusEventLoop::static_toggle_watch,
+        this,
+        nullptr);
+
+    dbus_connection_set_timeout_functions(
+        connection,
+        DBusEventLoop::static_add_timeout,
+        DBusEventLoop::static_remove_timeout,
+        DBusEventLoop::static_toggle_timeout,
+        this,
+        nullptr);
+
+    dbus_connection_set_wakeup_main_function(
+        connection,
+        DBusEventLoop::static_wake_up_loop,
+        this, nullptr);
+}
+
+usc::DBusEventLoop::~DBusEventLoop()
+{
+    stop();
+
+    dbus_connection_set_watch_functions(
+        connection, nullptr, nullptr, nullptr, nullptr, nullptr);
+
+    dbus_connection_set_timeout_functions(
+        connection, nullptr, nullptr, nullptr, nullptr, nullptr);
+
+    dbus_connection_set_wakeup_main_function(
+        connection, nullptr, nullptr, nullptr);
+}
+
+void usc::DBusEventLoop::run(std::promise<void>& started)
+{
+    running = true;
+    started.set_value();
+
+    while (running)
+    {
+        epoll_event event{};
+        int n = epoll_wait(epoll_fd, &event, 1, -1);
+        if (n == -1)
+        {
+            if (errno == EINTR)
+                continue;
+
+            BOOST_THROW_EXCEPTION(
+                std::system_error(errno, std::system_category(), "epoll_wait"));
+        }
+
+        if (event.data.fd == wake_up_fd_r)
+        {
+            char c;
+            if (read(event.data.fd, &c, 1));
+        }
+        else
+        {
+            auto const& matching_watches = enabled_watches_for(event.data.fd);
+            for (auto const& watch : matching_watches)
+            {
+                dbus_watch_handle(watch, epoll_events_to_dbus_flags(event.events));
+            }
+
+            if (matching_watches.empty())
+            {
+                auto timeout = enabled_timeout_for(event.data.fd);
+                if (timeout)
+                    dbus_timeout_handle(timeout);
+            }
+        }
+
+        dispatch_actions();
+
+        dbus_connection_flush(connection);
+
+        while (dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS)
+            continue;
+    }
+
+    // Flush any remaining outgoing messages
+    dbus_connection_flush(connection);
+}
+
+void usc::DBusEventLoop::stop()
+{
+    running = false;
+    wake_up_loop();
+}
+
+std::vector<DBusWatch*> usc::DBusEventLoop::enabled_watches_for(int fd)
+{
+    std::lock_guard<std::mutex> lock{mutex};
+
+    std::vector<DBusWatch*> ret_watches;
+
+    for (auto const& w : watches)
+    {
+        if (dbus_watch_get_unix_fd(w) == fd &&
+            dbus_watch_get_enabled(w))
+        {
+            ret_watches.push_back(w);
+        }
+    }
+
+    return ret_watches;
+}
+
+DBusTimeout* usc::DBusEventLoop::enabled_timeout_for(int fd)
+{
+    std::lock_guard<std::mutex> lock{mutex};
+
+    for (auto const& p : timeouts)
+    {
+        if (p.second == fd && dbus_timeout_get_enabled(p.first))
+            return p.first;
+    }
+
+    return nullptr;
+}
+
+dbus_bool_t usc::DBusEventLoop::add_watch(DBusWatch* watch)
+{
+    std::lock_guard<std::mutex> lock{mutex};
+
+    int const watch_fd = dbus_watch_get_unix_fd(watch);
+
+    if (!is_watched(watch_fd))
+    {
+        epoll_event ev{};
+        ev.data.fd = watch_fd;
+        if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, watch_fd, &ev) == -1)
+            return FALSE;
+    }
+
+    watches.push_back(watch);
+
+    update_events_for_watch_fd(watch_fd);
+
+    return TRUE;
+}
+
+void usc::DBusEventLoop::remove_watch(DBusWatch* watch)
+{
+    std::lock_guard<std::mutex> lock{mutex};
+
+    watches.erase(std::remove(begin(watches), end(watches), watch), end(watches));
+
+    int const watch_fd = dbus_watch_get_unix_fd(watch);
+    if (!is_watched(watch_fd))
+        epoll_ctl(epoll_fd, EPOLL_CTL_DEL, watch_fd, nullptr);
+    else
+        update_events_for_watch_fd(watch_fd);
+}
+
+void usc::DBusEventLoop::toggle_watch(DBusWatch* watch)
+{
+    std::lock_guard<std::mutex> lock{mutex};
+
+    int const watch_fd = dbus_watch_get_unix_fd(watch);
+    update_events_for_watch_fd(watch_fd);
+}
+
+void usc::DBusEventLoop::update_events_for_watch_fd(int watch_fd)
+{
+    epoll_event ev{};
+    ev.events = epoll_events_for_watch_fd(watch_fd);
+    ev.data.fd = watch_fd;
+    epoll_ctl(epoll_fd, EPOLL_CTL_MOD, watch_fd, &ev);
+}
+
+bool usc::DBusEventLoop::is_watched(int watch_fd)
+{
+    auto const iter = std::find_if(
+        begin(watches), end(watches),
+        [watch_fd] (DBusWatch* w) { return dbus_watch_get_unix_fd(w) == watch_fd; });
+
+    return iter != end(watches);
+}
+
+uint32_t usc::DBusEventLoop::epoll_events_for_watch_fd(int fd)
+{
+    uint32_t events{};
+
+    for (auto const& watch : watches)
+    {
+        if (dbus_watch_get_unix_fd(watch) == fd)
+            events |= dbus_flags_to_epoll_events(watch);
+    }
+
+    return events;
+}
+
+dbus_bool_t usc::DBusEventLoop::add_timeout(DBusTimeout* timeout)
+{
+    std::lock_guard<std::mutex> lock{mutex};
+
+    auto tfd = mir::Fd{timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)};
+
+    epoll_event ev{};
+    ev.events = EPOLLIN;
+    ev.data.fd = tfd;
+
+    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, tfd, &ev))
+        return FALSE;
+
+    timeouts.emplace_back(timeout, std::move(tfd));
+
+    return update_timer_fd_for(timeout);
+}
+
+void usc::DBusEventLoop::remove_timeout(DBusTimeout* timeout)
+{
+    std::lock_guard<std::mutex> lock{mutex};
+
+    auto tfd = timer_fd_for(timeout);
+    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, tfd, nullptr);
+
+    timeouts.erase(
+        std::remove_if(begin(timeouts), end(timeouts),
+            [timeout] (decltype(timeouts)::const_reference p)
+            {
+                return p.first == timeout;
+            }),
+        end(timeouts));
+
+}
+
+void usc::DBusEventLoop::toggle_timeout(DBusTimeout* timeout)
+{
+    std::lock_guard<std::mutex> lock{mutex};
+    update_timer_fd_for(timeout);
+}
+
+
+dbus_bool_t usc::DBusEventLoop::update_timer_fd_for(DBusTimeout* timeout)
+{
+    itimerspec spec{};
+
+    auto tfd = timer_fd_for(timeout);
+
+    if (dbus_timeout_get_enabled(timeout))
+    {
+        spec.it_interval = msec_to_timespec(dbus_timeout_get_interval(timeout));
+        spec.it_value = spec.it_interval;
+    }
+
+    if (timerfd_settime(tfd, 0, &spec, nullptr) == -1)
+        return FALSE;
+
+    return TRUE;
+}
+
+int usc::DBusEventLoop::timer_fd_for(DBusTimeout* timeout)
+{
+    auto iter = std::find_if(begin(timeouts), end(timeouts),
+        [timeout] (std::pair<DBusTimeout*,int> const& p)
+        {
+            return p.first == timeout;
+        });
+    return (iter == end(timeouts) ? -1 : iter->second);
+}
+
+void usc::DBusEventLoop::wake_up_loop()
+{
+    if (write(wake_up_fd_w, "a", 1) != 1)
+    {
+        BOOST_THROW_EXCEPTION(
+            std::system_error(errno, std::system_category(), "write"));
+    }
+}
+
+void usc::DBusEventLoop::enqueue(std::function<void()> const& action)
+{
+    {
+        std::lock_guard<std::mutex> lock{mutex};
+        actions.push_back(action);
+    }
+
+    wake_up_loop();
+}
+
+void usc::DBusEventLoop::dispatch_actions()
+{
+    decltype(actions) actions_to_dispatch;
+
+    {
+        std::lock_guard<std::mutex> lock{mutex};
+        actions.swap(actions_to_dispatch);
+    }
+
+    for (auto const& action : actions_to_dispatch)
+        action();
+}
+
+dbus_bool_t usc::DBusEventLoop::static_add_watch(DBusWatch* watch, void* data)
+{
+    return static_cast<DBusEventLoop*>(data)->add_watch(watch);
+}
+
+void usc::DBusEventLoop::static_remove_watch(DBusWatch* watch, void* data)
+{
+    static_cast<DBusEventLoop*>(data)->remove_watch(watch);
+}
+
+void usc::DBusEventLoop::static_toggle_watch(DBusWatch* watch, void* data)
+{
+    static_cast<DBusEventLoop*>(data)->toggle_watch(watch);
+}
+
+dbus_bool_t usc::DBusEventLoop::static_add_timeout(DBusTimeout* timeout, void* data)
+{
+    return static_cast<DBusEventLoop*>(data)->add_timeout(timeout);
+}
+
+void usc::DBusEventLoop::static_remove_timeout(DBusTimeout* timeout, void* data)
+{
+    static_cast<DBusEventLoop*>(data)->remove_timeout(timeout);
+}
+
+void usc::DBusEventLoop::static_toggle_timeout(DBusTimeout* timeout, void* data)
+{
+    static_cast<DBusEventLoop*>(data)->toggle_timeout(timeout);
+}
+
+void usc::DBusEventLoop::static_wake_up_loop(void* data)
+{
+    static_cast<DBusEventLoop*>(data)->wake_up_loop();
+}

=== added file 'src/dbus_event_loop.h'
--- src/dbus_event_loop.h	1970-01-01 00:00:00 +0000
+++ src/dbus_event_loop.h	2015-05-06 16:09:34 +0000
@@ -0,0 +1,87 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef USC_DBUS_EVENT_LOOP_H_
+#define USC_DBUS_EVENT_LOOP_H_
+
+#include <mir/fd.h>
+
+#include <dbus/dbus.h>
+
+#include <atomic>
+#include <vector>
+#include <mutex>
+#include <future>
+
+namespace usc
+{
+
+class DBusEventLoop
+{
+public:
+    DBusEventLoop(DBusConnection* connection);
+    ~DBusEventLoop();
+
+    void run(std::promise<void>& started);
+    void stop();
+
+    void enqueue(std::function<void()> const& action);
+
+private:
+    std::vector<DBusWatch*> enabled_watches_for(int fd);
+    DBusTimeout* enabled_timeout_for(int fd);
+
+    dbus_bool_t add_watch(DBusWatch* watch);
+    void remove_watch(DBusWatch* watch);
+    void toggle_watch(DBusWatch* watch);
+    void update_events_for_watch_fd(int watch_fd);
+    bool is_watched(int watch_fd);
+    uint32_t epoll_events_for_watch_fd(int watch_fd);
+
+    dbus_bool_t add_timeout(DBusTimeout* timeout);
+    void remove_timeout(DBusTimeout* timeout);
+    void toggle_timeout(DBusTimeout* timeout);
+    dbus_bool_t update_timer_fd_for(DBusTimeout* timeout);
+    int timer_fd_for(DBusTimeout* timeout);
+
+    void wake_up_loop();
+    void dispatch_actions();
+
+    static dbus_bool_t static_add_watch(DBusWatch* watch, void* data);
+    static void static_remove_watch(DBusWatch* watch, void* data);
+    static void static_toggle_watch(DBusWatch* watch, void* data);
+    static dbus_bool_t static_add_timeout(DBusTimeout* timeout, void* data);
+    static void static_remove_timeout(DBusTimeout* timeout, void* data);
+    static void static_toggle_timeout(DBusTimeout* timeout, void* data);
+    static void static_wake_up_loop(void* data);
+
+    DBusConnection* const connection;
+    std::atomic<bool> running;
+
+    std::mutex mutex;
+    std::vector<DBusWatch*> watches;
+    std::vector<std::pair<DBusTimeout*,mir::Fd>> timeouts;
+    std::vector<std::function<void(void)>> actions;
+    mir::Fd epoll_fd;
+    mir::Fd wake_up_fd_r;
+    mir::Fd wake_up_fd_w;
+};
+
+}
+
+#endif

=== added file 'src/dbus_message_handle.cpp'
--- src/dbus_message_handle.cpp	1970-01-01 00:00:00 +0000
+++ src/dbus_message_handle.cpp	2015-05-06 16:09:34 +0000
@@ -0,0 +1,83 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "dbus_message_handle.h"
+
+#include <stdexcept>
+#include <boost/throw_exception.hpp>
+
+usc::DBusMessageHandle::DBusMessageHandle(DBusMessage* message)
+    : message{message}
+{
+}
+
+usc::DBusMessageHandle::DBusMessageHandle(::DBusMessage* message, int first_arg_type, ...)
+    : message{message}
+{
+    if (!message)
+        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid dbus message"));
+
+    va_list args;
+    va_start(args, first_arg_type);
+    auto appended = dbus_message_append_args_valist(message, first_arg_type, args);
+    va_end(args);
+
+    if (!appended)
+    {
+        dbus_message_unref(message);
+        BOOST_THROW_EXCEPTION(
+            std::runtime_error("dbus_message_append_args_valist: Failed to append args"));
+    }
+}
+
+usc::DBusMessageHandle::DBusMessageHandle(
+    ::DBusMessage* message, int first_arg_type, va_list args)
+    : message{message}
+{
+    if (!message)
+        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid dbus message"));
+
+    if (!dbus_message_append_args_valist(message, first_arg_type, args))
+    {
+        dbus_message_unref(message);
+        BOOST_THROW_EXCEPTION(
+            std::runtime_error("dbus_message_append_args_valist: Failed to append args"));
+    }
+}
+
+usc::DBusMessageHandle::DBusMessageHandle(DBusMessageHandle&& other) noexcept
+    : message{other.message}
+{
+    other.message = nullptr;
+}
+
+usc::DBusMessageHandle::~DBusMessageHandle()
+{
+    if (message)
+        dbus_message_unref(message);
+}
+
+usc::DBusMessageHandle::operator ::DBusMessage*() const
+{
+    return message;
+}
+
+usc::DBusMessageHandle::operator bool() const
+{
+    return message != nullptr;
+}

=== added file 'src/dbus_message_handle.h'
--- src/dbus_message_handle.h	1970-01-01 00:00:00 +0000
+++ src/dbus_message_handle.h	2015-05-06 16:09:34 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef USC_DBUS_MESSAGE_HANDLE_H_
+#define USC_DBUS_MESSAGE_HANDLE_H_
+
+#include <dbus/dbus.h>
+#include <cstdarg>
+
+namespace usc
+{
+
+class DBusMessageHandle
+{
+public:
+    DBusMessageHandle(DBusMessage* message);
+    DBusMessageHandle(DBusMessage* message, int first_arg_type, ...);
+    DBusMessageHandle(DBusMessage* message, int first_arg_type, va_list args);
+    DBusMessageHandle(DBusMessageHandle&&) noexcept;
+    ~DBusMessageHandle();
+
+    operator ::DBusMessage*() const;
+    operator bool() const;
+
+private:
+    DBusMessageHandle(DBusMessageHandle const&) = delete;
+    DBusMessageHandle& operator=(DBusMessageHandle const&) = delete;
+    ::DBusMessage* message;
+};
+
+}
+
+#endif

=== removed file 'src/dbus_screen.cpp'
--- src/dbus_screen.cpp	2014-10-10 22:43:34 +0000
+++ src/dbus_screen.cpp	1970-01-01 00:00:00 +0000
@@ -1,213 +0,0 @@
-/*
- * 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/>.
- */
-
-#include "dbus_screen.h"
-#include "dbus_screen_adaptor.h"
-#include "dbus_screen_observer.h"
-#include "power_state_change_reason.h"
-#include "worker_thread.h"
-
-#include <atomic>
-#include <memory>
-#include <thread>
-#include <iostream>
-
-#include <QDBusMessage>
-#include <QDBusConnection>
-#include <QDBusServiceWatcher>
-#include <QDebug>
-
-namespace
-{
-bool is_valid_reason(int raw_reason)
-{
-    auto reason = static_cast<PowerStateChangeReason>(raw_reason);
-    switch (reason)
-    {
-    case PowerStateChangeReason::unknown:
-    case PowerStateChangeReason::inactivity:
-    case PowerStateChangeReason::power_key:
-    case PowerStateChangeReason::proximity:
-        return true;
-    }
-    return false;
-}
-
-enum DBusHandlerTaskId
-{
-    set_power_mode
-};
-}
-
-
-DBusScreen::DBusScreen(DBusScreenObserver& observer, QObject *parent)
-    : QObject(parent),
-      dbus_adaptor{new DBusScreenAdaptor(this)},
-      service_watcher{new QDBusServiceWatcher()},
-      observer{&observer},
-      worker_thread{new usc::WorkerThread("USC/DBusHandler")}
-{
-    QDBusConnection bus = QDBusConnection::systemBus();
-    bus.registerObject("/com/canonical/Unity/Screen", this);
-    bus.registerService("com.canonical.Unity.Screen");
-
-    service_watcher->setConnection(bus);
-    service_watcher->setWatchMode(QDBusServiceWatcher::WatchForUnregistration);
-
-    connect(service_watcher.get(),
-            SIGNAL(serviceUnregistered(QString const&)),
-            this, SLOT(remove_display_on_requestor(QString const&)));
-
-    //QT's ~QObject will release this child object
-    //so release ownership from the unique_ptr
-    dbus_adaptor.release();
-}
-
-DBusScreen::~DBusScreen() = default;
-
-bool DBusScreen::setScreenPowerMode(const QString &mode, int reason)
-{
-    if (!is_valid_reason(reason))
-        return false;
-
-    MirPowerMode newPowerMode;
-
-    // Note: the "standby" and "suspend" modes are mostly unused
-    if (mode == "on") {
-        newPowerMode = MirPowerMode::mir_power_mode_on;
-    } else if (mode == "standby") {
-        newPowerMode = MirPowerMode::mir_power_mode_standby; // higher power "off" mode (fastest resume)
-    } else if (mode == "suspend") {
-        newPowerMode = MirPowerMode::mir_power_mode_suspend; // medium power "off" mode
-    } else if (mode == "off") {
-        newPowerMode = MirPowerMode::mir_power_mode_off;     // lowest power "off" mode (slowest resume)
-    } else {
-        qWarning() << "DBusScreen: unknown mode type" << mode;
-        return false;
-    }
-
-    //This call may block - avoid blocking this dbus handling thread
-    worker_thread->queue_task([this, newPowerMode, reason]{
-        observer->set_screen_power_mode(newPowerMode, static_cast<PowerStateChangeReason>(reason));
-    }, DBusHandlerTaskId::set_power_mode);
-
-    return true;
-}
-
-void DBusScreen::emit_power_state_change(MirPowerMode power_mode, PowerStateChangeReason reason)
-{
-    QDBusMessage message =  QDBusMessage::createSignal("/com/canonical/Unity/Screen",
-        "com.canonical.Unity.Screen", "DisplayPowerStateChange");
-
-    int power_state = (power_mode == MirPowerMode::mir_power_mode_off) ? 0 : 1;
-
-    QVariant state(power_state);
-    QList<QVariant> arguments;
-    arguments.append(state);
-    arguments.append(static_cast<int>(reason));
-    message.setArguments(arguments);
-
-    QDBusConnection bus = QDBusConnection::systemBus();
-    bus.send(message);
-}
-
-int DBusScreen::keepDisplayOn()
-{
-    static std::atomic<uint32_t> request_id{0};
-
-    int id = request_id.fetch_add(1);
-    auto const& caller = message().service();
-
-    worker_thread->queue_task([this, id, caller]{
-        std::lock_guard<decltype(guard)> lock{guard};
-
-        //Check that the owner of the request is still valid
-        auto system_bus_if = QDBusConnection::systemBus().interface();
-        QDBusReply<QString> reply = system_bus_if->serviceOwner(caller);
-        if (!reply.isValid())
-            return;
-
-        auto& caller_requests = display_requests[caller.toStdString()];
-
-        if (caller_requests.size() == 0)
-            service_watcher->addWatchedService(caller);
-
-        caller_requests.insert(id);
-
-        //This call may block so it needs to be executed outside the thread
-        //that received the dbus call
-        observer->keep_display_on(true);
-
-        std::cout << "keepDisplayOn request id:" << id;
-        std::cout << " requested by \"" << caller.toStdString() << "\"" << std::endl;
-    });
-    return id;
-}
-
-void DBusScreen::removeDisplayOnRequest(int cookie)
-{
-    std::lock_guard<decltype(guard)> lock{guard};
-    auto const& requestor = message().service();
-
-    auto it = display_requests.find(requestor.toStdString());
-    if (it == display_requests.end())
-        return;
-
-    std::cout << "removeDisplayOnRequest id:" << cookie;
-    std::cout << " requested by \"" << requestor.toStdString() << "\"" << std::endl;
-
-    auto& caller_requests = it->second;
-    caller_requests.erase(cookie);
-    if (caller_requests.size() == 0)
-        remove_requestor(requestor, lock);
-}
-
-void DBusScreen::remove_display_on_requestor(QString const& requestor)
-{
-    std::lock_guard<decltype(guard)> lock{guard};
-    remove_requestor(requestor, lock);
-}
-
-void DBusScreen::remove_requestor(QString const& requestor, std::lock_guard<std::mutex> const&)
-{
-    std::cout << "remove_display_on_requestor \"" << requestor.toStdString() << "\"";
-    std::cout << std::endl;
-
-    display_requests.erase(requestor.toStdString());
-    service_watcher->removeWatchedService(requestor);
-    if (display_requests.size() == 0)
-        observer->keep_display_on(false);
-}
-
-void DBusScreen::setUserBrightness(int brightness)
-{
-    observer->set_brightness(brightness);
-}
-
-void DBusScreen::userAutobrightnessEnable(bool enable)
-{
-    observer->enable_auto_brightness(enable);
-}
-
-void DBusScreen::setInactivityTimeouts(int poweroff_timeout, int dimmer_timeout)
-{
-    observer->set_inactivity_timeouts(poweroff_timeout, dimmer_timeout);
-}
-
-void DBusScreen::setTouchVisualizationEnabled(bool enabled)
-{
-    observer->set_touch_visualization_enabled(enabled);
-}

=== removed file 'src/dbus_screen.h'
--- src/dbus_screen.h	2014-09-22 17:19:52 +0000
+++ src/dbus_screen.h	1970-01-01 00:00:00 +0000
@@ -1,77 +0,0 @@
-/*
- * 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/>.
- */
-
-#ifndef DBUS_SCREEN_H_
-#define DBUS_SCREEN_H_
-
-#include <mir_toolkit/common.h>
-
-#include <memory>
-#include <mutex>
-#include <unordered_map>
-#include <unordered_set>
-
-#include <QObject>
-#include <QtCore>
-#include <QDBusContext>
-
-namespace usc {class WorkerThread;}
-
-class DBusScreenAdaptor;
-class DBusScreenObserver;
-class QDBusInterface;
-class QDBusServiceWatcher;
-enum class PowerStateChangeReason;
-
-class DBusScreen : public QObject, protected QDBusContext
-{
-    Q_OBJECT
-    Q_CLASSINFO("D-Bus Interface", "com.canonical.Unity.Screen")
-
-public:
-    explicit DBusScreen(DBusScreenObserver& observer, QObject *parent = 0);
-    virtual ~DBusScreen();
-
-    void emit_power_state_change(MirPowerMode mode, PowerStateChangeReason reason);
-
-public Q_SLOTS:
-    bool setScreenPowerMode(const QString &mode, int reason);
-    int keepDisplayOn();
-    void removeDisplayOnRequest(int id);
-
-    //TODO: Expose same DBus powerd interface for now
-    void setUserBrightness(int brightness);
-    void userAutobrightnessEnable(bool enable);
-
-    void setInactivityTimeouts(int poweroff_timeout, int dimmer_timeout);
-    
-    void setTouchVisualizationEnabled(bool enabled);
-
-private Q_SLOTS:
-    void remove_display_on_requestor(QString const& requestor);
-
-private:
-    void remove_requestor(QString const& requestor, std::lock_guard<std::mutex> const& lock);
-
-    std::mutex guard;
-    std::unique_ptr<DBusScreenAdaptor> dbus_adaptor;
-    std::unique_ptr<QDBusServiceWatcher> service_watcher;
-    std::unordered_map<std::string, std::unordered_set<int>> display_requests;
-    DBusScreenObserver* const observer;
-    std::unique_ptr<usc::WorkerThread> worker_thread;
-};
-
-#endif /* DBUS_SCREEN_H_ */

=== modified file 'src/external_spinner.cpp'
--- src/external_spinner.cpp	2014-07-14 14:26:17 +0000
+++ src/external_spinner.cpp	2015-05-06 16:09:34 +0000
@@ -18,11 +18,15 @@
 
 #include "external_spinner.h"
 
+#include <unistd.h>
+#include <signal.h>
+
 usc::ExternalSpinner::ExternalSpinner(
     std::string const& executable,
     std::string const& mir_socket)
     : executable{executable},
-      mir_socket{mir_socket}
+      mir_socket{mir_socket},
+      spinner_pid{0}
 {
 }
 
@@ -33,22 +37,37 @@
 
 void usc::ExternalSpinner::ensure_running()
 {
-    if (executable.empty() || process.state() != QProcess::NotRunning)
+    std::lock_guard<std::mutex> lock{mutex};
+
+    if (executable.empty() || spinner_pid)
         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());
+    auto pid = fork();
+    if (!pid)
+    {
+        setenv("MIR_SOCKET", mir_socket.c_str(), 1);
+        execlp(executable.c_str(), executable.c_str(), nullptr);
+    }
+    else
+    {
+        spinner_pid = pid;
+    }
 }
 
 void usc::ExternalSpinner::kill()
 {
-    process.close();
+    std::lock_guard<std::mutex> lock{mutex};
+
+    if (spinner_pid)
+    {
+        ::kill(spinner_pid, SIGTERM);
+        spinner_pid = 0;
+    }
 }
 
 pid_t usc::ExternalSpinner::pid()
 {
-    return process.processId();
+    std::lock_guard<std::mutex> lock{mutex};
+
+    return spinner_pid;
 }

=== modified file 'src/external_spinner.h'
--- src/external_spinner.h	2014-07-14 14:26:17 +0000
+++ src/external_spinner.h	2015-05-06 16:09:34 +0000
@@ -21,8 +21,9 @@
 
 #include "spinner.h"
 
-#include <QProcess>
 #include <string>
+#include <sys/types.h>
+#include <mutex>
 
 namespace usc
 {
@@ -41,7 +42,8 @@
 private:
     std::string const executable;
     std::string const mir_socket;
-    QProcess process;
+    std::mutex mutex;
+    pid_t spinner_pid;
 };
 
 }

=== added file 'src/generate_header_with_string_from_file.sh'
--- src/generate_header_with_string_from_file.sh	1970-01-01 00:00:00 +0000
+++ src/generate_header_with_string_from_file.sh	2015-05-06 16:09:34 +0000
@@ -0,0 +1,26 @@
+# Copyright © 2015 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authored by: Alexandros Frantzis <[e-mail]>
+
+header=$1
+varname=$2
+filename=$3
+
+header_guard=$(echo "USC_$(basename $header)_" | tr '[a-z].' '[A-Z]_')
+
+echo "#ifndef $header_guard
+#define $header_guard
+const char* const $varname = R\"($(cat $filename))\";
+#endif" > $header

=== renamed file 'src/screen_state_handler.cpp' => 'src/mir_screen.cpp'
--- src/screen_state_handler.cpp	2015-02-09 16:26:25 +0000
+++ src/mir_screen.cpp	2015-05-06 16:09:34 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2014 Canonical Ltd.
+ * Copyright © 2014-2015 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -14,80 +14,72 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "screen_state_handler.h"
+#include "mir_screen.h"
 
 #include <mir/main_loop.h>
-#include <mir/time/timer.h>
+#include <mir/time/alarm_factory.h>
 #include <mir/compositor/compositor.h>
 #include <mir/graphics/display.h>
 #include <mir/graphics/display_configuration.h>
 #include <mir/input/touch_visualizer.h>
 
 #include <cstdio>
-#include "dbus_screen.h"
-#include "dbus_screen_observer.h"
-#include "powerd_mediator.h"
+#include "screen_hardware.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<usc::Server> const& server,
-                                       std::chrono::milliseconds poweroff_timeout,
-                                       std::chrono::milliseconds dimmer_timeout)
-    : current_power_mode{MirPowerMode::mir_power_mode_on},
+usc::MirScreen::MirScreen(
+    std::shared_ptr<usc::ScreenHardware> const& screen_hardware,
+    std::shared_ptr<mir::compositor::Compositor> const& compositor,
+    std::shared_ptr<mir::graphics::Display> const& display,
+    std::shared_ptr<mir::input::TouchVisualizer> const& touch_visualizer,
+    std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory,
+    std::chrono::milliseconds power_off_timeout,
+    std::chrono::milliseconds dimmer_timeout)
+    : screen_hardware{screen_hardware},
+      compositor{compositor},
+      display{display},
+      touch_visualizer{touch_visualizer},
+      alarm_factory{alarm_factory},
+      power_off_alarm{alarm_factory->create_alarm(
+              std::bind(&usc::MirScreen::power_off_alarm_notification, this))},
+      dimmer_alarm{alarm_factory->create_alarm(
+              std::bind(&usc::MirScreen::dimmer_alarm_notification, this))},
+      power_off_timeout{power_off_timeout},
+      dimming_timeout{dimmer_timeout},
+      current_power_mode{MirPowerMode::mir_power_mode_on},
       restart_timers{true},
-      power_off_timeout{poweroff_timeout},
-      dimming_timeout{dimmer_timeout},
-      powerd_mediator{new PowerdMediator()},
-      server{server},
-      power_off_alarm{server->the_main_loop()->create_alarm(
-              std::bind(&ScreenStateHandler::power_off_alarm_notification, this))},
-      dimmer_alarm{server->the_main_loop()->create_alarm(
-              std::bind(&ScreenStateHandler::dimmer_alarm_notification, this))},
-      dbus_screen{new DBusScreen(*this)}
+      power_state_change_handler{[](MirPowerMode,PowerStateChangeReason){}}
 {
     /*
      * Make sure the compositor is running as certain conditions can
      * cause Mir to tear down the compositor threads before we get
      * to this point. See bug #1410381.
      */
-    server->the_compositor()->start();
+    compositor->start();
     reset_timers_l();
 }
 
-ScreenStateHandler::~ScreenStateHandler() = default;
+usc::MirScreen::~MirScreen() = default;
 
-bool ScreenStateHandler::handle(MirEvent const& event)
+void usc::MirScreen::keep_display_on_temporarily()
 {
-    if (mir_event_get_type(&event) != mir_event_type_input)
-        return false;
-
-    auto input_event_type = mir_input_event_get_type(mir_event_get_input_event(&event));
-    // TODO: We should consider resetting the timer for key events too
-    // we have to make sure we wont introduce a bug where pressing the power
-    // key (to turn screen off) or just the volume keys will wake the screen though!
-    if (!(input_event_type == mir_input_event_type_touch
-          || input_event_type == mir_input_event_type_pointer))
-        return false;
-
     std::lock_guard<std::mutex> lock{guard};
     reset_timers_l();
     if (current_power_mode == MirPowerMode::mir_power_mode_on)
-        powerd_mediator->set_normal_backlight();
-
-    return false;
+        screen_hardware->set_normal_backlight();
 }
 
-void ScreenStateHandler::enable_inactivity_timers(bool enable)
+void usc::MirScreen::enable_inactivity_timers(bool enable)
 {
     std::lock_guard<std::mutex> lock{guard};
     enable_inactivity_timers_l(enable);
 }
 
-void ScreenStateHandler::toggle_screen_power_mode(PowerStateChangeReason reason)
+void usc::MirScreen::toggle_screen_power_mode(PowerStateChangeReason reason)
 {
     std::lock_guard<std::mutex> lock{guard};
     MirPowerMode new_mode = (current_power_mode == MirPowerMode::mir_power_mode_on) ?
@@ -96,13 +88,13 @@
     set_screen_power_mode_l(new_mode, reason);
 }
 
-void ScreenStateHandler::set_screen_power_mode(MirPowerMode mode, PowerStateChangeReason reason)
+void usc::MirScreen::set_screen_power_mode(MirPowerMode mode, PowerStateChangeReason reason)
 {
     std::lock_guard<std::mutex> lock{guard};
     set_screen_power_mode_l(mode, reason);
 }
 
-void ScreenStateHandler::keep_display_on(bool on)
+void usc::MirScreen::keep_display_on(bool on)
 {
     std::lock_guard<std::mutex> lock{guard};
     restart_timers = !on;
@@ -112,19 +104,19 @@
         set_screen_power_mode_l(MirPowerMode::mir_power_mode_on, PowerStateChangeReason::unknown);
 }
 
-void ScreenStateHandler::set_brightness(int brightness)
-{
-    std::lock_guard<std::mutex> lock{guard};
-    powerd_mediator->set_brightness(brightness);
-}
-
-void ScreenStateHandler::enable_auto_brightness(bool enable)
-{
-    std::lock_guard<std::mutex> lock{guard};
-    powerd_mediator->enable_auto_brightness(enable);
-}
-
-void ScreenStateHandler::set_inactivity_timeouts(int raw_poweroff_timeout, int raw_dimmer_timeout)
+void usc::MirScreen::set_brightness(int brightness)
+{
+    std::lock_guard<std::mutex> lock{guard};
+    screen_hardware->set_brightness(brightness);
+}
+
+void usc::MirScreen::enable_auto_brightness(bool enable)
+{
+    std::lock_guard<std::mutex> lock{guard};
+    screen_hardware->enable_auto_brightness(enable);
+}
+
+void usc::MirScreen::set_inactivity_timeouts(int raw_poweroff_timeout, int raw_dimmer_timeout)
 {
     std::lock_guard<std::mutex> lock{guard};
 
@@ -141,13 +133,13 @@
     reset_timers_l();
 }
 
-void ScreenStateHandler::set_screen_power_mode_l(MirPowerMode mode, PowerStateChangeReason reason)
+void usc::MirScreen::set_screen_power_mode_l(MirPowerMode mode, PowerStateChangeReason reason)
 {
     if (mode == MirPowerMode::mir_power_mode_on)
     {
         /* The screen may be dim, but on - make sure to reset backlight */
         if (current_power_mode == MirPowerMode::mir_power_mode_on)
-            powerd_mediator->set_normal_backlight();
+            screen_hardware->set_normal_backlight();
         configure_display_l(mode, reason);
         reset_timers_l();
     }
@@ -158,14 +150,12 @@
     }
 }
 
-void ScreenStateHandler::configure_display_l(MirPowerMode mode, PowerStateChangeReason reason)
+void usc::MirScreen::configure_display_l(MirPowerMode mode, PowerStateChangeReason reason)
 {
     if (current_power_mode == mode)
         return;
 
-    std::shared_ptr<mg::Display> display = server->the_display();
     std::shared_ptr<mg::DisplayConfiguration> displayConfig = display->configuration();
-    std::shared_ptr<mc::Compositor> compositor = server->the_compositor();
 
     displayConfig->for_each_output(
         [&](const mg::UserDisplayConfigurationOutput displayConfigOutput) {
@@ -179,11 +169,11 @@
     if (power_on)
     {
         //Some devices do not turn screen on properly from suspend mode
-        powerd_mediator->disable_suspend();
+        screen_hardware->disable_suspend();
     }
     else
     {
-        powerd_mediator->turn_off_backlight();
+        screen_hardware->turn_off_backlight();
     }
 
     display->configure(*displayConfig.get());
@@ -191,24 +181,25 @@
     if (power_on)
     {
         compositor->start();
-        powerd_mediator->set_normal_backlight();
+        screen_hardware->set_normal_backlight();
     }
 
     current_power_mode = mode;
 
-    dbus_screen->emit_power_state_change(mode, reason);
+    // TODO: Don't call this under lock
+    power_state_change_handler(mode, reason);
 
     if (!power_on)
-        powerd_mediator->allow_suspend();
+        screen_hardware->allow_suspend();
 }
 
-void ScreenStateHandler::cancel_timers_l()
+void usc::MirScreen::cancel_timers_l()
 {
     power_off_alarm->cancel();
     dimmer_alarm->cancel();
 }
 
-void ScreenStateHandler::reset_timers_l()
+void usc::MirScreen::reset_timers_l()
 {
     if (restart_timers && current_power_mode != MirPowerMode::mir_power_mode_off)
     {
@@ -220,7 +211,7 @@
     }
 }
 
-void ScreenStateHandler::enable_inactivity_timers_l(bool enable)
+void usc::MirScreen::enable_inactivity_timers_l(bool enable)
 {
     if (enable)
         reset_timers_l();
@@ -228,25 +219,32 @@
         cancel_timers_l();
 }
 
-void ScreenStateHandler::power_off_alarm_notification()
+void usc::MirScreen::power_off_alarm_notification()
 {
     std::lock_guard<std::mutex> lock{guard};
     configure_display_l(MirPowerMode::mir_power_mode_off, PowerStateChangeReason::inactivity);
 }
 
-void ScreenStateHandler::dimmer_alarm_notification()
+void usc::MirScreen::dimmer_alarm_notification()
 {
     std::lock_guard<std::mutex> lock{guard};
-    powerd_mediator->set_dim_backlight();
+    screen_hardware->set_dim_backlight();
 }
 
-void ScreenStateHandler::set_touch_visualization_enabled(bool enabled)
+void usc::MirScreen::set_touch_visualization_enabled(bool enabled)
 {
     std::lock_guard<std::mutex> lock{guard};
-    
-    auto visualizer = server->the_touch_visualizer();
+
     if (enabled)
-        visualizer->enable();
+        touch_visualizer->enable();
     else
-        visualizer->disable();
+        touch_visualizer->disable();
+}
+
+void usc::MirScreen::register_power_state_change_handler(
+    PowerStateChangeHandler const& handler)
+{
+    std::lock_guard<std::mutex> lock{guard};
+
+    power_state_change_handler = handler;
 }

=== renamed file 'src/screen_state_handler.h' => 'src/mir_screen.h'
--- src/screen_state_handler.h	2014-11-06 12:18:08 +0000
+++ src/mir_screen.h	2015-05-06 16:09:34 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2014 Canonical Ltd.
+ * Copyright © 2014-2015 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -14,51 +14,55 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef SCREEN_STATE_HANDLER_
-#define SCREEN_STATE_HANDLER_
+#ifndef USC_MIR_SCREEN_H_
+#define USC_MIR_SCREEN_H_
 
-#include "mir/input/event_filter.h"
-#include "dbus_screen_observer.h"
+#include "screen.h"
 
 #include <chrono>
 #include <memory>
 #include <mutex>
 
-class DBusScreen;
-class PowerdMediator;
 enum class PowerStateChangeReason;
-namespace usc { class Server; }
 
 namespace mir
 {
-namespace time
+namespace compositor { class Compositor; }
+namespace graphics {class Display;}
+namespace input { class TouchVisualizer; }
+namespace time { class AlarmFactory; class Alarm; }
+}
+
+namespace usc
 {
-class Alarm;
-class Timer;
-}
-}
+class Server;
+class ScreenHardware;
 
-class ScreenStateHandler: public mir::input::EventFilter, public DBusScreenObserver
+class MirScreen: public Screen
 {
 public:
-    ScreenStateHandler(std::shared_ptr<usc::Server> const& server,
-                       std::chrono::milliseconds power_off_timeout,
-                       std::chrono::milliseconds dimmer_timeout);
-    virtual ~ScreenStateHandler();
-
-    //from EventFilter
-    bool handle(MirEvent const& event) override;
-
-    void enable_inactivity_timers(bool enable);
-    void toggle_screen_power_mode(PowerStateChangeReason reason);
+    MirScreen(std::shared_ptr<usc::ScreenHardware> const& screen_hardware,
+              std::shared_ptr<mir::compositor::Compositor> const& compositor,
+              std::shared_ptr<mir::graphics::Display> const& display,
+              std::shared_ptr<mir::input::TouchVisualizer> const& touch_visualizer,
+              std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory,
+              std::chrono::milliseconds power_off_timeout,
+              std::chrono::milliseconds dimmer_timeout);
+    ~MirScreen();
+
+    void enable_inactivity_timers(bool enable) override;
+    void toggle_screen_power_mode(PowerStateChangeReason reason) override;
+    void keep_display_on_temporarily() override;
 
     void set_screen_power_mode(MirPowerMode mode, PowerStateChangeReason reason) override;
     void keep_display_on(bool on) override;
     void set_brightness(int brightness) override;
     void enable_auto_brightness(bool enable) override;
     void set_inactivity_timeouts(int power_off_timeout, int dimmer_timeout) override;
-    
+
     void set_touch_visualization_enabled(bool enabled) override;
+    void register_power_state_change_handler(
+            PowerStateChangeHandler const& power_state_change_handler) override;
 
 private:
     void set_screen_power_mode_l(MirPowerMode mode, PowerStateChangeReason reason);
@@ -72,21 +76,22 @@
     void dimmer_alarm_notification();
     void long_press_alarm_notification();
 
+    std::shared_ptr<usc::ScreenHardware> const screen_hardware;
+    std::shared_ptr<mir::compositor::Compositor> const compositor;
+    std::shared_ptr<mir::graphics::Display> const display;
+    std::shared_ptr<mir::input::TouchVisualizer> const touch_visualizer;
+    std::shared_ptr<mir::time::AlarmFactory> const alarm_factory;
+    std::unique_ptr<mir::time::Alarm> const power_off_alarm;
+    std::unique_ptr<mir::time::Alarm> const dimmer_alarm;
+
     std::mutex guard;
-
+    std::chrono::milliseconds power_off_timeout;
+    std::chrono::milliseconds dimming_timeout;
     MirPowerMode current_power_mode;
     bool restart_timers;
-
-    std::chrono::milliseconds power_off_timeout;
-    std::chrono::milliseconds dimming_timeout;
-
-    std::unique_ptr<PowerdMediator> powerd_mediator;
-    std::shared_ptr<usc::Server> server;
-
-    std::unique_ptr<mir::time::Alarm> power_off_alarm;
-    std::unique_ptr<mir::time::Alarm> dimmer_alarm;
-
-    std::unique_ptr<DBusScreen> dbus_screen;
+    PowerStateChangeHandler power_state_change_handler;
 };
 
+}
+
 #endif

=== modified file 'src/powerd_mediator.cpp'
--- src/powerd_mediator.cpp	2014-09-17 09:44:55 +0000
+++ src/powerd_mediator.cpp	2015-05-06 16:09:34 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2014 Canonical Ltd.
+ * Copyright © 2015 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -15,163 +15,253 @@
  */
 
 #include "powerd_mediator.h"
-
-#include <QDBusConnection>
-#include <QDBusInterface>
-#include <QDBusReply>
-#include <QDBusMetaType>
-#include <QDBusArgument>
-#include <QDBusServiceWatcher>
-
-#include <iostream>
-
-/* Struct for reply to getBrightnessParams DBus call */
-struct BrightnessParams
- {
-    int dim_brightness;
-    int min_brightness;
-    int max_brightness;
-    int default_brightness;
-    bool auto_brightness_supported;
-};
-Q_DECLARE_METATYPE(BrightnessParams);
-
-/* Not used but required by qDBusRegisterMetaType*/
-QDBusArgument &operator<<(QDBusArgument &argument, const BrightnessParams &mystruct)
-{
-    argument.beginStructure();
-    argument << mystruct.dim_brightness <<
-                mystruct.min_brightness <<
-                mystruct.max_brightness <<
-                mystruct.default_brightness <<
-                mystruct.auto_brightness_supported;
-    argument.endStructure();
-    return argument;
-}
-
-/* Needed to un-marshall powerd response */
-const QDBusArgument &operator>>(const QDBusArgument &argument, BrightnessParams &mystruct)
-{
-    argument.beginStructure();
-    argument >> mystruct.dim_brightness >>
-                mystruct.min_brightness >>
-                mystruct.max_brightness >>
-                mystruct.default_brightness >>
-                mystruct.auto_brightness_supported;
-    argument.endStructure();
-    return argument;
-}
-
-PowerdMediator::PowerdMediator()
-    : dim_brightness{10},
-      normal_brightness{102},
+#include "thread_name.h"
+#include "scoped_dbus_error.h"
+
+#include "dbus_message_handle.h"
+
+#include <future>
+#include <cstdint>
+
+namespace
+{
+
+char const* const powerd_service_name = "com.canonical.powerd";
+char const* const powerd_service_interface = "com.canonical.powerd";
+char const* const powerd_service_path = "/com/canonical/powerd";
+
+usc::DBusMessageHandle make_powerd_method_call_message(
+    char const* method, int first_arg_type, va_list args)
+{
+    return usc::DBusMessageHandle{
+        dbus_message_new_method_call(
+            powerd_service_name,
+            powerd_service_path,
+            powerd_service_interface,
+            method),
+        first_arg_type, args};
+}
+
+}
+
+usc::PowerdMediator::PowerdMediator(std::string const& bus_addr)
+    : connection{bus_addr.c_str()},
+      dbus_event_loop{connection},
+      pending_suspend_block_request{false},
+      dim_brightness_{10},
+      min_brightness_{0},
+      max_brightness_{102},
+      normal_brightness_{102},
       current_brightness{0},
-      min_brightness_{10},
-      max_brightness_{102},
+      backlight_state{BacklightState::normal},
       auto_brightness_supported_{false},
       auto_brightness_requested{false},
-      backlight_state{BacklightState::normal},
-      pending_suspend_blocker_request{true},
-      powerd_interface{new QDBusInterface("com.canonical.powerd",
-          "/com/canonical/powerd", "com.canonical.powerd", QDBusConnection::systemBus())},
-      service_watcher{new QDBusServiceWatcher("com.canonical.powerd",
-          QDBusConnection::systemBus(), QDBusServiceWatcher::WatchForRegistration)},
-      system_state{unknown}
+      sys_state{SysState::unknown}
 {
-    qDBusRegisterMetaType<BrightnessParams>();
-
-    //Powerd interface may not be available right now or it may restart in the future
-    //watch for changes so brightness params get initialized to the most recent values.
-    connect(service_watcher.get(),
-            SIGNAL(serviceRegistered(QString const&)),
-            this, SLOT(powerd_registered()));
-
-    powerd_interface->connection().connect("com.canonical.powerd",
-                                           "/com/canonical/powerd",
-                                           "com.canonical.powerd",
-                                           "SysPowerStateChange",
-                                           this,
-                                           SLOT(powerd_state_changed(int)));
-
-    if (powerd_interface->isValid())
-    {
-        init_brightness_params();
-        if (request_suspend_blocker())
+    connection.add_match(
+        "type='signal',"
+        "sender='com.canonical.powerd',"
+        "interface='com.canonical.powerd',"
+        "member='SysPowerStateChange'");
+    connection.add_match(
+        "type='signal',"
+        "sender='org.freedesktop.DBus',"
+        "interface='org.freedesktop.DBus',"
+        "member='NameOwnerChanged'");
+    connection.add_filter(handle_dbus_message_thunk, this);
+
+    std::promise<void> event_loop_started;
+    auto event_loop_started_future = event_loop_started.get_future();
+
+    dbus_loop_thread = std::thread(
+        [this,&event_loop_started]
         {
-            /*
-             * If powerd is already up it may already be in the active state
-             * and the SysPowerStateChange signal could have already been broadcasted
-             * before we got a chance to register a listener for it.
-             * We will assume that if the active request succeeds that the system state
-             * will become active at some point in the future - this is only a workaround
-             * for the lack of a system state query api in powerd
-             */
-            system_state = active;
-        }
-    }
-}
-
-PowerdMediator::~PowerdMediator()
-{
-    if (current_brightness > 0)
-        turn_off_backlight();
-}
-
-void PowerdMediator::set_dim_backlight()
-{
-    change_backlight_state(BacklightState::dim);
-}
-
-void PowerdMediator::set_normal_backlight()
-{
-    if (auto_brightness_requested)
-        change_backlight_state(BacklightState::automatic);
+            usc::set_thread_name("USC/DBusPowerd");
+            dbus_event_loop.run(event_loop_started);
+        });
+
+    event_loop_started_future.wait();
+
+    init_powerd_state(ForceDisableSuspend::yes);
+}
+
+usc::PowerdMediator::~PowerdMediator()
+{
+    turn_off_backlight();
+
+    dbus_event_loop.stop();
+    dbus_loop_thread.join();
+}
+
+void usc::PowerdMediator::set_dim_backlight()
+{
+    std::lock_guard<decltype(mutex)> lock{mutex};
+
+    change_backlight_state(BacklightState::dim, ForceBacklightState::no);
+}
+
+void usc::PowerdMediator::set_normal_backlight()
+{
+    std::lock_guard<decltype(mutex)> lock{mutex};
+
+    if (auto_brightness_supported_ && auto_brightness_requested)
+        change_backlight_state(BacklightState::automatic, ForceBacklightState::no);
     else
-        change_backlight_state(BacklightState::normal);
-}
-
-void PowerdMediator::turn_off_backlight()
-{
-    change_backlight_state(BacklightState::off);
-}
-
-void PowerdMediator::change_backlight_values(int dim, int normal)
-{
-    if (normal >= min_brightness_ && normal <= max_brightness_)
-        normal_brightness = normal;
-    if (dim >= min_brightness_ && dim <= max_brightness_)
-        dim_brightness = dim;
-}
-
-void PowerdMediator::enable_auto_brightness(bool enable)
-{
+        change_backlight_state(BacklightState::normal, ForceBacklightState::no);
+}
+
+void usc::PowerdMediator::turn_off_backlight()
+{
+    std::lock_guard<decltype(mutex)> lock{mutex};
+
+    change_backlight_state(BacklightState::off, ForceBacklightState::no);
+}
+
+void usc::PowerdMediator::change_backlight_values(int dim, int normal)
+{
+    std::lock_guard<decltype(mutex)> lock{mutex};
+
+    if (is_valid_brightness(dim))
+        dim_brightness_ = dim;
+    if (is_valid_brightness(normal))
+        normal_brightness_ = normal;
+}
+
+void usc::PowerdMediator::allow_suspend()
+{
+    std::lock_guard<decltype(mutex)> lock{mutex};
+
+    if (!suspend_block_cookie.empty())
+    {
+        auto const cstr = suspend_block_cookie.c_str();
+        invoke_with_reply("clearSysState",
+               DBUS_TYPE_STRING, &cstr,
+               DBUS_TYPE_INVALID);
+
+        suspend_block_cookie.clear();
+    }
+
+    pending_suspend_block_request = false;
+}
+
+void usc::PowerdMediator::disable_suspend()
+{
+    std::unique_lock<decltype(mutex)> lock{mutex};
+
+    if (request_suspend_block())
+    {
+        lock.unlock();
+        wait_for_sys_state(SysState::active);
+    }
+}
+
+void usc::PowerdMediator::enable_auto_brightness(bool enable)
+{
+    std::lock_guard<decltype(mutex)> lock{mutex};
+
     auto_brightness_requested = enable;
+
     if (auto_brightness_supported_ && enable)
-        change_backlight_state(BacklightState::automatic);
+        change_backlight_state(BacklightState::automatic, ForceBacklightState::no);
     else
-        change_backlight_state(BacklightState::normal);
+        change_backlight_state(BacklightState::normal, ForceBacklightState::no);
 }
 
-bool PowerdMediator::auto_brightness_supported()
+bool usc::PowerdMediator::auto_brightness_supported()
 {
+    std::lock_guard<decltype(mutex)> lock{mutex};
+
     return auto_brightness_supported_;
 }
 
-int PowerdMediator::min_brightness()
-{
+void usc::PowerdMediator::set_brightness(int brightness)
+{
+    std::lock_guard<decltype(mutex)> lock{mutex};
+
+    normal_brightness_ = brightness;
+    if (backlight_state != BacklightState::automatic)
+        change_backlight_state(BacklightState::normal, ForceBacklightState::yes);
+}
+
+int usc::PowerdMediator::min_brightness()
+{
+    std::lock_guard<decltype(mutex)> lock{mutex};
+
     return min_brightness_;
 }
 
-int PowerdMediator::max_brightness()
+int usc::PowerdMediator::max_brightness()
 {
+    std::lock_guard<decltype(mutex)> lock{mutex};
+
     return max_brightness_;
 }
 
-void PowerdMediator::powerd_registered()
-{
+bool usc::PowerdMediator::is_system_suspended()
+{
+    std::lock_guard<decltype(mutex)> lock{mutex};
+
+    return sys_state == SysState::suspend;
+}
+
+::DBusHandlerResult usc::PowerdMediator::handle_dbus_message_thunk(
+    ::DBusConnection* connection, DBusMessage* message, void* user_data)
+{
+    auto const powerd_mediator = static_cast<PowerdMediator*>(user_data);
+
+    return powerd_mediator->handle_dbus_message(connection, message, user_data);
+}
+
+::DBusHandlerResult usc::PowerdMediator::handle_dbus_message(
+    ::DBusConnection* connection, ::DBusMessage* message, void* user_data)
+{
+    ScopedDBusError error;
+
+    if (dbus_message_is_signal(message, powerd_service_interface, "SysPowerStateChange"))
+    {
+        int32_t state{-1};
+        dbus_message_get_args(
+            message, &error, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
+
+        if (!error)
+        {
+            update_sys_state(state == static_cast<int32_t>(SysState::suspend) ?
+                             SysState::suspend : SysState::active);
+        }
+    }
+    else if (dbus_message_is_signal(message, "org.freedesktop.DBus", "NameOwnerChanged"))
+    {
+        char const* name = "";
+        char const* old_owner = "";
+        char const* new_owner = "";
+
+        dbus_message_get_args(
+                message, &error,
+                DBUS_TYPE_STRING, &name,
+                DBUS_TYPE_STRING, &old_owner,
+                DBUS_TYPE_STRING, &new_owner,
+                DBUS_TYPE_INVALID);
+
+        if (!error &&
+            std::string{powerd_service_name} == name &&
+            *old_owner == '\0' &&
+            *new_owner != '\0')
+        {
+            init_powerd_state(ForceDisableSuspend::no);
+        }
+    }
+
+    return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+void usc::PowerdMediator::init_powerd_state(ForceDisableSuspend force_disable_suspend)
+{
+    std::lock_guard<decltype(mutex)> lock{mutex};
+
     init_brightness_params();
 
-    /* A suspend block request needs to be issued here on the following scenarios:
+    /*
+     * A suspend block request needs to be issued here on the following scenarios:
      * 1. powerd has restarted and PowerdMediator had already issued a request
      *    to the previous powerd instance
      * 2. When booting up the screen is assumed to be on and consequently we need to also issue
@@ -179,125 +269,199 @@
      * 3. If powerd interface is not available yet, but the screen had been turned on
      *    then now is the time to issue the request
      */
-    if (!suspend_block_cookie.isEmpty() || pending_suspend_blocker_request)
+    if (!suspend_block_cookie.empty() || pending_suspend_block_request ||
+        force_disable_suspend == ForceDisableSuspend::yes)
     {
-        //Clear the previous cookie as powerd has restarted anyway
+        // Clear the previous cookie as powerd has restarted anyway
         suspend_block_cookie.clear();
-        request_suspend_blocker();
-    }
-
-    //Powerd may have restarted, re-apply backlight settings
-    change_backlight_state(backlight_state, true);
-}
-
-void PowerdMediator::set_brightness(int brightness)
-{
-    normal_brightness = brightness;
-
-    if (backlight_state != BacklightState::automatic)
-        powerd_interface->call("setUserBrightness", brightness);
-}
-
-void PowerdMediator::change_backlight_state(BacklightState new_state, bool force_change)
-{
-    if (backlight_state == new_state && !force_change)
+        if (request_suspend_block())
+        {
+            /*
+             * If powerd is already up it may already be in the active state
+             * and the SysPowerStateChange signal could have already been broadcasted
+             * before we got a chance to register a listener for it.
+             * We will assume that if the active request succeeds that the system state
+             * will become active at some point in the future - this is only a workaround
+             * for the lack of a system state query api in powerd
+             */
+            update_sys_state(SysState::active);
+        }
+    }
+
+    // Powerd may have restarted, re-apply backlight settings
+    change_backlight_state(backlight_state, ForceBacklightState::yes);
+}
+
+void usc::PowerdMediator::init_brightness_params()
+{
+    auto reply = invoke_with_reply("getBrightnessParams", DBUS_TYPE_INVALID);
+
+    if (reply)
+    {
+        DBusMessageIter msg_iter;
+        dbus_message_iter_init(reply, &msg_iter);
+        if (dbus_message_iter_get_arg_type(&msg_iter) != DBUS_TYPE_STRUCT)
+            return;
+
+        DBusMessageIter struct_iter;
+        dbus_message_iter_recurse(&msg_iter, &struct_iter);
+
+        int32_t dim, min, max, normal;
+        dbus_bool_t auto_b;
+        struct { int type; void* address; } args[]{
+            { DBUS_TYPE_INT32, &dim },
+            { DBUS_TYPE_INT32, &min },
+            { DBUS_TYPE_INT32, &max },
+            { DBUS_TYPE_INT32, &normal },
+            { DBUS_TYPE_BOOLEAN, &auto_b }
+        };
+
+        for (auto const& arg : args)
+        {
+            if (dbus_message_iter_get_arg_type(&struct_iter) == arg.type)
+                dbus_message_iter_get_basic(&struct_iter, arg.address);
+            else
+                return;
+            dbus_message_iter_next(&struct_iter);
+        }
+
+        dim_brightness_ = dim;
+        min_brightness_ = min;
+        max_brightness_ = max;
+        normal_brightness_ = normal;
+        auto_brightness_supported_ = (auto_b == TRUE);
+    }
+}
+
+void usc::PowerdMediator::change_backlight_state(
+    BacklightState new_state,
+    ForceBacklightState force_backlight_state)
+{
+    if (backlight_state == new_state &&
+        force_backlight_state == ForceBacklightState::no)
+    {
         return;
+    }
+
+    update_current_brightness_for_state(new_state);
+    backlight_state = new_state;
 
     if (new_state == BacklightState::automatic)
     {
-        powerd_interface->call("userAutobrightnessEnable", true);
-        backlight_state = BacklightState::automatic;
-        return;
-    }
-
-    switch (new_state)
+        dbus_bool_t const enable{TRUE};
+        invoke_with_reply("userAutobrightnessEnable",
+               DBUS_TYPE_BOOLEAN, &enable,
+               DBUS_TYPE_INVALID);
+    }
+    else
+    {
+        int32_t const b{current_brightness};
+        invoke_with_reply("setUserBrightness",
+               DBUS_TYPE_INT32, &b,
+               DBUS_TYPE_INVALID);
+    }
+}
+
+bool usc::PowerdMediator::is_valid_brightness(int brightness)
+{
+    return brightness >= min_brightness_ && brightness <= max_brightness_;
+}
+
+bool usc::PowerdMediator::request_suspend_block()
+{
+    if (suspend_block_cookie.empty())
+    {
+        char const* const name{"com.canonical.Unity.Screen"};
+        int const sys_state_active{static_cast<int>(SysState::active)};
+
+        auto reply = invoke_with_reply(
+            "requestSysState",
+            DBUS_TYPE_STRING, &name,
+            DBUS_TYPE_INT32, &sys_state_active,
+            DBUS_TYPE_INVALID);
+
+        if (reply)
+        {
+            char const* cookie{nullptr};
+
+            dbus_message_get_args(
+                reply, nullptr,
+                DBUS_TYPE_STRING, &cookie,
+                DBUS_TYPE_INVALID);
+
+            if (cookie)
+                suspend_block_cookie = cookie;
+
+            return true;
+        }
+        else
+        {
+            pending_suspend_block_request = true;
+        }
+    }
+
+    return false;
+}
+
+void usc::PowerdMediator::update_sys_state(SysState state)
+{
+    {
+        std::lock_guard<decltype(mutex)> lock{sys_state_mutex};
+        sys_state = state;
+    }
+    sys_state_changed.notify_one();
+}
+
+void usc::PowerdMediator::wait_for_sys_state(SysState state)
+{
+    std::unique_lock<decltype(sys_state_mutex)> lock{sys_state_mutex};
+    sys_state_changed.wait(lock, [this, state]{ return sys_state == state; });
+}
+
+void usc::PowerdMediator::update_current_brightness_for_state(BacklightState state)
+{
+    switch (state)
     {
         case BacklightState::normal:
-            current_brightness = normal_brightness;
+            current_brightness = normal_brightness_;
             break;
         case BacklightState::off:
             current_brightness = 0;
             break;
         case BacklightState::dim:
-            current_brightness = dim_brightness;
+            current_brightness = dim_brightness_;
             break;
         default:
-            std::cerr << "unknown backlight state" << std::endl;
             break;
     }
-
-    powerd_interface->call("setUserBrightness", current_brightness);
-    backlight_state = new_state;
-}
-
-void PowerdMediator::allow_suspend()
-{
-    if (!suspend_block_cookie.isEmpty())
-    {
-        powerd_interface->call("clearSysState", suspend_block_cookie);
-        suspend_block_cookie.clear();
-    }
-    pending_suspend_blocker_request = false;
-}
-
-void PowerdMediator::disable_suspend()
-{
-    if (request_suspend_blocker())
-        wait_for_state(active);
-}
-
-bool PowerdMediator::request_suspend_blocker()
-{
-    if (suspend_block_cookie.isEmpty())
-    {
-        QDBusReply<QString> reply = powerd_interface->call("requestSysState", "com.canonical.Unity.Screen", 1);
-        if (reply.isValid())
-        {
-            suspend_block_cookie = reply.value();
-            pending_suspend_blocker_request = false;
-            return true;
-        }
-        else
-        {
-            //Powerd may not yet be available, so save the pending request
-            pending_suspend_blocker_request = true;
-        }
-    }
-    return false;
-}
-
-void PowerdMediator::init_brightness_params()
-{
-    QDBusReply<BrightnessParams> reply = powerd_interface->call("getBrightnessParams");
-    if (reply.isValid())
-    {
-        auto const& params = reply.value();
-        dim_brightness = params.dim_brightness;
-        normal_brightness = params.default_brightness;
-        min_brightness_ = params.min_brightness;
-        max_brightness_ = params.max_brightness;
-        auto_brightness_supported_ = params.auto_brightness_supported;
-        std::cerr << "initialized brightness parameters" << std::endl;
-    }
+}
+
+usc::DBusMessageHandle usc::PowerdMediator::invoke_with_reply(
+    char const* method, int first_arg_type, ...)
+{
+    va_list args;
+    va_start(args, first_arg_type);
+    auto msg = make_powerd_method_call_message(method, first_arg_type, args);
+    va_end(args);
+
+    std::promise<DBusMessage*> reply_promise;
+    auto reply_future = reply_promise.get_future();
+
+    auto const send_message_with_reply =
+        [this, &msg, &reply_promise]
+        {
+            auto const reply = dbus_connection_send_with_reply_and_block(
+                connection, msg, DBUS_TIMEOUT_USE_DEFAULT, nullptr);
+
+            reply_promise.set_value(reply);
+        };
+
+    // Run in the context of the dbus event loop to avoid
+    // strange dbus behaviors.
+    if (std::this_thread::get_id() == dbus_loop_thread.get_id())
+        send_message_with_reply();
     else
-    {
-        std::cerr << "getBrightnessParams call failed with: ";
-        std::cerr << reply.error().message().toStdString() << std::endl;
-    }
-}
-
-void PowerdMediator::powerd_state_changed(int state)
-{
-    std::unique_lock<std::mutex> lock(system_state_mutex);
-
-    system_state = state == 0 ? suspended : active;
-
-    lock.unlock();
-    state_change.notify_one();
-}
-
-void PowerdMediator::wait_for_state(SystemState state)
-{
-    std::unique_lock<std::mutex> lock(system_state_mutex);
-    state_change.wait(lock, [this, state]{ return (system_state == state); });
+        dbus_event_loop.enqueue(send_message_with_reply);
+
+    return usc::DBusMessageHandle{reply_future.get()};
 }

=== modified file 'src/powerd_mediator.h'
--- src/powerd_mediator.h	2014-08-14 18:06:05 +0000
+++ src/powerd_mediator.h	2015-05-06 16:09:34 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2014 Canonical Ltd.
+ * Copyright © 2015 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -14,53 +14,42 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef POWERD_MEDIATOR_
-#define POWERD_MEDIATOR_
-
-#include <mir_toolkit/common.h>
-
-#include <QString>
-#include <QObject>
-
-#include <memory>
-#include <mutex>
-#include <condition_variable>
-
-class QDBusInterface;
-class QDBusServiceWatcher;
-
-/*
- * A Proxy to powerd. Note this class is not thread-safe,
- * synchronization should be done externally.
- */
-class PowerdMediator : public QObject
-{
-    Q_OBJECT
+#ifndef USC_POWERD_MEDIATOR_H_
+#define USC_POWERD_MEDIATOR_H_
+
+#include "screen_hardware.h"
+
+#include "dbus_connection_handle.h"
+#include "dbus_event_loop.h"
+
+namespace usc
+{
+class DBusMessageHandle;
+
+class PowerdMediator : public ScreenHardware
+{
 public:
-    PowerdMediator();
+    PowerdMediator(std::string const& bus_addr);
     ~PowerdMediator();
 
-    void set_dim_backlight();
-    void set_normal_backlight();
-    void turn_off_backlight();
-    void allow_suspend();
-    void disable_suspend();
-
-    void change_backlight_values(int dim_brightness, int normal_brightness);
-    void enable_auto_brightness(bool flag);
-
-    bool auto_brightness_supported();
-    int min_brightness();
-    int max_brightness();
-
-    void set_brightness(int brightness);
-
-private Q_SLOTS:
-    void powerd_registered();
-    void powerd_state_changed(int state);
+    void set_dim_backlight() override;
+    void set_normal_backlight() override;
+    void turn_off_backlight() override;
+    void change_backlight_values(int dim_brightness, int normal_brightness) override;
+
+    void allow_suspend() override;
+    void disable_suspend() override;
+
+    void enable_auto_brightness(bool flag) override;
+    bool auto_brightness_supported() override;
+    void set_brightness(int brightness) override;
+    int min_brightness() override;
+    int max_brightness() override;
+
+    bool is_system_suspended();
 
 private:
-    enum BacklightState
+    enum class BacklightState
     {
         off,
         dim,
@@ -68,35 +57,53 @@
         automatic
     };
 
-    enum SystemState
+    enum class SysState
     {
         unknown = -1,
-        suspended = 0,
+        suspend = 0,
         active,
     };
-    void change_backlight_state(BacklightState state, bool force_change = false);
+
+    enum class ForceDisableSuspend { no, yes };
+    enum class ForceBacklightState { no, yes };
+
+    static ::DBusHandlerResult handle_dbus_message_thunk(
+        ::DBusConnection* connection, ::DBusMessage* message, void* user_data);
+
+    ::DBusHandlerResult handle_dbus_message(
+        ::DBusConnection* connection, ::DBusMessage* message, void* user_data);
+    void init_powerd_state(ForceDisableSuspend force_disable_suspend);
     void init_brightness_params();
-    bool request_suspend_blocker();
-    void wait_for_state(SystemState state);
-
-    int dim_brightness;
-    int normal_brightness;
-    int current_brightness;
+    void change_backlight_state(
+        BacklightState new_state, ForceBacklightState force_backlight_state);
+    bool is_valid_brightness(int brightness);
+    bool request_suspend_block();
+    void wait_for_sys_state(SysState state);
+    void update_sys_state(SysState state);
+    void update_current_brightness_for_state(BacklightState state);
+    void invoke(char const* method, int first_arg_type, ...);
+    usc::DBusMessageHandle invoke_with_reply(char const* method, int first_arg_type, ...);
+
+    usc::DBusConnectionHandle connection;
+    usc::DBusEventLoop dbus_event_loop;
+    std::thread dbus_loop_thread;
+
+    std::mutex mutex;
+    bool pending_suspend_block_request;
+    int dim_brightness_;
     int min_brightness_;
     int max_brightness_;
+    int normal_brightness_;
+    int current_brightness;
+    BacklightState backlight_state;
     bool auto_brightness_supported_;
     bool auto_brightness_requested;
-    BacklightState backlight_state;
-
-    QString suspend_block_cookie;
-    bool pending_suspend_blocker_request;
-
-    std::unique_ptr<QDBusInterface> powerd_interface;
-    std::unique_ptr<QDBusServiceWatcher> service_watcher;
-
-    SystemState system_state;
-
-    std::mutex system_state_mutex;
-    std::condition_variable state_change;
+    std::string suspend_block_cookie;
+    std::mutex sys_state_mutex;
+    SysState sys_state;
+    std::condition_variable sys_state_changed;
 };
+
+}
+
 #endif

=== added file 'src/scoped_dbus_error.h'
--- src/scoped_dbus_error.h	1970-01-01 00:00:00 +0000
+++ src/scoped_dbus_error.h	2015-05-06 16:09:34 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef USC_SCOPED_DBUS_ERROR_H_
+#define USC_SCOPED_DBUS_ERROR_H_
+
+#include <dbus/dbus.h>
+#include <string>
+
+namespace usc
+{
+
+struct ScopedDBusError : ::DBusError
+{
+    ScopedDBusError()
+    {
+        dbus_error_init(this);
+    }
+
+    ~ScopedDBusError()
+    {
+        if (dbus_error_is_set(this) == TRUE)
+            dbus_error_free(this);
+    }
+
+    std::string message_str() const
+    {
+        return message;
+    }
+
+    operator bool() const
+    {
+        return dbus_error_is_set(this) == TRUE;
+    }
+
+    ScopedDBusError(ScopedDBusError const&) = delete;
+    ScopedDBusError& operator=(ScopedDBusError const&) = delete;
+};
+
+}
+
+#endif

=== renamed file 'src/dbus_screen_observer.h' => 'src/screen.h'
--- src/dbus_screen_observer.h	2014-09-04 22:30:24 +0000
+++ src/screen.h	2015-05-06 16:09:34 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2014 Canonical Ltd.
+ * Copyright © 2014-2015 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -14,27 +14,44 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef DBUS_SCREEN_OBSERVER_H_
-#define DBUS_SCREEN_OBSERVER_H_
+#ifndef USC_SCREEN_H_
+#define USC_SCREEN_H_
+
+#include <mir_toolkit/common.h>
+#include <functional>
 
 enum class PowerStateChangeReason;
 
-class DBusScreenObserver
+namespace usc
+{
+
+using PowerStateChangeHandler = std::function<void(MirPowerMode, PowerStateChangeReason)>;
+
+class Screen
 {
 public:
-    virtual ~DBusScreenObserver() = default;
+    virtual ~Screen() = default;
+
+    virtual void enable_inactivity_timers(bool enable) = 0;
+    virtual void toggle_screen_power_mode(PowerStateChangeReason reason) = 0;
+    virtual void keep_display_on_temporarily() = 0;
 
     virtual void set_screen_power_mode(MirPowerMode mode, PowerStateChangeReason reason) = 0;
     virtual void keep_display_on(bool on) = 0;
     virtual void set_brightness(int brightness) = 0;
     virtual void enable_auto_brightness(bool enable) = 0;
-    virtual void set_inactivity_timeouts(int poweroff_timeout, int dimmer_timeout) = 0;
+    virtual void set_inactivity_timeouts(int power_off_timeout, int dimmer_timeout) = 0;
+
     virtual void set_touch_visualization_enabled(bool enabled) = 0;
+    virtual void register_power_state_change_handler(
+            PowerStateChangeHandler const& handler) = 0;
 
 protected:
-    DBusScreenObserver() = default;
-    DBusScreenObserver(const DBusScreenObserver&) = delete;
-    DBusScreenObserver& operator=(const DBusScreenObserver&) = delete;
+    Screen() = default;
+    Screen(Screen const&) = delete;
+    Screen& operator=(Screen const&) = delete;
 };
 
+}
+
 #endif

=== renamed file 'src/powerkey_handler.cpp' => 'src/screen_event_handler.cpp'
--- src/powerkey_handler.cpp	2014-12-11 22:15:07 +0000
+++ src/screen_event_handler.cpp	2015-05-06 16:09:34 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2014 Canonical Ltd.
+ * Copyright © 2014-2015 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -14,85 +14,96 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "powerkey_handler.h"
-#include "screen_state_handler.h"
+#include "screen_event_handler.h"
+#include "screen.h"
 #include "power_state_change_reason.h"
 
-#include <mir/time/timer.h>
+#include <mir/time/alarm_factory.h>
+#include <mir_toolkit/events/input/input_event.h>
 
 #include <cstdio>
-#include "dbus_screen.h"
-#include "powerd_mediator.h"
-
-namespace mi = mir::input;
-
-PowerKeyHandler::PowerKeyHandler(mir::time::Timer& timer,
-                                 std::chrono::milliseconds power_key_ignore_timeout,
-                                 std::chrono::milliseconds shutdown_timeout,
-                                 ScreenStateHandler& screen_state_handler)
-    : long_press_detected{false},
-      screen_state_handler{&screen_state_handler},
+
+usc::ScreenEventHandler::ScreenEventHandler(
+    std::shared_ptr<Screen> const& screen,
+    std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory,
+    std::chrono::milliseconds power_key_ignore_timeout,
+    std::chrono::milliseconds shutdown_timeout,
+    std::function<void()> const& shutdown)
+    : screen{screen},
+      alarm_factory{alarm_factory},
       power_key_ignore_timeout{power_key_ignore_timeout},
       shutdown_timeout{shutdown_timeout},
-      shutdown_alarm{timer.create_alarm([this]{ shutdown_alarm_notification(); })},
-      long_press_alarm{timer.create_alarm([this]{ long_press_notification(); })}
+      shutdown{shutdown},
+      long_press_detected{false},
+      shutdown_alarm{alarm_factory->create_alarm([this]{ shutdown_alarm_notification(); })},
+      long_press_alarm{alarm_factory->create_alarm([this]{ long_press_notification(); })}
 {
 }
 
-PowerKeyHandler::~PowerKeyHandler() = default;
+usc::ScreenEventHandler::~ScreenEventHandler() = default;
 
-bool PowerKeyHandler::handle(MirEvent const& event)
+bool usc::ScreenEventHandler::handle(MirEvent const& event)
 {
     static const int32_t POWER_KEY_CODE = 26;
-    
+
     if (mir_event_get_type(&event) != mir_event_type_input)
         return false;
-    auto input_event = mir_event_get_input_event(&event);
-    if (mir_input_event_get_type(input_event) != mir_input_event_type_key)
-        return false;
-    auto kev = mir_input_event_get_key_input_event(input_event);
-    if (mir_key_input_event_get_key_code(kev) != POWER_KEY_CODE)
-        return false;
-
-    auto action = mir_key_input_event_get_action(kev);
-    if (action == mir_key_input_event_action_down)
-        power_key_down();
-    else if (action == mir_key_input_event_action_up)
-        power_key_up();
+
+    auto const input_event = mir_event_get_input_event(&event);
+    auto const input_event_type = mir_input_event_get_type(input_event);
+
+    if (input_event_type == mir_input_event_type_key)
+    {
+        auto const kev = mir_input_event_get_keyboard_event(input_event);
+        if (mir_keyboard_event_key_code(kev) != POWER_KEY_CODE)
+            return false;
+
+        auto const action = mir_keyboard_event_action(kev);
+        if (action == mir_keyboard_action_down)
+            power_key_down();
+        else if (action == mir_keyboard_action_up)
+            power_key_up();
+    }
+    else if (input_event_type == mir_input_event_type_touch ||
+             input_event_type == mir_input_event_type_pointer)
+    {
+        std::lock_guard<std::mutex> lock{guard};
+        screen->keep_display_on_temporarily();
+    }
 
     return false;
 }
 
-void PowerKeyHandler::power_key_down()
+void usc::ScreenEventHandler::power_key_down()
 {
     std::lock_guard<std::mutex> lock{guard};
-    screen_state_handler->enable_inactivity_timers(false);
+    screen->enable_inactivity_timers(false);
     long_press_detected = false;
     long_press_alarm->reschedule_in(power_key_ignore_timeout);
     shutdown_alarm->reschedule_in(shutdown_timeout);
 }
 
-void PowerKeyHandler::power_key_up()
+void usc::ScreenEventHandler::power_key_up()
 {
     std::lock_guard<std::mutex> lock{guard};
     shutdown_alarm->cancel();
     long_press_alarm->cancel();
     if (!long_press_detected)
     {
-        screen_state_handler->toggle_screen_power_mode(PowerStateChangeReason::power_key);
+        screen->toggle_screen_power_mode(PowerStateChangeReason::power_key);
     }
 }
 
-void PowerKeyHandler::shutdown_alarm_notification()
+void usc::ScreenEventHandler::shutdown_alarm_notification()
 {
-    screen_state_handler->set_screen_power_mode(
+    screen->set_screen_power_mode(
         MirPowerMode::mir_power_mode_off, PowerStateChangeReason::power_key);
-    system("shutdown -P now");
+    shutdown();
 }
 
-void PowerKeyHandler::long_press_notification()
+void usc::ScreenEventHandler::long_press_notification()
 {
-    screen_state_handler->set_screen_power_mode(
+    screen->set_screen_power_mode(
         MirPowerMode::mir_power_mode_on, PowerStateChangeReason::power_key);
     long_press_detected = true;
 }

=== renamed file 'src/powerkey_handler.h' => 'src/screen_event_handler.h'
--- src/powerkey_handler.h	2014-11-03 17:57:10 +0000
+++ src/screen_event_handler.h	2015-05-06 16:09:34 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2014 Canonical Ltd.
+ * Copyright © 2014-2015 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -14,8 +14,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef POWERKEY_HANDLER_H_
-#define POWERKEY_HANDLER_H_
+#ifndef USC_SCREEN_EVENT_HANDLER_H_
+#define USC_SCREEN_EVENT_HANDLER_H_
 
 #include "mir/input/event_filter.h"
 
@@ -29,21 +29,25 @@
 namespace time
 {
 class Alarm;
-class Timer;
-}
-}
-
-class ScreenStateHandler;
-
-class PowerKeyHandler : public mir::input::EventFilter
+class AlarmFactory;
+}
+}
+
+namespace usc
+{
+class Screen;
+
+class ScreenEventHandler : public mir::input::EventFilter
 {
 public:
-    PowerKeyHandler(mir::time::Timer& timer,
-                    std::chrono::milliseconds power_key_ignore_timeout,
-                    std::chrono::milliseconds shutdown_timeout,
-                    ScreenStateHandler& screen_state_handler);
+    ScreenEventHandler(
+        std::shared_ptr<Screen> const& screen,
+        std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory,
+        std::chrono::milliseconds power_key_ignore_timeout,
+        std::chrono::milliseconds shutdown_timeout,
+        std::function<void()> const& shutdown);
 
-    ~PowerKeyHandler();
+    ~ScreenEventHandler();
 
     bool handle(MirEvent const& event) override;
 
@@ -54,16 +58,17 @@
     void long_press_notification();
 
     std::mutex guard;
+    std::shared_ptr<Screen> const screen;
+    std::shared_ptr<mir::time::AlarmFactory> const alarm_factory;
+    std::chrono::milliseconds const power_key_ignore_timeout;
+    std::chrono::milliseconds const shutdown_timeout;
+    std::function<void()> const shutdown;
+
     std::atomic<bool> long_press_detected;
-
-    ScreenStateHandler* screen_state_handler;
-
-    std::chrono::milliseconds power_key_ignore_timeout;
-    std::chrono::milliseconds shutdown_timeout;
-
     std::unique_ptr<mir::time::Alarm> shutdown_alarm;
     std::unique_ptr<mir::time::Alarm> long_press_alarm;
-
 };
 
+}
+
 #endif

=== added file 'src/screen_hardware.h'
--- src/screen_hardware.h	1970-01-01 00:00:00 +0000
+++ src/screen_hardware.h	2015-05-06 16:09:34 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef USC_SCREEN_HARDWARE_H_
+#define USC_SCREEN_HARDWARE_H_
+
+namespace usc
+{
+
+class ScreenHardware
+{
+public:
+    virtual ~ScreenHardware() = default;
+
+    virtual void set_dim_backlight() = 0;
+    virtual void set_normal_backlight() = 0;
+    virtual void turn_off_backlight() = 0;
+    virtual void change_backlight_values(int dim_brightness, int normal_brightness) = 0;
+
+    virtual void allow_suspend() = 0;
+    virtual void disable_suspend() = 0;
+
+    virtual void enable_auto_brightness(bool flag) = 0;
+    virtual bool auto_brightness_supported() = 0;
+    virtual void set_brightness(int brightness) = 0;
+    virtual int min_brightness() = 0;
+    virtual int max_brightness() = 0;
+
+protected:
+    ScreenHardware() = default;
+    ScreenHardware(ScreenHardware const&) = delete;
+    ScreenHardware& operator=(ScreenHardware const&) = delete;
+};
+
+}
+#endif

=== modified file 'src/server.cpp'
--- src/server.cpp	2015-01-27 17:43:17 +0000
+++ src/server.cpp	2015-05-06 16:09:34 +0000
@@ -18,14 +18,19 @@
 
 #include "server.h"
 #include "external_spinner.h"
-#include "shell.h"
 #include "asio_dm_connection.h"
 #include "session_switcher.h"
+#include "window_manager.h"
+#include "mir_screen.h"
+#include "screen_event_handler.h"
+#include "powerd_mediator.h"
+#include "unity_screen_service.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 <mir/main_loop.h>
 
 #include <iostream>
 
@@ -82,7 +87,7 @@
 
     std::weak_ptr<ms::Session> weak_active_session()
     {
-        return focus_controller->focussed_application();
+        return focus_controller->focused_session();
     }
 
     std::shared_ptr<msh::FocusController> const focus_controller;
@@ -126,11 +131,14 @@
             return std::make_shared<ServerStatusListener>(the_focus_controller());
         });
 
-    wrap_shell([this](std::shared_ptr<msh::Shell> const& wrapped)
-        -> std::shared_ptr<msh::Shell>
-        {
-            return std::make_shared<Shell>(wrapped, the_session_switcher());
-        });
+    override_the_window_manager_builder([this](msh::FocusController* focus_controller)
+       {
+         return std::make_shared<WindowManager>(
+             focus_controller,
+             the_shell_display_layout(),
+             the_session_coordinator(),
+             the_session_switcher());
+       });
 
     set_config_filename("unity-system-compositor.conf");
 
@@ -174,3 +182,64 @@
                 the_dm_message_handler());
         });
 }
+
+std::shared_ptr<usc::Screen> usc::Server::the_screen()
+{
+    return screen(
+        [this]
+        {
+            return std::make_shared<MirScreen>(
+                the_screen_hardware(),
+                the_compositor(),
+                the_display(),
+                the_touch_visualizer(),
+                the_main_loop(),
+                inactivity_display_off_timeout(),
+                inactivity_display_dim_timeout());
+        });
+}
+
+std::shared_ptr<mi::EventFilter> usc::Server::the_screen_event_handler()
+{
+    return screen_event_handler(
+        [this]
+        {
+            return std::make_shared<ScreenEventHandler>(
+                the_screen(),
+                the_main_loop(),
+                power_key_ignore_timeout(),
+                shutdown_timeout(),
+                [] { if (system("shutdown -P now")); }); // ignore warning
+        });
+}
+
+std::shared_ptr<usc::ScreenHardware> usc::Server::the_screen_hardware()
+{
+    return screen_hardware(
+        [this]
+        {
+            return std::make_shared<usc::PowerdMediator>(dbus_bus_address());
+        });
+}
+
+std::shared_ptr<usc::UnityScreenService> usc::Server::the_unity_screen_service()
+{
+    return unity_screen_service(
+        [this]
+        {
+            return std::make_shared<UnityScreenService>(
+                    dbus_bus_address(),
+                    the_screen());
+        });
+}
+
+std::string usc::Server::dbus_bus_address()
+{
+    static char const* const default_bus_address{"unix:path=/var/run/dbus/system_bus_socket"};
+
+    char const* bus = getenv("DBUS_SYSTEM_BUS_ADDRESS");
+    if (!bus)
+        bus = default_bus_address;
+
+    return std::string{bus};
+}

=== modified file 'src/server.h'
--- src/server.h	2014-11-28 11:39:04 +0000
+++ src/server.h	2015-05-06 16:09:34 +0000
@@ -23,12 +23,25 @@
 #include <mir/cached_ptr.h>
 #include <mir/options/option.h>
 
+#include <chrono>
+
+namespace mir
+{
+namespace input
+{
+class EventFilter;
+}
+}
+
 namespace usc
 {
 class Spinner;
 class SessionSwitcher;
 class DMMessageHandler;
 class DMConnection;
+class Screen;
+class ScreenHardware;
+class UnityScreenService;
 
 class Server : private mir::Server
 {
@@ -46,37 +59,16 @@
     virtual std::shared_ptr<Spinner> the_spinner();
     virtual std::shared_ptr<DMMessageHandler> the_dm_message_handler();
     virtual std::shared_ptr<DMConnection> the_dm_connection();
+    virtual std::shared_ptr<Screen> the_screen();
+    virtual std::shared_ptr<mir::input::EventFilter> the_screen_event_handler();
+    virtual std::shared_ptr<ScreenHardware> the_screen_hardware();
+    virtual std::shared_ptr<UnityScreenService> the_unity_screen_service();
 
     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", 2000);
-    }
-
-    bool enable_hardware_cursor()
-    {
-        return the_options()->get("enable-hardware-cursor", false);
-    }
-
     bool disable_inactivity_policy()
     {
         return the_options()->get("disable-inactivity-policy", false);
@@ -85,16 +77,6 @@
     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;
     }
 
@@ -114,11 +96,55 @@
     -> decltype(mir::Server::get_options())
     { return mir::Server::get_options(); }
 
+    std::chrono::milliseconds inactivity_display_off_timeout()
+    {
+        using namespace std::chrono;
+        return duration_cast<milliseconds>(
+            seconds{the_options()->get("inactivity-display-off-timeout", 60)});
+    }
+
+    std::chrono::milliseconds inactivity_display_dim_timeout()
+    {
+        using namespace std::chrono;
+        return duration_cast<milliseconds>(
+            seconds{the_options()->get("inactivity-display-dim-timeout", 45)});
+    }
+
+    std::chrono::milliseconds shutdown_timeout()
+    {
+        return std::chrono::milliseconds{
+            the_options()->get("shutdown-timeout", 5000)};
+    }
+
+    std::chrono::milliseconds power_key_ignore_timeout()
+    {
+        return std::chrono::milliseconds{
+            the_options()->get("power-key-ignore-timeout", 2000)};
+    }
+
+    bool enable_hardware_cursor()
+    {
+        return the_options()->get("enable-hardware-cursor", false);
+    }
+
+    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", "");
+        return x;
+    }
+
     virtual std::shared_ptr<SessionSwitcher> the_session_switcher();
+    std::string dbus_bus_address();
 
     mir::CachedPtr<Spinner> spinner;
     mir::CachedPtr<DMConnection> dm_connection;
     mir::CachedPtr<SessionSwitcher> session_switcher;
+    mir::CachedPtr<Screen> screen;
+    mir::CachedPtr<mir::input::EventFilter> screen_event_handler;
+    mir::CachedPtr<ScreenHardware> screen_hardware;
+    mir::CachedPtr<UnityScreenService> unity_screen_service;
 };
 
 }

=== removed file 'src/shell.cpp'
--- src/shell.cpp	2015-01-27 17:43:17 +0000
+++ src/shell.cpp	1970-01-01 00:00:00 +0000
@@ -1,157 +0,0 @@
-/*
- * Copyright © 2014-2015 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 3 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Alexandros Frantzis <[e-mail]>
- */
-
-#include "shell.h"
-#include "session_switcher.h"
-
-#include <mir/scene/null_surface_observer.h>
-#include <mir/scene/session.h>
-#include <mir/scene/surface.h>
-#include <mir/frontend/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::frontend::Session const* s) override
-    {
-        return scene_session.get() == s;
-    }
-
-    std::shared_ptr<ms::Session> const scene_session;
-    msh::FocusController& focus_controller;
-};
-
-
-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::Shell::Shell(
-    std::shared_ptr<msh::Shell> const& wrapped,
-    std::shared_ptr<SessionSwitcher> const& session_switcher)
-    : msh::ShellWrapper{wrapped},
-      session_switcher{session_switcher}
-{
-}
-
-std::shared_ptr<ms::Session>
-usc::Shell::open_session(
-    pid_t client_pid,
-    std::string const& name,
-    std::shared_ptr<mf::EventSink> const& sink)
-{
-    std::cerr << "Opening session " << name << std::endl;
-
-    auto orig = msh::ShellWrapper::open_session(client_pid, name, sink);
-
-    auto const usc_session = std::make_shared<UscSession>(orig, *this);
-
-    session_switcher->add(usc_session, client_pid);
-
-    return orig;
-}
-
-void usc::Shell::close_session(std::shared_ptr<ms::Session> const& session)
-{
-    std::cerr << "Closing session " << session->name() << std::endl;
-
-    msh::ShellWrapper::close_session(session);
-
-    session_switcher->remove(session);
-}
-
-mf::SurfaceId usc::Shell::create_surface(std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const& params)
-{
-    auto const id = msh::ShellWrapper::create_surface(session, params);
-
-    auto const surface = session->surface(id);
-    auto const session_ready_observer = std::make_shared<SessionReadyObserver>(
-        session_switcher, surface, session.get());
-
-    surface->add_observer(session_ready_observer);
-
-    return id;
-}

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

=== modified file 'src/system_compositor.cpp'
--- src/system_compositor.cpp	2015-01-05 22:38:04 +0000
+++ src/system_compositor.cpp	2015-05-06 16:09:34 +0000
@@ -17,30 +17,18 @@
  *              Alexandros Frantzis <[e-mail]>
  */
 
-
 #include "system_compositor.h"
 #include "server.h"
 #include "dm_connection.h"
-#include "spinner.h"
-#include "screen_state_handler.h"
-#include "powerkey_handler.h"
-
-// Qt headers will introduce a #define of "signals"
-// but some mir headers use "signals" as a variable name in
-// method declarations
-#undef signals
 
 #include <mir/input/composite_event_filter.h>
 #include <mir/abnormal_exit.h>
-#include <mir/main_loop.h>
 
 #include <cerrno>
 #include <iostream>
 #include <sys/stat.h>
-#include <thread>
 #include <regex.h>
 #include <GLES2/gl2.h>
-#include <QCoreApplication>
 
 namespace
 {
@@ -99,31 +87,21 @@
         return;
     }
 
-    struct ScopeGuard
-    {
-        ~ScopeGuard()
-        {
-            if (qt_thread.joinable())
-            {
-                QCoreApplication::quit();
-                qt_thread.join();
-            }
-        }
-
-        std::thread qt_thread;
-    } guard;
-
     server->add_init_callback([&]
         {
             auto vendor = (char *) glGetString(GL_VENDOR);
             auto renderer = (char *) glGetString (GL_RENDERER);
             auto version = (char *) glGetString (GL_VERSION);
+
             std::cerr << "GL_VENDOR = " << vendor << std::endl;
             std::cerr << "GL_RENDERER = " << renderer << std::endl;
             std::cerr << "GL_VERSION = " << version << std::endl;
 
             if (!check_blacklist(server->blacklist(), vendor, renderer, version))
-                throw mir::AbnormalExit ("Video driver is blacklisted, exiting");
+            {
+                BOOST_THROW_EXCEPTION(
+                    mir::AbnormalExit("Video driver is blacklisted, exiting"));
+            }
 
             dm_connection = server->the_dm_connection();
 
@@ -135,43 +113,17 @@
 
             dm_connection->start();
 
-            guard.qt_thread = std::thread(&SystemCompositor::qt_main, this);
+            if (!server->disable_inactivity_policy())
+            {
+                screen = server->the_screen();
+                screen_event_handler = server->the_screen_event_handler();
+
+                auto composite_filter = server->the_composite_event_filter();
+                composite_filter->append(screen_event_handler);
+
+                unity_screen_service = server->the_unity_screen_service();
+            }
         });
 
     server->run();
 }
-
-void usc::SystemCompositor::qt_main()
-{
-    int argc{0};
-    QCoreApplication app(argc, nullptr);
-
-    if (!server->disable_inactivity_policy())
-    {
-        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>(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>(*(server->the_main_loop()),
-            power_key_ignore_timeout,
-            shutdown_timeout,
-            *screen_state_handler);
-
-        auto composite_filter = server->the_composite_event_filter();
-        composite_filter->append(screen_state_handler);
-        composite_filter->append(power_key_handler);
-    }
-
-    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-11-28 13:19:29 +0000
+++ src/system_compositor.h	2015-05-06 16:09:34 +0000
@@ -22,8 +22,13 @@
 
 #include <memory>
 
-class ScreenStateHandler;
-class PowerKeyHandler;
+namespace mir
+{
+namespace input
+{
+class EventFilter;
+}
+}
 
 namespace usc
 {
@@ -31,6 +36,9 @@
 class Server;
 class DMConnection;
 class Spinner;
+class ScreenEventHandler;
+class Screen;
+class UnityScreenService;
 
 class SystemCompositor
 {
@@ -39,13 +47,12 @@
     void run();
 
 private:
-    void qt_main();
-
     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;
+    std::shared_ptr<Screen> screen;
+    std::shared_ptr<mir::input::EventFilter> screen_event_handler;
+    std::shared_ptr<UnityScreenService> unity_screen_service;
 };
 
 }

=== added file 'src/thread_name.cpp'
--- src/thread_name.cpp	1970-01-01 00:00:00 +0000
+++ src/thread_name.cpp	2015-05-06 16:09:34 +0000
@@ -0,0 +1,32 @@
+/*
+ * Copyright © 2014-2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "thread_name.h"
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <pthread.h>
+
+void usc::set_thread_name(std::string const& name)
+{
+    static size_t const max_name_len = 15;
+    auto const proper_name = name.substr(0, max_name_len);
+
+    pthread_setname_np(pthread_self(), proper_name.c_str());
+}

=== added file 'src/thread_name.h'
--- src/thread_name.h	1970-01-01 00:00:00 +0000
+++ src/thread_name.h	2015-05-06 16:09:34 +0000
@@ -0,0 +1,29 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef USC_THREAD_NAME_H_
+#define USC_THREAD_NAME_H_
+
+#include <string>
+
+namespace usc
+{
+void set_thread_name(std::string const& name);
+}
+
+#endif

=== added file 'src/unity_screen_service.cpp'
--- src/unity_screen_service.cpp	1970-01-01 00:00:00 +0000
+++ src/unity_screen_service.cpp	2015-05-06 16:09:34 +0000
@@ -0,0 +1,358 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "unity_screen_service.h"
+#include "screen.h"
+#include "dbus_message_handle.h"
+#include "thread_name.h"
+#include "scoped_dbus_error.h"
+
+#include "unity_screen_service_introspection.h" // autogenerated
+
+namespace
+{
+
+char const* const dbus_screen_interface = "com.canonical.Unity.Screen";
+char const* const dbus_screen_path = "/com/canonical/Unity/Screen";
+char const* const dbus_screen_service_name = "com.canonical.Unity.Screen";
+
+}
+
+usc::UnityScreenService::UnityScreenService(
+    std::string const& bus_addr,
+    std::shared_ptr<usc::Screen> const& screen)
+    : connection{bus_addr.c_str()},
+      screen{screen},
+      dbus_event_loop{connection},
+      request_id{0}
+{
+    connection.request_name(dbus_screen_service_name);
+    connection.add_match(
+        "type='signal',"
+        "sender='org.freedesktop.DBus',"
+        "interface='org.freedesktop.DBus',"
+        "member='NameOwnerChanged'");
+    connection.add_filter(handle_dbus_message_thunk, this);
+
+    screen->register_power_state_change_handler(
+        [this](MirPowerMode mode, PowerStateChangeReason reason)
+        {
+            dbus_emit_DisplayPowerStateChange(mode, reason);
+        });
+
+    std::promise<void> event_loop_started;
+    auto event_loop_started_future = event_loop_started.get_future();
+
+    dbus_loop_thread = std::thread(
+        [this,&event_loop_started]
+        {
+            usc::set_thread_name("USC/DBusScreen");
+            dbus_event_loop.run(event_loop_started);
+        });
+
+    event_loop_started_future.wait();
+}
+
+usc::UnityScreenService::~UnityScreenService()
+{
+    dbus_event_loop.stop();
+    dbus_loop_thread.join();
+}
+
+::DBusHandlerResult usc::UnityScreenService::handle_dbus_message_thunk(
+    ::DBusConnection* connection, DBusMessage* message, void* user_data)
+{
+    auto const dbus_screen_service = static_cast<usc::UnityScreenService*>(user_data);
+    return dbus_screen_service->handle_dbus_message(connection, message, user_data);
+}
+
+DBusHandlerResult usc::UnityScreenService::handle_dbus_message(
+    ::DBusConnection* connection, DBusMessage* message, void* user_data)
+{
+    auto const sender = dbus_message_get_sender(message);
+    ScopedDBusError args_error;
+
+    if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Introspectable", "Introspect"))
+    {
+        DBusMessageHandle reply{
+            dbus_message_new_method_return(message),
+            DBUS_TYPE_STRING, &unity_screen_service_introspection,
+            DBUS_TYPE_INVALID};
+
+        dbus_connection_send(connection, reply, nullptr);
+    }
+    else if (dbus_message_is_method_call(message, dbus_screen_interface, "setUserBrightness"))
+    {
+        int32_t brightness{0};
+        dbus_message_get_args(
+            message, &args_error, DBUS_TYPE_INT32, &brightness, DBUS_TYPE_INVALID);
+
+        if (!args_error)
+        {
+            dbus_setUserBrightness(brightness);
+
+            DBusMessageHandle reply{dbus_message_new_method_return(message)};
+            dbus_connection_send(connection, reply, nullptr);
+        }
+    }
+    else if (dbus_message_is_method_call(message, dbus_screen_interface, "userAutobrightnessEnable"))
+    {
+        dbus_bool_t enable{false};
+        dbus_message_get_args(
+            message, &args_error, DBUS_TYPE_BOOLEAN, &enable, DBUS_TYPE_INVALID);
+
+        if (!args_error)
+        {
+            dbus_userAutobrightnessEnable(enable);
+
+            DBusMessageHandle reply{dbus_message_new_method_return(message)};
+            dbus_connection_send(connection, reply, nullptr);
+        }
+    }
+    else if (dbus_message_is_method_call(message, dbus_screen_interface, "setInactivityTimeouts"))
+    {
+        int32_t poweroff_timeout{-1};
+        int32_t dimmer_timeout{-1};
+        dbus_message_get_args(
+            message, &args_error,
+            DBUS_TYPE_INT32, &poweroff_timeout,
+            DBUS_TYPE_INT32, &dimmer_timeout,
+            DBUS_TYPE_INVALID);
+
+        if (!args_error)
+        {
+            dbus_setInactivityTimeouts(poweroff_timeout, dimmer_timeout);
+
+            DBusMessageHandle reply{dbus_message_new_method_return(message)};
+            dbus_connection_send(connection, reply, nullptr);
+        }
+    }
+    else if (dbus_message_is_method_call(message, dbus_screen_interface, "setTouchVisualizationEnabled"))
+    {
+        dbus_bool_t enable{false};
+        dbus_message_get_args(
+            message, &args_error, DBUS_TYPE_BOOLEAN, &enable, DBUS_TYPE_INVALID);
+
+        if (!args_error)
+        {
+            dbus_setTouchVisualizationEnabled(enable);
+
+            DBusMessageHandle reply{dbus_message_new_method_return(message)};
+            dbus_connection_send(connection, reply, nullptr);
+        }
+    }
+    else if (dbus_message_is_method_call(message, dbus_screen_interface, "setScreenPowerMode"))
+    {
+        char const* mode = nullptr;
+        int32_t reason{-1};
+
+        dbus_message_get_args(
+            message, &args_error,
+            DBUS_TYPE_STRING, &mode,
+            DBUS_TYPE_INT32, &reason,
+            DBUS_TYPE_INVALID);
+
+        if (!args_error)
+        {
+            auto const result = dbus_setScreenPowerMode(mode, reason);
+            dbus_bool_t bresult = (result == true);
+
+            DBusMessageHandle reply{
+                dbus_message_new_method_return(message),
+                DBUS_TYPE_BOOLEAN, &bresult,
+                DBUS_TYPE_INVALID};
+
+            dbus_connection_send(connection, reply, nullptr);
+        }
+    }
+    else if (dbus_message_is_method_call(message, dbus_screen_interface, "keepDisplayOn"))
+    {
+        auto const id = dbus_keepDisplayOn(sender);
+
+        DBusMessageHandle reply{
+            dbus_message_new_method_return(message),
+            DBUS_TYPE_INT32, &id,
+            DBUS_TYPE_INVALID};
+
+        dbus_connection_send(connection, reply, nullptr);
+    }
+    else if (dbus_message_is_method_call(message, dbus_screen_interface, "removeDisplayOnRequest"))
+    {
+        int32_t id{-1};
+        dbus_message_get_args(
+            message, &args_error,
+            DBUS_TYPE_INT32, &id,
+            DBUS_TYPE_INVALID);
+
+        if (!args_error)
+        {
+            dbus_removeDisplayOnRequest(sender, id);
+
+            DBusMessageHandle reply{dbus_message_new_method_return(message)};
+            dbus_connection_send(connection, reply, nullptr);
+        }
+    }
+    else if (dbus_message_is_signal(message, "org.freedesktop.DBus", "NameOwnerChanged"))
+    {
+        char const* name = nullptr;
+        char const* old_owner = nullptr;
+        char const* new_owner = nullptr;
+
+        dbus_message_get_args(
+                message, &args_error,
+                DBUS_TYPE_STRING, &name,
+                DBUS_TYPE_STRING, &old_owner,
+                DBUS_TYPE_STRING, &new_owner,
+                DBUS_TYPE_INVALID);
+
+        if (!args_error)
+            dbus_NameOwnerChanged(name, old_owner, new_owner);
+    }
+    else if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL)
+    {
+         DBusMessageHandle reply{
+             dbus_message_new_error(message, DBUS_ERROR_FAILED, "Not supported")};
+
+        dbus_connection_send(connection, reply, nullptr);
+    }
+
+    if (args_error)
+    {
+         DBusMessageHandle reply{
+             dbus_message_new_error(message, DBUS_ERROR_FAILED, "Invalid arguments")};
+
+        dbus_connection_send(connection, reply, nullptr);
+    }
+
+    return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+void usc::UnityScreenService::dbus_setUserBrightness(int32_t brightness)
+{
+    screen->set_brightness(brightness);
+}
+
+void usc::UnityScreenService::dbus_userAutobrightnessEnable(dbus_bool_t enable)
+{
+    screen->enable_auto_brightness(enable == TRUE);
+}
+
+void usc::UnityScreenService::dbus_setInactivityTimeouts(
+    int32_t poweroff_timeout, int32_t dimmer_timeout)
+{
+    screen->set_inactivity_timeouts(poweroff_timeout, dimmer_timeout);
+}
+
+void usc::UnityScreenService::dbus_setTouchVisualizationEnabled(dbus_bool_t enable)
+{
+    screen->set_touch_visualization_enabled(enable == TRUE);
+}
+
+bool usc::UnityScreenService::dbus_setScreenPowerMode(
+    std::string const& mode,
+    int32_t reason)
+{
+    MirPowerMode new_power_mode;
+
+    // Note: the "standby" and "suspend" modes are mostly unused
+    if (mode == "on")
+        new_power_mode = MirPowerMode::mir_power_mode_on;
+    else if (mode == "standby") // higher power "off" mode (fastest resume)
+        new_power_mode = MirPowerMode::mir_power_mode_standby; 
+    else if (mode == "suspend") // medium power "off" mode
+        new_power_mode = MirPowerMode::mir_power_mode_suspend;
+    else if (mode == "off") // lowest power "off" mode (slowest resume)
+        new_power_mode = MirPowerMode::mir_power_mode_off;
+    else
+        return false;
+
+    screen->set_screen_power_mode(
+        new_power_mode, static_cast<PowerStateChangeReason>(reason));
+
+    return true;
+}
+
+int32_t usc::UnityScreenService::dbus_keepDisplayOn(
+    std::string const& sender)
+{
+    std::lock_guard<std::mutex> lock{keep_display_on_mutex};
+
+    auto const id = ++request_id;
+
+    keep_display_on_ids.emplace(sender, id);
+    screen->keep_display_on(true);
+
+    return id;
+}
+
+void usc::UnityScreenService::dbus_removeDisplayOnRequest(
+    std::string const& sender, int32_t id)
+{
+    std::lock_guard<std::mutex> lock{keep_display_on_mutex};
+
+    auto range = keep_display_on_ids.equal_range(sender);
+    for (auto iter = range.first;
+         iter != range.second;
+         ++iter)
+    {
+        if (iter->second == id)
+        {
+            keep_display_on_ids.erase(iter);
+            break;
+        }
+    }
+
+    if (keep_display_on_ids.empty())
+        screen->keep_display_on(false);
+}
+
+void usc::UnityScreenService::dbus_NameOwnerChanged(
+    std::string const& name,
+    std::string const& old_owner,
+    std::string const& new_owner)
+{
+    if (new_owner.empty() && old_owner == name)
+    {
+        std::lock_guard<std::mutex> lock{keep_display_on_mutex};
+        keep_display_on_ids.erase(name);
+        if (keep_display_on_ids.empty())
+            screen->keep_display_on(false);
+    }
+}
+
+void usc::UnityScreenService::dbus_emit_DisplayPowerStateChange(
+    MirPowerMode power_mode, PowerStateChangeReason reason)
+{
+    int32_t const power_state = (power_mode == MirPowerMode::mir_power_mode_off) ? 0 : 1;
+    int32_t const reason_int = static_cast<int32_t>(reason);
+
+    dbus_event_loop.enqueue(
+        [this, power_state, reason_int]
+        {
+            DBusMessageHandle signal{
+                dbus_message_new_signal(
+                    dbus_screen_path,
+                    dbus_screen_interface,
+                    "DisplayPowerStateChange"),
+                DBUS_TYPE_INT32, &power_state,
+                DBUS_TYPE_INT32, &reason_int,
+                DBUS_TYPE_INVALID};
+
+            dbus_connection_send(connection, signal, nullptr);
+        });
+}

=== added file 'src/unity_screen_service.h'
--- src/unity_screen_service.h	1970-01-01 00:00:00 +0000
+++ src/unity_screen_service.h	2015-05-06 16:09:34 +0000
@@ -0,0 +1,83 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef USC_UNITY_SCREEN_SERVICE_H_
+#define USC_UNITY_SCREEN_SERVICE_H_
+
+#include "dbus_event_loop.h"
+#include "dbus_connection_handle.h"
+
+#include <mir_toolkit/common.h>
+
+#include <cstdint>
+#include <memory>
+#include <thread>
+#include <atomic>
+#include <mutex>
+#include <unordered_map>
+
+enum class PowerStateChangeReason;
+
+namespace usc
+{
+class Screen;
+class WorkerThread;
+
+class UnityScreenService
+{
+public:
+    UnityScreenService(
+        std::string const& bus_addr,
+        std::shared_ptr<usc::Screen> const& screen);
+    ~UnityScreenService();
+
+private:
+    void dbus_loop();
+    void stop_loop();
+    static ::DBusHandlerResult handle_dbus_message_thunk(
+        DBusConnection* connection, DBusMessage* message, void* user_data);
+    ::DBusHandlerResult handle_dbus_message(
+        DBusConnection* connection, DBusMessage* message, void* user_data);
+
+    void dbus_setUserBrightness(int32_t brightness);
+    void dbus_userAutobrightnessEnable(dbus_bool_t enable);
+    void dbus_setInactivityTimeouts(int32_t poweroff_timeout, int32_t dimmer_timeout);
+    void dbus_setTouchVisualizationEnabled(dbus_bool_t enable);
+    bool dbus_setScreenPowerMode(std::string const& mode, int32_t reason);
+    int32_t dbus_keepDisplayOn(std::string const& sender);
+    void dbus_removeDisplayOnRequest(std::string const& sender, int32_t id);
+    void dbus_NameOwnerChanged(
+        std::string const& name,
+        std::string const& old_owner,
+        std::string const& new_owner);
+    void dbus_emit_DisplayPowerStateChange(
+        MirPowerMode power_mode, PowerStateChangeReason reason);
+
+    DBusConnectionHandle const connection;
+    std::shared_ptr<usc::Screen> const screen;
+
+    DBusEventLoop dbus_event_loop;
+    std::thread dbus_loop_thread;
+    std::mutex keep_display_on_mutex;
+    std::unordered_multimap<std::string,int32_t> keep_display_on_ids;
+    int32_t request_id;
+};
+
+}
+
+#endif

=== added file 'src/window_manager.cpp'
--- src/window_manager.cpp	1970-01-01 00:00:00 +0000
+++ src/window_manager.cpp	2015-05-06 16:09:34 +0000
@@ -0,0 +1,234 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored By: Alan Griffiths <[e-mail]>
+ */
+
+#include "window_manager.h"
+
+#include "session_switcher.h"
+
+#include "mir/geometry/rectangle.h"
+#include "mir/scene/null_surface_observer.h"
+#include "mir/scene/session.h"
+#include "mir/scene/session_coordinator.h"
+#include "mir/scene/surface.h"
+#include "mir/scene/surface_creation_parameters.h"
+#include "mir/shell/display_layout.h"
+#include "mir/shell/focus_controller.h"
+#include "mir/shell/surface_specification.h"
+
+#include "mir_toolkit/client_types.h"
+
+#include <iostream>
+
+namespace mf = mir::frontend;
+namespace ms = mir::scene;
+namespace msh = mir::shell;
+
+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
+    {
+        auto const surface = scene_session->default_surface();
+        focus_controller.raise({surface});
+        focus_controller.set_focus_to(scene_session, surface);
+    }
+
+    bool corresponds_to(mir::frontend::Session const* s) override
+    {
+        return scene_session.get() == s;
+    }
+
+    std::shared_ptr<ms::Session> const scene_session;
+    msh::FocusController& focus_controller;
+};
+
+
+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::WindowManager::WindowManager(
+    mir::shell::FocusController* focus_controller,
+    std::shared_ptr<mir::shell::DisplayLayout> const& display_layout,
+    std::shared_ptr<ms::SessionCoordinator> const& session_coordinator,
+    std::shared_ptr<SessionSwitcher> const& session_switcher) :
+    focus_controller{focus_controller},
+    display_layout{display_layout},
+    session_coordinator{session_coordinator},
+    session_switcher{session_switcher}
+{
+}
+
+void usc::WindowManager::add_session(std::shared_ptr<ms::Session> const& session)
+{
+    std::cerr << "Opening session " << session->name() << std::endl;
+
+    focus_controller->set_focus_to(session, {});
+
+    auto const usc_session = std::make_shared<UscSession>(session, *focus_controller);
+
+    session_switcher->add(usc_session, session->process_id());
+}
+
+void usc::WindowManager::remove_session(std::shared_ptr<ms::Session> const& session)
+{
+    std::cerr << "Closing session " << session->name() << std::endl;
+
+    auto const next_session = session_coordinator->successor_of({});
+    if (next_session)
+        focus_controller->set_focus_to(next_session, next_session->default_surface());
+    else
+        focus_controller->set_focus_to(next_session, {});
+
+    session_switcher->remove(session);
+}
+
+auto usc::WindowManager::add_surface(
+    std::shared_ptr<ms::Session> const& session,
+    ms::SurfaceCreationParameters const& params,
+    std::function<mf::SurfaceId(std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const& params)> const& build)
+-> mf::SurfaceId
+{
+    mir::graphics::DisplayConfigurationOutputId const output_id_invalid{
+        mir_display_output_id_invalid};
+    auto placed_parameters = params;
+
+    mir::geometry::Rectangle rect{params.top_left, params.size};
+
+    if (params.output_id != output_id_invalid)
+    {
+        display_layout->place_in_output(params.output_id, rect);
+    }
+
+    placed_parameters.top_left = rect.top_left;
+    placed_parameters.size = rect.size;
+
+    auto const result = build(session, placed_parameters);
+    auto const surface = session->surface(result);
+
+    auto const session_ready_observer = std::make_shared<SessionReadyObserver>(
+        session_switcher, surface, session.get());
+
+    surface->add_observer(session_ready_observer);
+
+    return result;
+}
+
+void usc::WindowManager::modify_surface(
+    std::shared_ptr<ms::Session> const& /*session*/,
+    std::shared_ptr<ms::Surface> const& surface,
+    msh::SurfaceSpecification const& modifications)
+{
+    if (modifications.name.is_set())
+        surface->rename(modifications.name.value());
+}
+
+void usc::WindowManager::remove_surface(
+    std::shared_ptr<ms::Session> const& /*session*/,
+    std::weak_ptr<ms::Surface> const& /*surface*/)
+{
+}
+
+void usc::WindowManager::add_display(mir::geometry::Rectangle const& /*area*/)
+{
+}
+
+void usc::WindowManager::remove_display(mir::geometry::Rectangle const& /*area*/)
+{
+}
+
+bool usc::WindowManager::handle_keyboard_event(MirKeyboardEvent const* /*event*/)
+{
+    return false;
+}
+
+bool usc::WindowManager::handle_touch_event(MirTouchEvent const* /*event*/)
+{
+    return false;
+}
+
+bool usc::WindowManager::handle_pointer_event(MirPointerEvent const* /*event*/)
+{
+    return false;
+}
+
+int usc::WindowManager::set_surface_attribute(
+    std::shared_ptr<ms::Session> const& /*session*/,
+    std::shared_ptr<ms::Surface> const& surface,
+    MirSurfaceAttrib attrib,
+    int value)
+{
+    return surface->configure(attrib, value);
+}

=== added file 'src/window_manager.h'
--- src/window_manager.h	1970-01-01 00:00:00 +0000
+++ src/window_manager.h	2015-05-06 16:09:34 +0000
@@ -0,0 +1,85 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored By: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef USC_WINDOW_MANAGER_H_
+#define USC_WINDOW_MANAGER_H_
+
+#include <mir/shell/window_manager.h>
+
+namespace mir
+{
+namespace scene { class PlacementStrategy; class SessionCoordinator; }
+namespace shell { class FocusController; class DisplayLayout; }
+}
+
+namespace usc
+{
+class SessionSwitcher;
+
+class WindowManager : public mir::shell::WindowManager
+{
+public:
+    explicit WindowManager(
+        mir::shell::FocusController* focus_controller,
+        std::shared_ptr<mir::shell::DisplayLayout> const& display_layout,
+        std::shared_ptr<mir::scene::SessionCoordinator> const& session_coordinator,
+        std::shared_ptr<SessionSwitcher> const& session_switcher);
+
+    void add_session(std::shared_ptr<mir::scene::Session> const& session) override;
+
+    void remove_session(std::shared_ptr<mir::scene::Session> const& session) override;
+
+    mir::frontend::SurfaceId add_surface(
+        std::shared_ptr<mir::scene::Session> const& session,
+        mir::scene::SurfaceCreationParameters const& params,
+        std::function<mir::frontend::SurfaceId(std::shared_ptr<mir::scene::Session> const& session, mir::scene::SurfaceCreationParameters const& params)> const& build) override;
+
+    void modify_surface(
+        std::shared_ptr<mir::scene::Session> const& session,
+        std::shared_ptr<mir::scene::Surface> const& surface,
+        mir::shell::SurfaceSpecification const& modifications) override;
+
+    void remove_surface(
+        std::shared_ptr<mir::scene::Session> const& session,
+        std::weak_ptr<mir::scene::Surface> const& surface) override;
+
+    void add_display(mir::geometry::Rectangle const& area) override;
+
+    void remove_display(mir::geometry::Rectangle const& area) override;
+
+    bool handle_keyboard_event(MirKeyboardEvent const* event) override;
+
+    bool handle_touch_event(MirTouchEvent const* event) override;
+
+    bool handle_pointer_event(MirPointerEvent const* event) override;
+
+    int set_surface_attribute(
+        std::shared_ptr<mir::scene::Session> const& session,
+        std::shared_ptr<mir::scene::Surface> const& surface,
+        MirSurfaceAttrib attrib,
+        int value) override;
+
+private:
+    mir::shell::FocusController* const focus_controller;
+    std::shared_ptr<mir::shell::DisplayLayout> const display_layout;
+    std::shared_ptr<mir::scene::SessionCoordinator> const session_coordinator;
+    std::shared_ptr<SessionSwitcher> const session_switcher;
+};
+}
+
+#endif /* USC_WINDOW_MANAGER_H_ */

=== removed file 'src/worker_thread.cpp'
--- src/worker_thread.cpp	2015-01-05 23:05:48 +0000
+++ src/worker_thread.cpp	1970-01-01 00:00:00 +0000
@@ -1,142 +0,0 @@
-/*
- * 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: Alberto Aguirre <[e-mail]>
- */
-
-#include "worker_thread.h"
-
-#include <mir/terminate_with_current_exception.h>
-
-#include <algorithm>
-#include <condition_variable>
-#include <deque>
-#include <map>
-
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-#include <pthread.h>
-
-namespace usc
-{
-
-class Worker
-{
-public:
-    explicit Worker(std::string name)
-        : name{name.substr(0, 15)}, exiting{false}
-    {
-    }
-
-    ~Worker()
-    {
-        exit();
-    }
-
-    void operator()() noexcept
-    try
-    {
-       pthread_setname_np(pthread_self(), name.c_str());
-
-       std::unique_lock<std::mutex> lock{state_mutex};
-       while (!exiting)
-       {
-           task_available_cv.wait(lock, [&]{ return exiting || !tasks.empty(); });
-
-           if (!exiting)
-           {
-               auto& task = tasks.front();
-
-               lock.unlock();
-               task();
-               lock.lock();
-               tasks.pop_front();
-           }
-       }
-    }
-    catch(...)
-    {
-        mir::terminate_with_current_exception();
-    }
-
-    void queue_task(std::function<void()> task)
-    {
-        std::lock_guard<std::mutex> lock{state_mutex};
-        tasks.push_back(std::move(task));
-        task_available_cv.notify_one();
-    }
-
-    void queue_task(std::function<void()> task, int id)
-    {
-        std::lock_guard<std::mutex> lock{state_mutex};
-        coalesced_tasks[id] = task;
-        tasks.push_back([this, id]{ run_coalesced_task(id);});
-        task_available_cv.notify_one();
-    }
-
-    void run_coalesced_task(int id)
-    {
-        std::unique_lock<std::mutex> lock{state_mutex};
-        auto it = coalesced_tasks.find(id);
-        if (it != coalesced_tasks.end())
-        {
-            auto task = it->second;
-            coalesced_tasks.erase(it);
-            lock.unlock();
-            task();
-        }
-    }
-
-    void exit()
-    {
-        std::lock_guard<std::mutex> lock{state_mutex};
-        exiting = true;
-        task_available_cv.notify_one();
-    }
-
-private:
-    std::mutex mutable state_mutex;
-    std::string name;
-    bool exiting;
-    std::map<int, std::function<void()>> coalesced_tasks;
-    std::deque<std::function<void()>> tasks;
-    std::condition_variable task_available_cv;
-};
-
-}
-
-usc::WorkerThread::WorkerThread(std::string name)
-    : worker{new Worker(name)},
-      thread{std::ref(*worker)}
-{
-}
-
-usc::WorkerThread::~WorkerThread()
-{
-    worker->exit();
-    if (thread.joinable())
-        thread.join();
-}
-
-void usc::WorkerThread::queue_task(std::function<void()> task)
-{
-    worker->queue_task(std::move(task));
-}
-
-void usc::WorkerThread::queue_task(std::function<void()> task, int id)
-{
-    worker->queue_task(std::move(task), id);
-}

=== removed file 'src/worker_thread.h'
--- src/worker_thread.h	2014-10-22 19:31:57 +0000
+++ src/worker_thread.h	1970-01-01 00:00:00 +0000
@@ -1,55 +0,0 @@
-/*
- * 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: Alberto Aguirre <[e-mail]>
- */
-
-#ifndef USC_WORKER_THREAD_H_
-#define USC_WORKER_THREAD_H_
-
-#include <memory>
-#include <string>
-#include <thread>
-
-namespace usc
-{
-class Worker;
-class WorkerThread
-{
-public:
-    explicit WorkerThread(std::string name);
-    ~WorkerThread();
-
-    /**
-     * Queues a task to be executed on the worker thread
-     */
-    void queue_task(std::function<void()> task);
-
-    /**
-     * Queues and coalesces tasks that share the same id
-     */
-    void queue_task(std::function<void()> task, int id);
-
-private:
-    WorkerThread(WorkerThread const&) = delete;
-    WorkerThread& operator=(WorkerThread const&) = delete;
-
-    std::unique_ptr<Worker> worker;
-    std::thread thread;
-};
-
-}
-
-#endif

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-07-09 06:58:05 +0000
+++ tests/CMakeLists.txt	2015-05-06 16:09:34 +0000
@@ -15,3 +15,4 @@
 # Authored by: Alexandros Frantzis <[e-mail]>
 
 add_subdirectory(unit-tests/)
+add_subdirectory(integration-tests/)

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

=== added file 'tests/integration-tests/dbus_bus.cpp'
--- tests/integration-tests/dbus_bus.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/dbus_bus.cpp	2015-05-06 16:09:34 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.