Merge lp:~kdub/unity-system-compositor/nochange-rebuild into lp:unity-system-compositor/0.2

[Kevin DuBois]

do not land: no change rebuild to test a mir corruption fix that breaks abi

do not land: no change rebuild to test a mir corruption fix that breaks abi

[lp:~kdub/unity-system-compositor/nochange-rebuild]

259. By Andreas Pokorny on 2015-12-01

follow the deprecation warning and use tobytes instead of tostring.

Approved by PS Jenkins bot.

260. By Andreas Pokorny on 2015-12-01

do not premultiply RGB images

python would raise an exception if we attempt to access pixel[x,y][3] on a RGB image.
.

Approved by PS Jenkins bot.

261. By Andrea Cimitan on 2015-12-01

Updated wallpaper for spinner from unity8.

Approved by PS Jenkins bot, Andreas Pokorny.

262. By Andreas Pokorny on 2015-12-01

Change keyboard handling to scan codes.

Additionally relevant for ubuntu-pd: use none-phone keys to keep display on. Fixes: https://bugs.launchpad.net/bugs/1514059, https://bugs.launchpad.net/bugs/1520422.

Approved by Alexandros Frantzis, PS Jenkins bot.

263. By Andreas Pokorny on 2015-12-01

Catch all devices with pointer or touchpad capabilities and forward input configuration changes to them.

Approved by Alexandros Frantzis, PS Jenkins bot.

264. By Andreas Pokorny on 2015-12-07

Use actual image.bytes_per_pixel to decide about GL format of pixel data.

Approved by Alexandros Frantzis, PS Jenkins bot, Kevin DuBois.

265. By Andreas Pokorny on 2016-01-19

merge updated change log and version

266. By Andreas Pokorny on 2016-01-20

Move Mocks around and integration test utilities to reuse them in further tests.

Approved by Alexandros Frantzis, PS Jenkins bot.

267. By Andreas Pokorny on 2016-01-20

Split out the single DBusConnectionHandle from DBusConnectionThread

This allows having multiple connection names that actually work. As opposed to assigning multiple connection names to a single DBusConnection, in which case the first one wins. Fixes: https://bugs.launchpad.net/bugs/1536383.

Approved by PS Jenkins bot, Alexandros Frantzis.

268. By Michael Terry on 2016-01-21

Properly clamp mouseCursorSpeed and touchpadCursorSpeed settings.

Approved by PS Jenkins bot, Andreas Pokorny.

269. By Alexandros Frantzis on 2016-01-21

Unblank the screen when a pointer or key event arrives. Fixes: https://bugs.launchpad.net/bugs/1488413.

Approved by Andreas Pokorny, PS Jenkins bot.

270. By Kevin DuBois on 2016-01-25

bump changelog for no change rebuild

271. By Kevin DuBois on 2016-01-27

 update changelog after 0.3 landing

Unmerged revisions

271. By Kevin DuBois on 2016-01-27

 update changelog after 0.3 landing

270. By Kevin DuBois on 2016-01-25

bump changelog for no change rebuild

269. By Alexandros Frantzis on 2016-01-21

Unblank the screen when a pointer or key event arrives. Fixes: https://bugs.launchpad.net/bugs/1488413.

Approved by Andreas Pokorny, PS Jenkins bot.

268. By Michael Terry on 2016-01-21

Properly clamp mouseCursorSpeed and touchpadCursorSpeed settings.

Approved by PS Jenkins bot, Andreas Pokorny.

267. By Andreas Pokorny on 2016-01-20

Split out the single DBusConnectionHandle from DBusConnectionThread

This allows having multiple connection names that actually work. As opposed to assigning multiple connection names to a single DBusConnection, in which case the first one wins. Fixes: https://bugs.launchpad.net/bugs/1536383.

Approved by PS Jenkins bot, Alexandros Frantzis.

266. By Andreas Pokorny on 2016-01-20

Move Mocks around and integration test utilities to reuse them in further tests.

Approved by Alexandros Frantzis, PS Jenkins bot.

265. By Andreas Pokorny on 2016-01-19

merge updated change log and version

264. By Andreas Pokorny on 2015-12-07

Use actual image.bytes_per_pixel to decide about GL format of pixel data.

Approved by Alexandros Frantzis, PS Jenkins bot, Kevin DuBois.

263. By Andreas Pokorny on 2015-12-01

Catch all devices with pointer or touchpad capabilities and forward input configuration changes to them.

Approved by Alexandros Frantzis, PS Jenkins bot.

262. By Andreas Pokorny on 2015-12-01

Change keyboard handling to scan codes.

Additionally relevant for ubuntu-pd: use none-phone keys to keep display on. Fixes: https://bugs.launchpad.net/bugs/1514059, https://bugs.launchpad.net/bugs/1520422.

Approved by Alexandros Frantzis, PS Jenkins bot.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-10-08 09:54:02 +0000
+++ CMakeLists.txt	2016-01-27 14:14:14 +0000
@@ -16,8 +16,8 @@
 
 project(UnitySystemCompositor)
 set(USC_VERSION_MAJOR 0)
-set(USC_VERSION_MINOR 2)
-set(USC_VERSION_PATCH 0)
+set(USC_VERSION_MINOR 3)
+set(USC_VERSION_PATCH 1)
 set(USC_VERSION "${USC_VERSION_MAJOR}.${USC_VERSION_MINOR}.${USC_VERSION_PATCH}")
 
 cmake_minimum_required(VERSION 2.8)
@@ -35,7 +35,7 @@
 
 # Use C++11 and warnings
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11 -Wall")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -Wall")
 
 find_package(PkgConfig)
 pkg_check_modules(ANDROIDPROPS libandroid-properties)
@@ -57,6 +57,7 @@
 
 if (MIR_ENABLE_TESTS)
   find_package(Gtest REQUIRED)
+  include_directories(${MIRCLIENT_INCLUDE_DIRS} )
   include_directories(${GMOCK_INCLUDE_DIR} ${GTEST_INCLUDE_DIR})
   add_subdirectory(tests/)
 endif ()

=== modified file 'debian/changelog'
--- debian/changelog	2015-11-16 15:36:56 +0000
+++ debian/changelog	2016-01-27 14:14:14 +0000
@@ -1,6 +1,65 @@
-unity-system-compositor (0.2.0+15.10.20151008.1-0ubuntu1) wily; urgency=medium
-
-  [ Alexandros Frantzis ]
+<<<<<<< TREE
+unity-system-compositor (0.2.0+15.10.20151008.1-0ubuntu1) wily; urgency=medium
+
+  [ Alexandros Frantzis ]
+=======
+unity-system-compositor (0.3.1+16.04.20160121-0ubuntu2) UNRELEASED; urgency=medium
+
+  * no change rebuild for mir 0.18.2
+
+ -- Kevin DuBois <[e-mail]>  Wed, 27 Jan 2016 09:12:35 -0500
+
+unity-system-compositor (0.3.1+16.04.20160121-0ubuntu1) xenial; urgency=medium
+
+  [ Alexandros Frantzis ]
+  * Unblank the screen when a pointer or key event arrives. (LP: #1488413)
+
+  [ Andreas Pokorny ]
+  * Implement a DBus interface for setting pointer speed/acceleration.
+    (LP: #1536383)
+
+ -- Alexandros Frantzis <[e-mail]>  Thu, 21 Jan 2016 19:27:33 +0200
+
+unity-system-compositor (0.2.0+16.04.20151222.1-0ubuntu1) xenial; urgency=medium
+
+  [ Alexandros Frantzis ]
+  * tests: Fix build failure with gcc-4.9
+
+  [ Andrea Cimitan ]
+  * Updated wallpaper for spinner from unity8.
+
+  [ Andreas Pokorny ]
+  * Add clone method to StubdisplayConfigurations
+  * Change keyboard handling to scan codes. (LP: #1514059, #1520422)
+  * do not premultiply RGB images
+  * follow the deprecation warning and use tobytes instead of tostring.
+
+  [ Kevin DuBois ]
+  * Accommodate RGB images (LP: #1528279)
+  * Accommodate RGB images (LP: #1528279)
+
+ -- Kevin DuBois <[e-mail]>  Tue, 22 Dec 2015 19:09:40 +0000
+
+unity-system-compositor (0.2.0+16.04.20151216.1-0ubuntu1) xenial; urgency=medium
+
+  [ Alexandros Frantzis ]
+  * Merge trunk into 0.3.0
+
+  [ Andrea Cimitan ]
+  * Merge trunk into 0.3.0
+
+  [ Andreas Pokorny ]
+  * Merge trunk into 0.3.0
+
+  [ Kevin DuBois ]
+  * Merge trunk into 0.3.0
+
+ -- Kevin DuBois <[e-mail]>  Wed, 16 Dec 2015 22:44:38 +0000
+
+unity-system-compositor (0.2.0+15.10.20151008.1-0ubuntu1) wily; urgency=medium
+
+  [ Alexandros Frantzis ]
+>>>>>>> MERGE-SOURCE
   * Use new versions of mir::event::make_event() overloads.
   * Rebuild for Mir 0.17.
 

=== modified file 'spinner/eglspinner.cpp'
--- spinner/eglspinner.cpp	2015-06-30 12:04:53 +0000
+++ spinner/eglspinner.cpp	2016-01-27 14:14:14 +0000
@@ -150,14 +150,17 @@
 void uploadTexture (GLuint id, Image& image)
 {
     glBindTexture(GL_TEXTURE_2D, id);
+    GLint format = GL_RGBA;
+    if (image.bytes_per_pixel == 3)
+        format = GL_RGB;
 
     glTexImage2D(GL_TEXTURE_2D,
                  0,
-                 GL_RGBA,
+                 format,
                  image.width,
                  image.height,
                  0,
-                 GL_RGBA,
+                 format,
                  GL_UNSIGNED_BYTE,
                  image.pixel_data);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

=== modified file 'spinner/wallpaper.png'
Binary files spinner/wallpaper.png	2015-07-03 11:43:24 +0000 and spinner/wallpaper.png	2016-01-27 14:14:14 +0000 differ
=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-08-29 14:38:35 +0000
+++ src/CMakeLists.txt	2016-01-27 14:14:14 +0000
@@ -72,6 +72,7 @@
   ${Boost_INCLUDE_DIRS}
   ${GLESv2_INCLUDE_DIRS}
   ${MIRSERVER_INCLUDE_DIRS}
+  ${MIRCLIENT_INCLUDE_DIRS}
   ${DBUS_INCLUDE_DIRS}
 )
 add_definitions(

=== modified file 'src/dbus_connection_handle.cpp'
--- src/dbus_connection_handle.cpp	2015-03-18 12:20:58 +0000
+++ src/dbus_connection_handle.cpp	2016-01-27 14:14:14 +0000
@@ -22,12 +22,12 @@
 #include <stdexcept>
 #include <boost/throw_exception.hpp>
 
-usc::DBusConnectionHandle::DBusConnectionHandle(const char* address)
+usc::DBusConnectionHandle::DBusConnectionHandle(std::string const& address)
 {
     dbus_threads_init_default();
     ScopedDBusError error;
 
-    connection = dbus_connection_open_private(address, &error);
+    connection = dbus_connection_open_private(address.c_str(), &error);
     if (!connection || error)
     {
         BOOST_THROW_EXCEPTION(

=== modified file 'src/dbus_connection_handle.h'
--- src/dbus_connection_handle.h	2015-03-17 18:17:14 +0000
+++ src/dbus_connection_handle.h	2016-01-27 14:14:14 +0000
@@ -21,13 +21,15 @@
 
 #include <dbus/dbus.h>
 
+#include <string>
+
 namespace usc
 {
 
 class DBusConnectionHandle
 {
 public:
-    DBusConnectionHandle(char const* address);
+    DBusConnectionHandle(std::string const& address);
     ~DBusConnectionHandle();
 
     void request_name(char const* name) const;

=== modified file 'src/dbus_connection_thread.cpp'
--- src/dbus_connection_thread.cpp	2015-08-25 14:27:23 +0000
+++ src/dbus_connection_thread.cpp	2016-01-27 14:14:14 +0000
@@ -17,11 +17,10 @@
  */
 
 #include "dbus_connection_thread.h"
+#include "dbus_event_loop.h"
 #include "thread_name.h"
 
-usc::DBusConnectionThread::DBusConnectionThread(std::string const& address)
-    : dbus_connection{address.c_str()},
-      dbus_event_loop{dbus_connection}
+usc::DBusConnectionThread::DBusConnectionThread(std::shared_ptr<DBusEventLoop> const& loop) : dbus_event_loop(loop)
 {
     std::promise<void> event_loop_started;
     auto event_loop_started_future = event_loop_started.get_future();
@@ -30,7 +29,7 @@
         [this,&event_loop_started]
         {
             usc::set_thread_name("USC/DBus");
-            dbus_event_loop.run(event_loop_started);
+            dbus_event_loop->run(event_loop_started);
         });
 
     event_loop_started_future.wait();
@@ -38,16 +37,11 @@
 
 usc::DBusConnectionThread::~DBusConnectionThread()
 {
-    dbus_event_loop.stop();
+    dbus_event_loop->stop();
     dbus_loop_thread.join();
 }
 
-usc::DBusConnectionHandle const& usc::DBusConnectionThread::connection() const
-{
-    return dbus_connection;
-}
-
 usc::DBusEventLoop & usc::DBusConnectionThread::loop()
 {
-    return dbus_event_loop;
+    return *dbus_event_loop;
 }

=== modified file 'src/dbus_connection_thread.h'
--- src/dbus_connection_thread.h	2015-08-25 14:27:23 +0000
+++ src/dbus_connection_thread.h	2016-01-27 14:14:14 +0000
@@ -19,25 +19,21 @@
 #ifndef USC_DBUS_CONNECTION_THREAD_H_
 #define USC_DBUS_CONNECTION_THREAD_H_
 
-#include "dbus_connection_handle.h"
-#include "dbus_event_loop.h"
-
 #include <thread>
 
 namespace usc
 {
 
+class DBusEventLoop;
 class DBusConnectionThread
 {
 public:
-    DBusConnectionThread(std::string const& address);
+    DBusConnectionThread(std::shared_ptr<DBusEventLoop> const& thread);
     ~DBusConnectionThread();
-    DBusConnectionHandle const& connection() const;
     DBusEventLoop & loop();
 
 private:
-    DBusConnectionHandle dbus_connection;
-    DBusEventLoop dbus_event_loop;
+    std::shared_ptr<DBusEventLoop> dbus_event_loop;
     std::thread dbus_loop_thread;
 };
 

=== modified file 'src/dbus_event_loop.cpp'
--- src/dbus_event_loop.cpp	2015-03-18 12:20:58 +0000
+++ src/dbus_event_loop.cpp	2016-01-27 14:14:14 +0000
@@ -21,6 +21,7 @@
 #endif
 
 #include "dbus_event_loop.h"
+#include "dbus_connection_handle.h"
 
 #include <algorithm>
 
@@ -78,9 +79,8 @@
 
 }
 
-usc::DBusEventLoop::DBusEventLoop(DBusConnection* connection)
-    : connection{connection},
-      running{false},
+usc::DBusEventLoop::DBusEventLoop()
+    : running{false},
       epoll_fd{epoll_create1(EPOLL_CLOEXEC)}
 {
     if (epoll_fd == -1)
@@ -109,9 +109,17 @@
         BOOST_THROW_EXCEPTION(
             std::system_error(errno, std::system_category(), "epoll_ctl"));
     }
+}
+
+void usc::DBusEventLoop::add_connection(std::shared_ptr<DBusConnectionHandle> const& connection)
+{
+    if (running)
+        BOOST_THROW_EXCEPTION(std::logic_error("Connection added after dbus event loop started"));
+
+    connections.push_back(connection);
 
     dbus_connection_set_watch_functions(
-        connection,
+        *connection,
         DBusEventLoop::static_add_watch,
         DBusEventLoop::static_remove_watch,
         DBusEventLoop::static_toggle_watch,
@@ -119,7 +127,7 @@
         nullptr);
 
     dbus_connection_set_timeout_functions(
-        connection,
+        *connection,
         DBusEventLoop::static_add_timeout,
         DBusEventLoop::static_remove_timeout,
         DBusEventLoop::static_toggle_timeout,
@@ -127,7 +135,7 @@
         nullptr);
 
     dbus_connection_set_wakeup_main_function(
-        connection,
+        *connection,
         DBusEventLoop::static_wake_up_loop,
         this, nullptr);
 }
@@ -136,14 +144,17 @@
 {
     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);
+    for(auto connection : connections)
+    {
+        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)
@@ -187,14 +198,17 @@
 
         dispatch_actions();
 
-        dbus_connection_flush(connection);
+        for (auto connection : connections)
+        {
+            dbus_connection_flush(*connection);
 
-        while (dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS)
-            continue;
+            while (dbus_connection_dispatch(*connection) == DBUS_DISPATCH_DATA_REMAINS);
+        }
     }
 
     // Flush any remaining outgoing messages
-    dbus_connection_flush(connection);
+    for (auto connection : connections)
+        dbus_connection_flush(*connection);
 }
 
 void usc::DBusEventLoop::stop()

=== modified file 'src/dbus_event_loop.h'
--- src/dbus_event_loop.h	2015-03-18 11:56:28 +0000
+++ src/dbus_event_loop.h	2016-01-27 14:14:14 +0000
@@ -30,13 +30,15 @@
 
 namespace usc
 {
+class DBusConnectionHandle;
 
 class DBusEventLoop
 {
 public:
-    DBusEventLoop(DBusConnection* connection);
+    DBusEventLoop();
     ~DBusEventLoop();
 
+    void add_connection(std::shared_ptr<DBusConnectionHandle> const& connection);
     void run(std::promise<void>& started);
     void stop();
 
@@ -70,10 +72,10 @@
     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<std::shared_ptr<DBusConnectionHandle>> connections;
     std::vector<DBusWatch*> watches;
     std::vector<std::pair<DBusTimeout*,mir::Fd>> timeouts;
     std::vector<std::function<void(void)>> actions;

=== modified file 'src/mir_input_configuration.cpp'
--- src/mir_input_configuration.cpp	2015-08-26 08:26:35 +0000
+++ src/mir_input_configuration.cpp	2016-01-27 14:14:14 +0000
@@ -15,58 +15,173 @@
  */
 
 #include "mir_input_configuration.h"
-
-// just a stub at the moment, this implementation will be supposed to
-// observe available input devices and apply settings to it.
-
+#include "mir/input/input_device_observer.h"
+#include "mir/input/input_device_hub.h"
+#include "mir/input/pointer_configuration.h"
+#include "mir/input/touchpad_configuration.h"
+#include "mir/input/device.h"
+
+namespace mi = mir::input;
+
+namespace
+{
+struct DeviceObserver : mi::InputDeviceObserver
+{
+    usc::MirInputConfiguration* conf;
+    DeviceObserver(usc::MirInputConfiguration* conf)
+        : conf{conf}
+    {
+    }
+
+    void device_added(std::shared_ptr<mi::Device> const& device) override
+    {
+        conf->device_added(device);
+    }
+
+    void device_changed(std::shared_ptr<mi::Device> const&) override
+    {
+    }
+
+    void device_removed(std::shared_ptr<mi::Device> const&device) override
+    {
+        conf->device_removed(device);
+    }
+
+    void changes_complete() override
+    {
+    }
+};
+}
+
+
+usc::MirInputConfiguration::MirInputConfiguration(std::shared_ptr<mi::InputDeviceHub> const& device_hub) :
+    observer{std::make_shared<DeviceObserver>(this)}
+{
+    device_hub->add_observer(observer);
+}
+
+void usc::MirInputConfiguration::device_removed(std::shared_ptr<mi::Device> const& dev)
+{
+    std::lock_guard<decltype(devices_lock)> lock(devices_lock);
+    touchpads.erase(dev);
+    mice.erase(dev);
+}
+
+void usc::MirInputConfiguration::configure_mouse(mi::Device& dev)
+{
+    dev.apply_pointer_configuration(mouse_pointer_config);
+}
+
+void usc::MirInputConfiguration::configure_touchpad(mi::Device& dev)
+{
+    dev.apply_pointer_configuration(touchpad_pointer_config);
+    dev.apply_touchpad_configuration(touchpad_config);
+}
+
+void usc::MirInputConfiguration::device_added(std::shared_ptr<mi::Device> const& dev)
+{
+    std::lock_guard<decltype(devices_lock)> lock(devices_lock);
+
+    if (contains(dev->capabilities(), mi::DeviceCapability::touchpad))
+    {
+        touchpads.insert(dev);
+        configure_touchpad(*dev);
+    }
+    else if (contains(dev->capabilities(), mi::DeviceCapability::pointer))
+    {
+        mice.insert(dev);
+        configure_mouse(*dev);
+    }
+}
+
+void usc::MirInputConfiguration::update_touchpads()
+{
+    for (auto const& touchpad : touchpads)
+        configure_touchpad(*touchpad);
+}
+
+void usc::MirInputConfiguration::update_mice()
+{
+    for (auto const& mouse : mice)
+        configure_mouse(*mouse);
+}
 
 void usc::MirInputConfiguration::set_mouse_primary_button(int32_t button)
 {
-    mouse_primary_button = button;
+    mouse_pointer_config.handedness = button == 0 ?
+        mir_pointer_handedness_right :
+        mir_pointer_handedness_left;
+    update_mice();
 }
 
 void usc::MirInputConfiguration::set_mouse_cursor_speed(double speed)
 {
-    mouse_cursor_speed = speed;
+    double clamped = speed;
+    if (clamped < 0.0)
+        clamped = 0.0;
+    if (clamped > 1.0)
+        clamped = 1.0;
+    mouse_pointer_config.cursor_acceleration_bias = clamped * 2.0 - 1.0;
+    update_mice();
 }
 
 void usc::MirInputConfiguration::set_mouse_scroll_speed(double speed)
 {
-    mouse_scroll_speed = speed;
+    mouse_pointer_config.horizontal_scroll_scale = speed;
+    mouse_pointer_config.vertical_scroll_scale = speed;
+    update_mice();
 }
 
 void usc::MirInputConfiguration::set_touchpad_primary_button(int32_t button)
 {
-    touchpad_primary_button = button;
+    touchpad_pointer_config.handedness = button == 0?mir_pointer_handedness_right:mir_pointer_handedness_left;
+    update_touchpads();
 }
 
 void usc::MirInputConfiguration::set_touchpad_cursor_speed(double speed)
 {
-    touchpad_cursor_speed = speed;
+    double clamped = speed;
+    if (clamped < 0.0)
+        clamped = 0.0;
+    if (clamped > 1.0)
+        clamped = 1.0;
+    touchpad_pointer_config.cursor_acceleration_bias = clamped * 2.0 - 1.0;
+    update_touchpads();
 }
 
 void usc::MirInputConfiguration::set_touchpad_scroll_speed(double speed)
 {
-    touchpad_scroll_speed = speed;
+    touchpad_pointer_config.horizontal_scroll_scale = speed;
+    touchpad_pointer_config.vertical_scroll_scale = speed;
+    update_touchpads();
 }
 
 void usc::MirInputConfiguration::set_two_finger_scroll(bool enable)
 {
-    two_finger_scroll = enable;
+    MirTouchpadScrollModes current = touchpad_config.scroll_mode;
+    if (enable)
+        current |= mir_touchpad_scroll_mode_two_finger_scroll;
+    else
+        current &= ~mir_touchpad_scroll_mode_two_finger_scroll;
+    touchpad_config.scroll_mode = current;
+    update_touchpads();
 }
 
 void usc::MirInputConfiguration::set_tap_to_click(bool enable)
 {
-    tap_to_click = enable;
+    touchpad_config.tap_to_click = enable;
+    update_touchpads();
 }
 
 void usc::MirInputConfiguration::set_disable_touchpad_while_typing(bool enable)
 {
-    disable_while_typing = enable;
+    touchpad_config.disable_while_typing = enable;
+    update_touchpads();
 }
 
 void usc::MirInputConfiguration::set_disable_touchpad_with_mouse(bool enable)
 {
-    disable_with_mouse = enable;
+    touchpad_config.disable_with_mouse = enable;
+    update_touchpads();
 }
 

=== modified file 'src/mir_input_configuration.h'
--- src/mir_input_configuration.h	2015-08-26 08:26:35 +0000
+++ src/mir_input_configuration.h	2016-01-27 14:14:14 +0000
@@ -14,18 +14,36 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #ifndef USC_MIR_INPUT_CONFIGRATION_H_
 #define USC_MIR_INPUT_CONFIGRATION_H_
 
 #include "input_configuration.h"
 
+#include "mir/input/touchpad_configuration.h"
+#include "mir/input/pointer_configuration.h"
+
+#include <memory>
+#include <thread>
+#include <mutex>
+#include <unordered_set>
+
+namespace mir
+{
+namespace input
+{
+class InputDeviceHub;
+class Device;
+class InputDeviceObserver;
+}
+}
+
 namespace usc
 {
 
 struct MirInputConfiguration : InputConfiguration
 {
 public:
+    MirInputConfiguration(std::shared_ptr<mir::input::InputDeviceHub> const& device_hub);
     void set_mouse_primary_button(int32_t button) override;
     void set_mouse_cursor_speed(double speed) override;
     void set_mouse_scroll_speed(double speed) override;
@@ -36,17 +54,22 @@
     void set_tap_to_click(bool enable) override;
     void set_disable_touchpad_while_typing(bool enable) override;
     void set_disable_touchpad_with_mouse(bool enable) override;
+
+    void device_added(std::shared_ptr<mir::input::Device> const& device);
+    void device_removed(std::shared_ptr<mir::input::Device> const& device);
 private:
-    int32_t mouse_primary_button{0};
-    double mouse_cursor_speed{0.5};
-    double mouse_scroll_speed{0.5};
-    int32_t touchpad_primary_button{0};
-    double touchpad_cursor_speed{0.5};
-    double touchpad_scroll_speed{0.5};
-    bool two_finger_scroll{false};
-    bool tap_to_click{false};
-    bool disable_while_typing{false};
-    bool disable_with_mouse{true};
+    void configure_mouse(mir::input::Device& dev);
+    void configure_touchpad(mir::input::Device& dev);
+    void update_touchpads();
+    void update_mice();
+
+    std::shared_ptr<mir::input::InputDeviceObserver> const observer;
+    std::mutex devices_lock;
+    std::unordered_set<std::shared_ptr<mir::input::Device>> touchpads;
+    std::unordered_set<std::shared_ptr<mir::input::Device>> mice;
+    mir::input::PointerConfiguration mouse_pointer_config;
+    mir::input::PointerConfiguration touchpad_pointer_config;
+    mir::input::TouchpadConfiguration touchpad_config;
 };
 
 }

=== modified file 'src/powerd_mediator.cpp'
--- src/powerd_mediator.cpp	2015-07-17 12:43:46 +0000
+++ src/powerd_mediator.cpp	2016-01-27 14:14:14 +0000
@@ -45,8 +45,7 @@
 }
 
 usc::PowerdMediator::PowerdMediator(std::string const& bus_addr)
-    : connection{bus_addr.c_str()},
-      dbus_event_loop{connection},
+    : connection{std::make_shared<DBusConnectionHandle>(bus_addr.c_str())},
       pending_suspend_block_request{false},
       dim_brightness_{10},
       min_brightness_{0},
@@ -59,17 +58,18 @@
       proximity_enabled{false},
       sys_state{SysState::unknown}
 {
-    connection.add_match(
+    dbus_event_loop.add_connection(connection);
+    connection->add_match(
         "type='signal',"
         "sender='com.canonical.powerd',"
         "interface='com.canonical.powerd',"
         "member='SysPowerStateChange'");
-    connection.add_match(
+    connection->add_match(
         "type='signal',"
         "sender='org.freedesktop.DBus',"
         "interface='org.freedesktop.DBus',"
         "member='NameOwnerChanged'");
-    connection.add_filter(handle_dbus_message_thunk, this);
+    connection->add_filter(handle_dbus_message_thunk, this);
 
     std::promise<void> event_loop_started;
     auto event_loop_started_future = event_loop_started.get_future();
@@ -477,7 +477,7 @@
         [this, &msg, &reply_promise]
         {
             auto const reply = dbus_connection_send_with_reply_and_block(
-                connection, msg, DBUS_TIMEOUT_USE_DEFAULT, nullptr);
+                *connection, msg, DBUS_TIMEOUT_USE_DEFAULT, nullptr);
 
             reply_promise.set_value(reply);
         };

=== modified file 'src/powerd_mediator.h'
--- src/powerd_mediator.h	2015-07-17 12:43:46 +0000
+++ src/powerd_mediator.h	2016-01-27 14:14:14 +0000
@@ -88,7 +88,7 @@
     void invoke(char const* method, int first_arg_type, ...);
     usc::DBusMessageHandle invoke_with_reply(char const* method, int first_arg_type, ...);
 
-    usc::DBusConnectionHandle connection;
+    std::shared_ptr<usc::DBusConnectionHandle> connection;
     usc::DBusEventLoop dbus_event_loop;
     std::thread dbus_loop_thread;
 

=== modified file 'src/screen_event_handler.cpp'
--- src/screen_event_handler.cpp	2015-07-13 12:35:41 +0000
+++ src/screen_event_handler.cpp	2016-01-27 14:14:14 +0000
@@ -21,6 +21,7 @@
 #include <mir/time/alarm_factory.h>
 #include <mir_toolkit/events/input/input_event.h>
 
+#include "linux/input.h"
 #include <cstdio>
 
 usc::ScreenEventHandler::ScreenEventHandler(
@@ -45,8 +46,6 @@
 
 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;
 
@@ -56,21 +55,36 @@
     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();
+        if (mir_keyboard_event_scan_code(kev) == KEY_POWER)
+        {
+            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();
+        }
+        // we might want to come up with a whole range of media player related keys
+        else if (mir_keyboard_event_scan_code(kev) == KEY_VOLUMEDOWN||
+                 mir_keyboard_event_scan_code(kev) == KEY_VOLUMEUP)
+        {
+            // do not keep display on when interacting with media player
+        }
+        else
+        {
+            keep_or_turn_screen_on();
+        }
     }
-    else if (input_event_type == mir_input_event_type_touch ||
-             input_event_type == mir_input_event_type_pointer)
+    else if (input_event_type == mir_input_event_type_touch)
     {
         std::lock_guard<std::mutex> lock{guard};
         screen->keep_display_on_temporarily();
     }
+    else if (input_event_type == mir_input_event_type_pointer)
+    {
+        bool const filter_out_event = screen->get_screen_power_mode() != mir_power_mode_on;
+        keep_or_turn_screen_on();
+        return filter_out_event;
+    }
 
     return false;
 }
@@ -128,3 +142,18 @@
         MirPowerMode::mir_power_mode_on, PowerStateChangeReason::power_key);
     long_press_detected = true;
 }
+
+void usc::ScreenEventHandler::keep_or_turn_screen_on()
+{
+    std::lock_guard<std::mutex> lock{guard};
+
+    if (screen->get_screen_power_mode() == mir_power_mode_off)
+    {
+        screen->set_screen_power_mode(
+            MirPowerMode::mir_power_mode_on, PowerStateChangeReason::unknown);
+    }
+    else
+    {
+        screen->keep_display_on_temporarily();
+    }
+}

=== modified file 'src/screen_event_handler.h'
--- src/screen_event_handler.h	2015-04-29 14:39:19 +0000
+++ src/screen_event_handler.h	2016-01-27 14:14:14 +0000
@@ -56,6 +56,7 @@
     void power_key_down();
     void shutdown_alarm_notification();
     void long_press_notification();
+    void keep_or_turn_screen_on();
 
     std::mutex guard;
     std::shared_ptr<Screen> const screen;

=== modified file 'src/server.cpp'
--- src/server.cpp	2015-09-30 10:53:54 +0000
+++ src/server.cpp	2016-01-27 14:14:14 +0000
@@ -28,6 +28,7 @@
 #include "unity_screen_service.h"
 #include "unity_input_service.h"
 #include "dbus_connection_thread.h"
+#include "dbus_event_loop.h"
 #include "display_configuration_policy.h"
 #include "steady_clock.h"
 
@@ -241,7 +242,7 @@
     return input_configuration(
         [this]
         {
-            return std::make_shared<MirInputConfiguration>();
+            return std::make_shared<MirInputConfiguration>(the_input_device_hub());
         });
 }
 
@@ -292,12 +293,22 @@
         });
 }
 
+std::shared_ptr<usc::DBusEventLoop> usc::Server::the_dbus_event_loop()
+{
+    return dbus_loop(
+        [this]
+        {
+            return std::make_shared<DBusEventLoop>();
+        });
+
+}
+
 std::shared_ptr<usc::DBusConnectionThread> usc::Server::the_dbus_connection_thread()
 {
     return dbus_thread(
         [this]
         {
-            return std::make_shared<DBusConnectionThread>(dbus_bus_address());
+            return std::make_shared<DBusConnectionThread>(the_dbus_event_loop());
         });
 }
 
@@ -307,7 +318,8 @@
         [this]
         {
             return std::make_shared<UnityScreenService>(
-                    the_dbus_connection_thread(),
+                    the_dbus_event_loop(),
+                    dbus_bus_address(),
                     the_screen());
         });
 }
@@ -318,7 +330,8 @@
         [this]
         {
             return std::make_shared<UnityInputService>(
-                    the_dbus_connection_thread(),
+                    the_dbus_event_loop(),
+                    dbus_bus_address(),
                     the_input_configuration());
         });
 }

=== modified file 'src/server.h'
--- src/server.h	2015-09-30 10:53:54 +0000
+++ src/server.h	2016-01-27 14:14:14 +0000
@@ -45,6 +45,7 @@
 class InputConfiguration;
 class UnityInputService;
 class DBusConnectionThread;
+class DBusEventLoop;
 class Clock;
 
 class Server : private mir::Server
@@ -69,6 +70,7 @@
     virtual std::shared_ptr<ScreenHardware> the_screen_hardware();
     virtual std::shared_ptr<UnityScreenService> the_unity_screen_service();
     virtual std::shared_ptr<UnityInputService> the_unity_input_service();
+    virtual std::shared_ptr<DBusEventLoop> the_dbus_event_loop();
     virtual std::shared_ptr<DBusConnectionThread> the_dbus_connection_thread();
     virtual std::shared_ptr<Clock> the_clock();
 
@@ -182,6 +184,7 @@
     mir::CachedPtr<mir::input::EventFilter> screen_event_handler;
     mir::CachedPtr<ScreenHardware> screen_hardware;
     mir::CachedPtr<DBusConnectionThread> dbus_thread;
+    mir::CachedPtr<DBusEventLoop> dbus_loop;
     mir::CachedPtr<UnityScreenService> unity_screen_service;
     mir::CachedPtr<UnityInputService> unity_input_service;
     mir::CachedPtr<Clock> clock;

=== modified file 'src/system_compositor.cpp'
--- src/system_compositor.cpp	2015-08-26 08:26:35 +0000
+++ src/system_compositor.cpp	2016-01-27 14:14:14 +0000
@@ -22,6 +22,7 @@
 #include "dm_connection.h"
 
 #include <mir/input/composite_event_filter.h>
+#include <mir/input/input_device_hub.h>
 #include <mir/abnormal_exit.h>
 
 #include <cerrno>
@@ -123,6 +124,7 @@
 
                 unity_screen_service = server->the_unity_screen_service();
                 unity_input_service = server->the_unity_input_service();
+                dbus_service_thread = server->the_dbus_connection_thread();
             }
         });
 

=== modified file 'src/system_compositor.h'
--- src/system_compositor.h	2015-08-26 08:26:35 +0000
+++ src/system_compositor.h	2016-01-27 14:14:14 +0000
@@ -40,6 +40,7 @@
 class Screen;
 class UnityScreenService;
 class UnityInputService;
+class DBusConnectionThread;
 
 class SystemCompositor
 {
@@ -55,6 +56,7 @@
     std::shared_ptr<mir::input::EventFilter> screen_event_handler;
     std::shared_ptr<UnityScreenService> unity_screen_service;
     std::shared_ptr<UnityInputService> unity_input_service;
+    std::shared_ptr<DBusConnectionThread> dbus_service_thread;
 };
 
 }

=== modified file 'src/unity_input_service.cpp'
--- src/unity_input_service.cpp	2015-08-28 15:57:25 +0000
+++ src/unity_input_service.cpp	2016-01-27 14:14:14 +0000
@@ -19,7 +19,7 @@
 #include "unity_input_service.h"
 #include "input_configuration.h"
 #include "dbus_message_handle.h"
-#include "dbus_connection_thread.h"
+#include "dbus_event_loop.h"
 #include "scoped_dbus_error.h"
 
 #include "unity_input_service_introspection.h" // autogenerated
@@ -33,15 +33,14 @@
 
 }
 
-usc::UnityInputService::UnityInputService(
-    std::shared_ptr<usc::DBusConnectionThread> const& dbus,
-    std::shared_ptr<usc::InputConfiguration> const& input_config)
-    : dbus{dbus},
-      input_config{input_config}
+usc::UnityInputService::UnityInputService(std::shared_ptr<usc::DBusEventLoop> const& loop,
+                                          std::string const& address,
+                                          std::shared_ptr<usc::InputConfiguration> const& input_config)
+    : loop{loop}, connection{std::make_shared<DBusConnectionHandle>(address.c_str())}, input_config{input_config}
 {
-    auto const& connection = dbus->connection();
-    connection.request_name(dbus_input_service_name);
-    connection.add_filter(handle_dbus_message_thunk, this);
+    loop->add_connection(connection);
+    connection->request_name(dbus_input_service_name);
+    connection->add_filter(handle_dbus_message_thunk, this);
 }
 
 ::DBusHandlerResult usc::UnityInputService::handle_dbus_message_thunk(
@@ -63,7 +62,7 @@
         (input_config.get()->*method)(flag);
 
         DBusMessageHandle reply{dbus_message_new_method_return(message)};
-        dbus_connection_send(dbus->connection(), reply, nullptr);
+        dbus_connection_send(*connection, reply, nullptr);
     }
 }
 
@@ -79,7 +78,7 @@
         (input_config.get()->*method)(value);
 
         DBusMessageHandle reply{dbus_message_new_method_return(message)};
-        dbus_connection_send(dbus->connection(), reply, nullptr);
+        dbus_connection_send(*connection, reply, nullptr);
     }
 }
 
@@ -95,7 +94,7 @@
         (input_config.get()->*method)(value);
 
         DBusMessageHandle reply{dbus_message_new_method_return(message)};
-        dbus_connection_send(dbus->connection(), reply, nullptr);
+        dbus_connection_send(*connection, reply, nullptr);
     }
 }
 
@@ -151,4 +150,3 @@
 
     return DBUS_HANDLER_RESULT_HANDLED;
 }
-

=== modified file 'src/unity_input_service.h'
--- src/unity_input_service.h	2015-08-26 08:00:27 +0000
+++ src/unity_input_service.h	2016-01-27 14:14:14 +0000
@@ -20,18 +20,20 @@
 #define USC_UNITY_INPUT_SERVICE_H_
 
 #include <dbus/dbus.h>
+#include "dbus_connection_handle.h"
 #include <memory>
 
 namespace usc
 {
-class DBusConnectionThread;
+class DBusEventLoop;
 class InputConfiguration;
 
 class UnityInputService
 {
 public:
     UnityInputService(
-        std::shared_ptr<usc::DBusConnectionThread> const& dbus_thread,
+        std::shared_ptr<usc::DBusEventLoop> const& loop,
+        std::string const& address,
         std::shared_ptr<usc::InputConfiguration> const& input_config);
 
 private:
@@ -44,7 +46,8 @@
     void handle_message(DBusMessage* message, void (usc::InputConfiguration::* method)(int32_t));
     void handle_message(DBusMessage* message, void (usc::InputConfiguration::* method)(double));
 
-    std::shared_ptr<usc::DBusConnectionThread> const dbus;
+    std::shared_ptr<usc::DBusEventLoop> const loop;
+    std::shared_ptr<usc::DBusConnectionHandle> connection;
     std::shared_ptr<usc::InputConfiguration> const input_config;
 };
 

=== modified file 'src/unity_screen_service.cpp'
--- src/unity_screen_service.cpp	2015-08-25 14:35:20 +0000
+++ src/unity_screen_service.cpp	2016-01-27 14:14:14 +0000
@@ -19,7 +19,7 @@
 #include "unity_screen_service.h"
 #include "screen.h"
 #include "dbus_message_handle.h"
-#include "dbus_connection_thread.h"
+#include "dbus_event_loop.h"
 #include "dbus_connection_handle.h"
 #include "scoped_dbus_error.h"
 
@@ -35,20 +35,22 @@
 }
 
 usc::UnityScreenService::UnityScreenService(
-    std::shared_ptr<usc::DBusConnectionThread> const& dbus,
+    std::shared_ptr<usc::DBusEventLoop> const& loop,
+    std::string const& address,
     std::shared_ptr<usc::Screen> const& screen)
     : screen{screen},
-      dbus{dbus},
+      loop{loop},
+      connection{std::make_shared<DBusConnectionHandle>(address.c_str())},
       request_id{0}
 {
-    auto const& connection = dbus->connection();
-    connection.request_name(dbus_screen_service_name);
-    connection.add_match(
+    loop->add_connection(connection);
+    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);
+    connection->add_filter(handle_dbus_message_thunk, this);
 
     screen->register_power_state_change_handler(
         [this](MirPowerMode mode, PowerStateChangeReason reason)
@@ -332,7 +334,7 @@
     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->loop().enqueue(
+    loop->enqueue(
         [this, power_state, reason_int]
         {
             DBusMessageHandle signal{
@@ -344,6 +346,6 @@
                 DBUS_TYPE_INT32, &reason_int,
                 DBUS_TYPE_INVALID};
 
-            dbus_connection_send(dbus->connection(), signal, nullptr);
+            dbus_connection_send(*connection, signal, nullptr);
         });
 }

=== modified file 'src/unity_screen_service.h'
--- src/unity_screen_service.h	2015-08-25 14:32:32 +0000
+++ src/unity_screen_service.h	2016-01-27 14:14:14 +0000
@@ -34,13 +34,14 @@
 namespace usc
 {
 class Screen;
-class DBusConnectionThread;
+class DBusEventLoop;
 
 class UnityScreenService
 {
 public:
     UnityScreenService(
-        std::shared_ptr<usc::DBusConnectionThread> const& connection,
+        std::shared_ptr<usc::DBusEventLoop> const& loop,
+        std::string const& address,
         std::shared_ptr<usc::Screen> const& screen);
 
 private:
@@ -64,7 +65,8 @@
         MirPowerMode power_mode, PowerStateChangeReason reason);
 
     std::shared_ptr<usc::Screen> const screen;
-    std::shared_ptr<DBusConnectionThread> const dbus;
+    std::shared_ptr<DBusEventLoop> const loop;
+    std::shared_ptr<DBusConnectionHandle> connection;
 
     std::mutex keep_display_on_mutex;
     std::unordered_multimap<std::string,int32_t> keep_display_on_ids;

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2015-03-17 18:17:14 +0000
+++ tests/CMakeLists.txt	2016-01-27 14:14:14 +0000
@@ -14,5 +14,6 @@
 #
 # Authored by: Alexandros Frantzis <[e-mail]>
 
+include_directories(include)
 add_subdirectory(unit-tests/)
 add_subdirectory(integration-tests/)

=== added directory 'tests/include'
=== added directory 'tests/include/usc'
=== added directory 'tests/include/usc/test'
=== added file 'tests/include/usc/test/mock_display.h'
--- tests/include/usc/test/mock_display.h	1970-01-01 00:00:00 +0000
+++ tests/include/usc/test/mock_display.h	2016-01-27 14:14:14 +0000
@@ -0,0 +1,67 @@
+/*
+ * 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_TEST_MOCK_DISPLAY_H
+#define USC_TEST_MOCK_DISPLAY_H
+
+#include "usc/test/stub_display_configuration.h"
+
+#include <mir/graphics/display.h>
+#include <gmock/gmock.h>
+
+namespace usc
+{
+namespace test
+{
+struct MockDisplay : mir::graphics::Display
+{
+    void for_each_display_sync_group(std::function<void(mir::graphics::DisplaySyncGroup&)> const& f) override
+    {
+    }
+
+    std::unique_ptr<mir::graphics::DisplayConfiguration> configuration() const override
+    { return std::make_unique<usc::test::StubDisplayConfiguration>(); }
+
+    MOCK_METHOD1(configure, void(mir::graphics::DisplayConfiguration const& conf));
+
+    void register_configuration_change_handler(
+    mir::graphics::EventHandlerRegister& ,
+    mir::graphics::DisplayConfigurationChangeHandler const& ) override {};
+
+    void register_pause_resume_handlers(
+        mir::graphics::EventHandlerRegister&,
+        mir::graphics::DisplayPauseHandler const&,
+        mir::graphics::DisplayResumeHandler const&) override
+    {
+    }
+
+    void pause() override {};
+
+    void resume() override {};
+
+    std::shared_ptr<mir::graphics::Cursor> create_hardware_cursor(
+        std::shared_ptr<mir::graphics::CursorImage> const&) override
+    {
+        return {};
+    };
+
+    std::unique_ptr<mir::graphics::GLContext> create_gl_context() override
+    { return std::unique_ptr<mir::graphics::GLContext>{};};
+};
+}
+}
+
+#endif

=== added file 'tests/include/usc/test/mock_input_configuration.h'
--- tests/include/usc/test/mock_input_configuration.h	1970-01-01 00:00:00 +0000
+++ tests/include/usc/test/mock_input_configuration.h	2016-01-27 14:14:14 +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: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef USC_TEST_MOCK_INPUT_CONFIGURATION_H_
+#define USC_TEST_MOCK_INPUT_CONFIGURATION_H_
+
+#include "src/input_configuration.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+namespace usc
+{
+namespace test
+{
+struct MockInputConfiguration : usc::InputConfiguration
+{
+public:
+    MOCK_METHOD1(set_mouse_primary_button, void(int32_t));
+    MOCK_METHOD1(set_mouse_cursor_speed, void(double));
+    MOCK_METHOD1(set_mouse_scroll_speed, void(double));
+    MOCK_METHOD1(set_touchpad_primary_button, void(int32_t));
+    MOCK_METHOD1(set_touchpad_cursor_speed, void(double));
+    MOCK_METHOD1(set_touchpad_scroll_speed, void(double));
+    MOCK_METHOD1(set_two_finger_scroll, void(bool));
+    MOCK_METHOD1(set_tap_to_click, void(bool));
+    MOCK_METHOD1(set_disable_touchpad_with_mouse, void(bool));
+    MOCK_METHOD1(set_disable_touchpad_while_typing, void(bool));
+};
+}
+}
+
+#endif

=== added file 'tests/include/usc/test/mock_screen.h'
--- tests/include/usc/test/mock_screen.h	1970-01-01 00:00:00 +0000
+++ tests/include/usc/test/mock_screen.h	2016-01-27 14:14:14 +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: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef USC_TEST_MOCK_SCREEN_H_
+#define USC_TEST_MOCK_SCREEN_H_
+
+#include "src/screen.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+namespace usc
+{
+namespace test
+{
+
+struct MockScreen : usc::Screen
+{
+    MOCK_METHOD1(enable_inactivity_timers, void(bool enable));
+    MOCK_METHOD0(keep_display_on_temporarily, void());
+
+    MOCK_METHOD0(get_screen_power_mode, MirPowerMode());
+    MOCK_METHOD2(set_screen_power_mode, void(MirPowerMode mode, PowerStateChangeReason reason));
+    MOCK_METHOD1(keep_display_on, void(bool on));
+    MOCK_METHOD1(set_brightness, void(int brightness));
+    MOCK_METHOD1(enable_auto_brightness, void(bool enable));
+    MOCK_METHOD2(set_inactivity_timeouts, void(int power_off_timeout, int dimmer_timeout));
+
+    MOCK_METHOD1(set_touch_visualization_enabled, void(bool enabled));
+
+    void register_power_state_change_handler(
+        usc::PowerStateChangeHandler const& handler)
+    {
+        power_state_change_handler = handler;
+    }
+
+    usc::PowerStateChangeHandler power_state_change_handler;
+};
+
+}
+}
+
+#endif

=== added file 'tests/include/usc/test/stub_display_configuration.h'
--- tests/include/usc/test/stub_display_configuration.h	1970-01-01 00:00:00 +0000
+++ tests/include/usc/test/stub_display_configuration.h	2016-01-27 14:14:14 +0000
@@ -0,0 +1,65 @@
+/*
+ * 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_TEST_STUB_DISPLAY_CONFIGURATION_H_
+#define USC_TEST_STUB_DISPLAY_CONFIGURATION_H_
+
+#include <mir/graphics/display_configuration.h>
+
+namespace usc
+{
+namespace test
+{
+
+struct StubDisplayConfiguration : mir::graphics::DisplayConfiguration
+{
+    StubDisplayConfiguration()
+    {
+        conf_output.power_mode = MirPowerMode::mir_power_mode_on;
+    }
+
+    StubDisplayConfiguration(mir::graphics::DisplayConfigurationOutput const& output)
+        : conf_output(output)
+    {
+    }
+
+    void for_each_card(std::function<void(mir::graphics::DisplayConfigurationCard const&)>) const override
+    {
+    }
+
+    void for_each_output(std::function<void(mir::graphics::DisplayConfigurationOutput const&)> f) const override
+    {
+        f(conf_output);
+    }
+
+    void for_each_output(std::function<void(mir::graphics::UserDisplayConfigurationOutput&)> f)
+    {
+        mir::graphics::UserDisplayConfigurationOutput user{conf_output};
+        f(user);
+    }
+
+    std::unique_ptr<mir::graphics::DisplayConfiguration> clone() const override
+    {
+        return std::make_unique<StubDisplayConfiguration>(conf_output);
+    }
+
+    mir::graphics::DisplayConfigurationOutput conf_output;
+};
+
+}
+}
+
+#endif

=== modified file 'tests/integration-tests/CMakeLists.txt'
--- tests/integration-tests/CMakeLists.txt	2015-09-22 16:17:40 +0000
+++ tests/integration-tests/CMakeLists.txt	2016-01-27 14:14:14 +0000
@@ -33,9 +33,12 @@
   dbus_bus.cpp
   dbus_client.cpp
   spin_wait.cpp
+  unity_screen_dbus_client.cpp
+  unity_input_dbus_client.cpp
   test_dbus_event_loop.cpp
   test_unity_screen_service.cpp
   test_unity_input_service.cpp
+  test_unity_services.cpp
   test_external_spinner.cpp
   test_powerd_mediator.cpp
   test_deadlock_lp1491566.cpp

=== modified file 'tests/integration-tests/test_dbus_event_loop.cpp'
--- tests/integration-tests/test_dbus_event_loop.cpp	2015-05-27 09:42:40 +0000
+++ tests/integration-tests/test_dbus_event_loop.cpp	2016-01-27 14:14:14 +0000
@@ -79,8 +79,9 @@
 {
     ADBusEventLoop()
     {
-        connection.request_name(test_service_name);
-        connection.add_filter(handle_dbus_message_thunk, this);
+        dbus_event_loop.add_connection(connection);
+        connection->request_name(test_service_name);
+        connection->add_filter(handle_dbus_message_thunk, this);
 
         std::promise<void> event_loop_started;
         auto event_loop_started_future = event_loop_started.get_future();
@@ -102,8 +103,7 @@
     }
 
     static ::DBusHandlerResult handle_dbus_message_thunk(
-        ::DBusConnection* connection, DBusMessage* message, void* user_data)
-    {
+        ::DBusConnection* connection, DBusMessage* message, void* user_data) {
         auto const a_dbus_event_loop = static_cast<ADBusEventLoop*>(user_data);
         return a_dbus_event_loop->handle_dbus_message(connection, message, user_data);
     }
@@ -142,8 +142,8 @@
 
     ut::DBusBus bus;
 
-    usc::DBusConnectionHandle connection{bus.address().c_str()};
-    usc::DBusEventLoop dbus_event_loop{connection};
+    std::shared_ptr<usc::DBusConnectionHandle> connection{std::make_shared<usc::DBusConnectionHandle>(bus.address())};
+    usc::DBusEventLoop dbus_event_loop{};
     std::thread dbus_loop_thread;
     TestDBusClient client{bus.address()};
 };
@@ -173,7 +173,7 @@
                     test_service_interface,
                     "signal")};
 
-            dbus_connection_send(connection, msg, nullptr);
+            dbus_connection_send(*connection, msg, nullptr);
         });
 
     auto const reply = client.listen_for_signal();
@@ -214,7 +214,7 @@
 
             DBusPendingCall* pending{nullptr};
             dbus_connection_send_with_reply(
-                connection, msg, &pending, timeout_ms);
+                *connection, msg, &pending, timeout_ms);
             dbus_pending_call_set_notify(
                 pending, &pending_complete, &pending_promise, nullptr);
         });

=== modified file 'tests/integration-tests/test_deadlock_lp1491566.cpp'
--- tests/integration-tests/test_deadlock_lp1491566.cpp	2015-09-29 13:05:56 +0000
+++ tests/integration-tests/test_deadlock_lp1491566.cpp	2016-01-27 14:14:14 +0000
@@ -21,11 +21,11 @@
 #include "src/screen_hardware.h"
 #include "src/power_state_change_reason.h"
 #include "spin_wait.h"
+#include "usc/test/stub_display_configuration.h"
+#include "usc/test/mock_display.h"
 
 #include <mir/compositor/compositor.h>
 #include <mir/main_loop.h>
-#include <mir/graphics/display.h>
-#include <mir/graphics/display_configuration.h>
 #include <mir/graphics/gl_context.h>
 #include <mir/input/touch_visualizer.h>
 
@@ -36,6 +36,7 @@
 #include <future>
 
 namespace mg = mir::graphics;
+namespace ut = usc::test;
 
 namespace
 {
@@ -46,71 +47,6 @@
     void stop() override {}
 };
 
-struct StubDisplayConfiguration : mg::DisplayConfiguration
-{
-    StubDisplayConfiguration()
-    {
-        conf_output.power_mode = MirPowerMode::mir_power_mode_on;
-    }
-
-    void for_each_card(std::function<void(mg::DisplayConfigurationCard const&)> f) const override
-    {
-    }
-
-    void for_each_output(std::function<void(mg::DisplayConfigurationOutput const&)> f) const override
-    {
-        f(conf_output);
-    }
-
-    void for_each_output(std::function<void(mg::UserDisplayConfigurationOutput&)> f)
-    {
-        mg::UserDisplayConfigurationOutput user{conf_output};
-        f(user);
-    }
-
-    mg::DisplayConfigurationOutput conf_output;
-};
-
-struct StubDisplay : mg::Display
-{
-    void for_each_display_sync_group(std::function<void(mg::DisplaySyncGroup&)> const& f) override
-    {
-    }
-
-    std::unique_ptr<mg::DisplayConfiguration> configuration() const override
-    { 
-        return std::unique_ptr<mg::DisplayConfiguration>{new StubDisplayConfiguration{}};
-    }
-
-    void configure(mg::DisplayConfiguration const&) override {}
-
-    void register_configuration_change_handler(
-        mg::EventHandlerRegister& ,
-        mg::DisplayConfigurationChangeHandler const& ) override
-    {
-    }
-
-    void register_pause_resume_handlers(
-        mg::EventHandlerRegister&,
-        mg::DisplayPauseHandler const&,
-        mg::DisplayResumeHandler const&) override
-    {
-    }
-
-    void pause() override {}
-    void resume() override {}
-
-    std::shared_ptr<mg::Cursor> create_hardware_cursor(
-        std::shared_ptr<mg::CursorImage> const&) override
-    {
-        return{};
-    }
-
-    std::unique_ptr<mg::GLContext> create_gl_context() override
-    { 
-        return std::unique_ptr<mg::GLContext>{};
-    }
-};
 
 struct StubScreenHardware : usc::ScreenHardware
 {
@@ -219,7 +155,7 @@
     TestMirScreen mir_screen{
         std::make_shared<StubScreenHardware>(),
         std::make_shared<NullCompositor>(),
-        std::make_shared<StubDisplay>(),
+        std::make_shared<::testing::NiceMock<ut::MockDisplay>>(),
         std::make_shared<NullTouchVisualizer>(),
         main_loop,
         server.the_clock(),

=== modified file 'tests/integration-tests/test_powerd_mediator.cpp'
--- tests/integration-tests/test_powerd_mediator.cpp	2015-07-17 12:43:46 +0000
+++ tests/integration-tests/test_powerd_mediator.cpp	2016-01-27 14:14:14 +0000
@@ -41,9 +41,10 @@
         dbus_bool_t auto_brightness_supported,
         StartNow start_now)
         : auto_brightness_supported{auto_brightness_supported},
-          connection{address.c_str()},
-          dbus_event_loop{connection}
+          connection{std::make_shared<usc::DBusConnectionHandle>(address)},
+          dbus_event_loop{}
     {
+        dbus_event_loop.add_connection(connection);
         if (start_now == StartNow::yes)
             start();
     }
@@ -60,8 +61,8 @@
         ON_CALL(*this, dbus_setUserBrightness(normal_brightness))
             .WillByDefault(WakeUp(&initial_setup_done));
 
-        connection.request_name(powerd_service_name);
-        connection.add_filter(handle_dbus_message_thunk, this);
+        connection->request_name(powerd_service_name);
+        connection->add_filter(handle_dbus_message_thunk, this);
 
         std::promise<void> event_loop_started;
         auto event_loop_started_future = event_loop_started.get_future();
@@ -104,7 +105,7 @@
             DBUS_TYPE_INT32, &state,
             DBUS_TYPE_INVALID};
 
-        dbus_connection_send(connection, signal, nullptr);
+        dbus_connection_send(*connection, signal, nullptr);
     }
 
 private:
@@ -230,7 +231,7 @@
 
     ut::WaitCondition initial_setup_done;
 
-    usc::DBusConnectionHandle connection;
+    std::shared_ptr<usc::DBusConnectionHandle> connection;
     usc::DBusEventLoop dbus_event_loop;
     std::thread dbus_loop_thread;
 };

=== modified file 'tests/integration-tests/test_unity_input_service.cpp'
--- tests/integration-tests/test_unity_input_service.cpp	2015-08-28 15:57:25 +0000
+++ tests/integration-tests/test_unity_input_service.cpp	2016-01-27 14:14:14 +0000
@@ -19,15 +19,16 @@
 #include "src/unity_input_service.h"
 #include "src/dbus_connection_handle.h"
 #include "src/dbus_connection_thread.h"
+#include "src/dbus_event_loop.h"
 #include "src/dbus_message_handle.h"
-#include "src/input_configuration.h"
 #include "src/unity_input_service_introspection.h"
+
 #include "wait_condition.h"
 #include "dbus_bus.h"
 #include "dbus_client.h"
+#include "unity_input_dbus_client.h"
 
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
+#include "usc/test/mock_input_configuration.h"
 
 #include <stdexcept>
 #include <memory>
@@ -37,128 +38,19 @@
 namespace
 {
 
-struct MockInputConfiguration : usc::InputConfiguration
-{
-public:
-    MOCK_METHOD1(set_mouse_primary_button, void(int32_t));
-    MOCK_METHOD1(set_mouse_cursor_speed, void(double));
-    MOCK_METHOD1(set_mouse_scroll_speed, void(double));
-    MOCK_METHOD1(set_touchpad_primary_button, void(int32_t));
-    MOCK_METHOD1(set_touchpad_cursor_speed, void(double));
-    MOCK_METHOD1(set_touchpad_scroll_speed, void(double));
-    MOCK_METHOD1(set_two_finger_scroll, void(bool));
-    MOCK_METHOD1(set_tap_to_click, void(bool));
-    MOCK_METHOD1(set_disable_touchpad_with_mouse, void(bool));
-    MOCK_METHOD1(set_disable_touchpad_while_typing, void(bool));
-};
-
-class UnityInputDBusClient : public ut::DBusClient
-{
-public:
-    UnityInputDBusClient(std::string const& address)
-        : ut::DBusClient{
-            address,
-            "com.canonical.Unity.Input",
-            "/com/canonical/Unity/Input"}
-    {
-    }
-
-    ut::DBusAsyncReplyString request_introspection()
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyString>(
-            "org.freedesktop.DBus.Introspectable", "Introspect",
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request(char const* requestName, int32_t value)
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_input_interface, requestName,
-            DBUS_TYPE_INT32, &value,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_mouse_primary_button(int32_t button)
-    {
-        return request("setMousePrimaryButton", button);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touchpad_primary_button(int32_t button)
-    {
-        return request("setTouchpadPrimaryButton", button);
-    }
-
-    ut::DBusAsyncReplyVoid request(char const* requestName, double value)
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_input_interface, requestName,
-            DBUS_TYPE_DOUBLE, &value,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_mouse_cursor_speed(double speed)
-    {
-        return request("setMouseCursorSpeed", speed);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_mouse_scroll_speed(double speed)
-    {
-        return request("setMouseScrollSpeed", speed);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touchpad_cursor_speed(double speed)
-    {
-        return request("setTouchpadCursorSpeed", speed);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touchpad_scroll_speed(double speed)
-    {
-        return request("setTouchpadScrollSpeed", speed);
-    }
-
-    ut::DBusAsyncReplyVoid request(char const* requestName, bool value)
-    {
-        dbus_bool_t copied = value;
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_input_interface, requestName,
-            DBUS_TYPE_BOOLEAN, &copied,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touchpad_two_finger_scroll(bool enabled)
-    {
-        return request("setTouchpadTwoFingerScroll", enabled);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touchpad_tap_to_click(bool enabled)
-    {
-        return request("setTouchpadTapToClick", enabled);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touchpad_disable_with_mouse(bool enabled)
-    {
-        return request("setTouchpadDisableWithMouse", enabled);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touchpad_disable_while_typing(bool enabled)
-    {
-        return request("setTouchpadDisableWhileTyping", enabled);
-    }
-
-    char const* const unity_input_interface = "com.canonical.Unity.Input";
-};
-
 struct AUnityInputService : testing::Test
 {
     std::chrono::seconds const default_timeout{3};
     ut::DBusBus bus;
 
-    std::shared_ptr<MockInputConfiguration> const mock_input_configuration =
-        std::make_shared<testing::NiceMock<MockInputConfiguration>>();
-    UnityInputDBusClient client{bus.address()};
+    std::shared_ptr<ut::MockInputConfiguration> const mock_input_configuration =
+        std::make_shared<testing::NiceMock<ut::MockInputConfiguration>>();
+    ut::UnityInputDBusClient client{bus.address()};
+    std::shared_ptr<usc::DBusEventLoop> const dbus_loop=
+        std::make_shared<usc::DBusEventLoop>();
+    usc::UnityInputService service{dbus_loop, bus.address(), mock_input_configuration};
     std::shared_ptr<usc::DBusConnectionThread> const dbus_thread =
-        std::make_shared<usc::DBusConnectionThread>(bus.address());
-    usc::UnityInputService service{dbus_thread, mock_input_configuration};
+        std::make_shared<usc::DBusConnectionThread>(dbus_loop);
 };
 
 }

=== modified file 'tests/integration-tests/test_unity_screen_service.cpp'
--- tests/integration-tests/test_unity_screen_service.cpp	2015-08-25 14:27:23 +0000
+++ tests/integration-tests/test_unity_screen_service.cpp	2016-01-27 14:14:14 +0000
@@ -19,14 +19,16 @@
 #include "src/unity_screen_service.h"
 #include "src/dbus_connection_handle.h"
 #include "src/dbus_connection_thread.h"
+#include "src/dbus_event_loop.h"
 #include "src/dbus_message_handle.h"
 #include "src/screen.h"
 #include "src/power_state_change_reason.h"
 #include "src/unity_screen_service_introspection.h"
 #include "wait_condition.h"
 #include "dbus_bus.h"
-#include "dbus_client.h"
+#include "unity_screen_dbus_client.h"
 
+#include "usc/test/mock_screen.h"
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
@@ -38,157 +40,20 @@
 namespace
 {
 
-struct MockScreen : usc::Screen
-{
-    MOCK_METHOD1(enable_inactivity_timers, void(bool enable));
-    MOCK_METHOD0(keep_display_on_temporarily, void());
-
-    MOCK_METHOD0(get_screen_power_mode, MirPowerMode());
-    MOCK_METHOD2(set_screen_power_mode, void(MirPowerMode mode, PowerStateChangeReason reason));
-    MOCK_METHOD1(keep_display_on, void(bool on));
-    MOCK_METHOD1(set_brightness, void(int brightness));
-    MOCK_METHOD1(enable_auto_brightness, void(bool enable));
-    MOCK_METHOD2(set_inactivity_timeouts, void(int power_off_timeout, int dimmer_timeout));
-
-    MOCK_METHOD1(set_touch_visualization_enabled, void(bool enabled));
-
-    void register_power_state_change_handler(
-        usc::PowerStateChangeHandler const& handler)
-    {
-        power_state_change_handler = handler;
-    }
-
-    usc::PowerStateChangeHandler power_state_change_handler;
-};
-
-class UnityScreenDBusClient : public ut::DBusClient
-{
-public:
-    UnityScreenDBusClient(std::string const& address)
-        : ut::DBusClient{
-            address,
-            "com.canonical.Unity.Screen",
-            "/com/canonical/Unity/Screen"}
-    {
-        connection.add_match(
-            "type='signal',"
-            "interface='com.canonical.Unity.Screen',"
-            "member='DisplayPowerStateChange'");
-    }
-
-    ut::DBusAsyncReplyString request_introspection()
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyString>(
-            "org.freedesktop.DBus.Introspectable", "Introspect",
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_user_brightness(int32_t brightness)
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_screen_interface, "setUserBrightness",
-            DBUS_TYPE_INT32, &brightness,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_user_auto_brightness_enable(bool enabled)
-    {
-        dbus_bool_t const e = enabled ? TRUE : FALSE;
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_screen_interface, "userAutobrightnessEnable",
-            DBUS_TYPE_BOOLEAN, &e,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_inactivity_timeouts(
-        int32_t poweroff_timeout, int32_t dimmer_timeout)
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_screen_interface, "setInactivityTimeouts",
-            DBUS_TYPE_INT32, &poweroff_timeout,
-            DBUS_TYPE_INT32, &dimmer_timeout,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touch_visualization_enabled(bool enabled)
-    {
-        dbus_bool_t const e = enabled ? TRUE : FALSE;
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_screen_interface, "setTouchVisualizationEnabled",
-            DBUS_TYPE_BOOLEAN, &e,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyBool request_set_screen_power_mode(
-        std::string const& mode, int reason)
-    {
-        auto mode_cstr = mode.c_str();
-        return invoke_with_reply<ut::DBusAsyncReplyBool>(
-            unity_screen_interface, "setScreenPowerMode",
-            DBUS_TYPE_STRING, &mode_cstr,
-            DBUS_TYPE_INT32, &reason,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyInt request_keep_display_on()
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyInt>(
-            unity_screen_interface, "keepDisplayOn",
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_remove_display_on_request(int id)
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_screen_interface, "removeDisplayOnRequest",
-            DBUS_TYPE_INT32, &id,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReply request_invalid_method()
-    {
-        return invoke_with_reply<ut::DBusAsyncReply>(
-            unity_screen_interface, "invalidMethod",
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReply request_method_with_invalid_arguments()
-    {
-        char const* const str = "abcd";
-        return invoke_with_reply<ut::DBusAsyncReply>(
-            unity_screen_interface, "setUserBrightness",
-            DBUS_TYPE_STRING, &str,
-            DBUS_TYPE_INVALID);
-    }
-
-    usc::DBusMessageHandle listen_for_power_state_change_signal()
-    {
-        while (true)
-        {
-            dbus_connection_read_write(connection, 1);
-            auto msg = usc::DBusMessageHandle{dbus_connection_pop_message(connection)};
-
-            if (msg && dbus_message_is_signal(msg, "com.canonical.Unity.Screen", "DisplayPowerStateChange"))
-            {
-                return msg;
-            }
-        }
-    }
-
-    char const* const unity_screen_interface = "com.canonical.Unity.Screen";
-};
-
 struct AUnityScreenService : testing::Test
 {
     std::chrono::seconds const default_timeout{3};
     ut::DBusBus bus;
 
-    std::shared_ptr<MockScreen> const mock_screen =
-        std::make_shared<testing::NiceMock<MockScreen>>();
-    UnityScreenDBusClient client{bus.address()};
+    std::shared_ptr<ut::MockScreen> const mock_screen =
+        std::make_shared<testing::NiceMock<ut::MockScreen>>();
+    ut::UnityScreenDBusClient client{bus.address()};
+    std::shared_ptr<usc::DBusEventLoop> const dbus_loop=
+        std::make_shared<usc::DBusEventLoop>();
+    usc::UnityScreenService service{dbus_loop, bus.address(), mock_screen};
     std::shared_ptr<usc::DBusConnectionThread> const dbus_thread =
-        std::make_shared<usc::DBusConnectionThread>(bus.address());
-    usc::UnityScreenService service{dbus_thread, mock_screen};
+        std::make_shared<usc::DBusConnectionThread>(dbus_loop);
+
 };
 
 }
@@ -340,7 +205,7 @@
 {
     using namespace testing;
 
-    UnityScreenDBusClient other_client{bus.address()};
+    ut::UnityScreenDBusClient other_client{bus.address()};
 
     EXPECT_CALL(*mock_screen, keep_display_on(true)).Times(4);
     EXPECT_CALL(*mock_screen, keep_display_on(false)).Times(0);

=== added file 'tests/integration-tests/test_unity_services.cpp'
--- tests/integration-tests/test_unity_services.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/test_unity_services.cpp	2016-01-27 14:14:14 +0000
@@ -0,0 +1,82 @@
+/*
+ * Copyright © 2016 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: Andreas Pokorny <[e-mail]>
+ */
+#include "src/unity_input_service.h"
+#include "src/dbus_connection_handle.h"
+#include "src/dbus_connection_thread.h"
+#include "src/dbus_event_loop.h"
+#include "src/dbus_message_handle.h"
+#include "src/unity_screen_service.h"
+#include "src/unity_input_service_introspection.h"
+#include "src/unity_screen_service_introspection.h"
+
+#include "wait_condition.h"
+#include "dbus_bus.h"
+#include "dbus_client.h"
+#include "unity_input_dbus_client.h"
+#include "unity_screen_dbus_client.h"
+
+#include "usc/test/mock_input_configuration.h"
+#include "usc/test/mock_screen.h"
+
+namespace ut = usc::test;
+using namespace testing;
+
+namespace
+{
+
+struct UnityServices : testing::Test
+{
+    std::chrono::seconds const default_timeout{3};
+    ut::DBusBus bus;
+
+    ut::UnityScreenDBusClient screen_client{bus.address()};
+    ut::UnityInputDBusClient input_client{bus.address()};
+    std::shared_ptr<ut::MockScreen> const mock_screen =
+        std::make_shared<testing::NiceMock<ut::MockScreen>>();
+    std::shared_ptr<ut::MockInputConfiguration> const mock_input_configuration =
+        std::make_shared<testing::NiceMock<ut::MockInputConfiguration>>();
+    std::shared_ptr<usc::DBusEventLoop> const dbus_loop=
+        std::make_shared<usc::DBusEventLoop>();
+    usc::UnityScreenService screen_service{dbus_loop, bus.address(), mock_screen};
+    usc::UnityInputService input_service{dbus_loop, bus.address(), mock_input_configuration};
+    std::shared_ptr<usc::DBusConnectionThread> const dbus_thread =
+        std::make_shared<usc::DBusConnectionThread>(dbus_loop);
+};
+
+}
+
+TEST_F(UnityServices, offer_screen_introspection)
+{
+    auto reply = screen_client.request_introspection();
+    EXPECT_THAT(reply.get(), Eq(unity_screen_service_introspection));
+}
+
+TEST_F(UnityServices, offer_input_introspection)
+{
+    auto reply = input_client.request_introspection();
+    EXPECT_THAT(reply.get(), Eq(unity_input_service_introspection));
+}
+
+TEST_F(UnityServices, provides_access_to_input_methods)
+{
+    double const speed = 8.0;
+
+    EXPECT_CALL(*mock_input_configuration, set_mouse_scroll_speed(speed));
+
+    input_client.request_set_mouse_scroll_speed(speed);
+}

=== added file 'tests/integration-tests/unity_input_dbus_client.cpp'
--- tests/integration-tests/unity_input_dbus_client.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/unity_input_dbus_client.cpp	2016-01-27 14:14:14 +0000
@@ -0,0 +1,113 @@
+/*
+ * 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: Andreas Pokorny <[e-mail]>
+ */
+
+#include "unity_input_dbus_client.h"
+
+namespace ut = usc::test;
+
+ut::UnityInputDBusClient::UnityInputDBusClient(std::string const& address)
+    : ut::DBusClient{
+        address,
+        "com.canonical.Unity.Input",
+        "/com/canonical/Unity/Input"}
+{
+}
+
+ut::DBusAsyncReplyString ut::UnityInputDBusClient::request_introspection()
+{
+    return invoke_with_reply<ut::DBusAsyncReplyString>(
+        "org.freedesktop.DBus.Introspectable", "Introspect",
+        DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request(char const* requestName, int32_t value)
+{
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(
+        unity_input_interface, requestName,
+        DBUS_TYPE_INT32, &value,
+        DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_mouse_primary_button(int32_t button)
+{
+    return request("setMousePrimaryButton", button);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_touchpad_primary_button(int32_t button)
+{
+    return request("setTouchpadPrimaryButton", button);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request(char const* requestName, double value)
+{
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(
+        unity_input_interface, requestName,
+        DBUS_TYPE_DOUBLE, &value,
+        DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_mouse_cursor_speed(double speed)
+{
+    return request("setMouseCursorSpeed", speed);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_mouse_scroll_speed(double speed)
+{
+    return request("setMouseScrollSpeed", speed);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_touchpad_cursor_speed(double speed)
+{
+    return request("setTouchpadCursorSpeed", speed);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_touchpad_scroll_speed(double speed)
+{
+    return request("setTouchpadScrollSpeed", speed);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request(char const* requestName, bool value)
+{
+    dbus_bool_t copied = value;
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(
+        unity_input_interface, requestName,
+        DBUS_TYPE_BOOLEAN, &copied,
+        DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_touchpad_two_finger_scroll(bool enabled)
+{
+    return request("setTouchpadTwoFingerScroll", enabled);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_touchpad_tap_to_click(bool enabled)
+{
+    return request("setTouchpadTapToClick", enabled);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_touchpad_disable_with_mouse(bool enabled)
+{
+    return request("setTouchpadDisableWithMouse", enabled);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_touchpad_disable_while_typing(bool enabled)
+{
+    return request("setTouchpadDisableWhileTyping", enabled);
+}
+
+

=== added file 'tests/integration-tests/unity_input_dbus_client.h'
--- tests/integration-tests/unity_input_dbus_client.h	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/unity_input_dbus_client.h	2016-01-27 14:14:14 +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/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef USC_TEST_UNITY_INPUT_DBUS_CLIENT_H_
+#define USC_TEST_UNITY_INPUT_DBUS_CLIENT_H_
+
+#include "dbus_client.h"
+
+namespace usc
+{
+namespace test
+{
+class UnityInputDBusClient : public DBusClient
+{
+public:
+    UnityInputDBusClient(std::string const& address);
+    DBusAsyncReplyString request_introspection();
+    DBusAsyncReplyVoid request(char const* requestName, int32_t value);
+    DBusAsyncReplyVoid request_set_mouse_primary_button(int32_t button);
+    DBusAsyncReplyVoid request_set_touchpad_primary_button(int32_t button);
+    DBusAsyncReplyVoid request(char const* requestName, double value);
+    DBusAsyncReplyVoid request_set_mouse_cursor_speed(double speed);
+    DBusAsyncReplyVoid request_set_mouse_scroll_speed(double speed);
+    DBusAsyncReplyVoid request_set_touchpad_cursor_speed(double speed);
+    DBusAsyncReplyVoid request_set_touchpad_scroll_speed(double speed);
+    DBusAsyncReplyVoid request(char const* requestName, bool value);
+    DBusAsyncReplyVoid request_set_touchpad_two_finger_scroll(bool enabled);
+    DBusAsyncReplyVoid request_set_touchpad_tap_to_click(bool enabled);
+    DBusAsyncReplyVoid request_set_touchpad_disable_with_mouse(bool enabled);
+    DBusAsyncReplyVoid request_set_touchpad_disable_while_typing(bool enabled);
+    char const* const unity_input_interface = "com.canonical.Unity.Input";
+};
+
+}
+}
+
+#endif

=== added file 'tests/integration-tests/unity_screen_dbus_client.cpp'
--- tests/integration-tests/unity_screen_dbus_client.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/unity_screen_dbus_client.cpp	2016-01-27 14:14:14 +0000
@@ -0,0 +1,112 @@
+/*
+ * 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: Andreas Pokorny <[e-mail]>
+ */
+
+#include "unity_screen_dbus_client.h"
+#include "src/dbus_message_handle.h"
+
+namespace ut = usc::test;
+
+ut::UnityScreenDBusClient::UnityScreenDBusClient(std::string const& address)
+    : ut::DBusClient{
+        address,
+        "com.canonical.Unity.Screen",
+        "/com/canonical/Unity/Screen"}
+{
+    connection.add_match(
+        "type='signal',"
+        "interface='com.canonical.Unity.Screen',"
+        "member='DisplayPowerStateChange'");
+}
+
+ut::DBusAsyncReplyString ut::UnityScreenDBusClient::request_introspection()
+{
+    return invoke_with_reply<ut::DBusAsyncReplyString>("org.freedesktop.DBus.Introspectable", "Introspect",
+                                                       DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityScreenDBusClient::request_set_user_brightness(int32_t brightness)
+{
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(unity_screen_interface, "setUserBrightness", DBUS_TYPE_INT32,
+                                                     &brightness, DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityScreenDBusClient::request_user_auto_brightness_enable(bool enabled)
+{
+    dbus_bool_t const e = enabled ? TRUE : FALSE;
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(unity_screen_interface, "userAutobrightnessEnable",
+                                                     DBUS_TYPE_BOOLEAN, &e, DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityScreenDBusClient::request_set_inactivity_timeouts(int32_t poweroff_timeout,
+                                                                                  int32_t dimmer_timeout)
+{
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(unity_screen_interface, "setInactivityTimeouts", DBUS_TYPE_INT32,
+                                                     &poweroff_timeout, DBUS_TYPE_INT32, &dimmer_timeout,
+                                                     DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityScreenDBusClient::request_set_touch_visualization_enabled(bool enabled)
+{
+    dbus_bool_t const e = enabled ? TRUE : FALSE;
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(unity_screen_interface, "setTouchVisualizationEnabled",
+                                                     DBUS_TYPE_BOOLEAN, &e, DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyBool ut::UnityScreenDBusClient::request_set_screen_power_mode(std::string const& mode, int reason)
+{
+    auto mode_cstr = mode.c_str();
+    return invoke_with_reply<ut::DBusAsyncReplyBool>(unity_screen_interface, "setScreenPowerMode", DBUS_TYPE_STRING,
+                                                     &mode_cstr, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyInt ut::UnityScreenDBusClient::request_keep_display_on()
+{
+    return invoke_with_reply<ut::DBusAsyncReplyInt>(unity_screen_interface, "keepDisplayOn", DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityScreenDBusClient::request_remove_display_on_request(int id)
+{
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(unity_screen_interface, "removeDisplayOnRequest", DBUS_TYPE_INT32,
+                                                     &id, DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReply ut::UnityScreenDBusClient::request_invalid_method()
+{
+    return invoke_with_reply<ut::DBusAsyncReply>(unity_screen_interface, "invalidMethod", DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReply ut::UnityScreenDBusClient::request_method_with_invalid_arguments()
+{
+    char const* const str = "abcd";
+    return invoke_with_reply<ut::DBusAsyncReply>(unity_screen_interface, "setUserBrightness", DBUS_TYPE_STRING, &str,
+                                                 DBUS_TYPE_INVALID);
+}
+
+usc::DBusMessageHandle ut::UnityScreenDBusClient::listen_for_power_state_change_signal()
+{
+    while (true)
+    {
+        dbus_connection_read_write(connection, 1);
+        auto msg = usc::DBusMessageHandle{dbus_connection_pop_message(connection)};
+
+        if (msg && dbus_message_is_signal(msg, "com.canonical.Unity.Screen", "DisplayPowerStateChange"))
+        {
+            return msg;
+        }
+    }
+}

=== added file 'tests/integration-tests/unity_screen_dbus_client.h'
--- tests/integration-tests/unity_screen_dbus_client.h	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/unity_screen_dbus_client.h	2016-01-27 14:14:14 +0000
@@ -0,0 +1,54 @@
+/*
+ * 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: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef USC_TEST_UNITY_SCREEN_DBUS_CLIENT_H_
+#define USC_TEST_UNITY_SCREEN_DBUS_CLIENT_H_
+
+#include "dbus_client.h"
+
+namespace usc
+{
+namespace test
+{
+
+class UnityScreenDBusClient : public DBusClient
+{
+public:
+    UnityScreenDBusClient(std::string const& address);
+
+    DBusAsyncReplyString request_introspection();
+    DBusAsyncReplyVoid request_set_user_brightness(int32_t brightness);
+    DBusAsyncReplyVoid request_user_auto_brightness_enable(bool enabled);
+    DBusAsyncReplyVoid request_set_inactivity_timeouts(
+        int32_t poweroff_timeout, int32_t dimmer_timeout);
+    DBusAsyncReplyVoid request_set_touch_visualization_enabled(bool enabled);
+    DBusAsyncReplyBool request_set_screen_power_mode(
+        std::string const& mode, int reason);
+
+    DBusAsyncReplyInt request_keep_display_on();
+    DBusAsyncReplyVoid request_remove_display_on_request(int id);
+    DBusAsyncReply request_invalid_method();
+    DBusAsyncReply request_method_with_invalid_arguments();
+    usc::DBusMessageHandle listen_for_power_state_change_signal();
+    char const* const unity_screen_interface = "com.canonical.Unity.Screen";
+};
+
+}
+}
+
+#endif

=== modified file 'tests/unit-tests/CMakeLists.txt'
--- tests/unit-tests/CMakeLists.txt	2015-02-18 14:40:29 +0000
+++ tests/unit-tests/CMakeLists.txt	2016-01-27 14:14:14 +0000
@@ -25,6 +25,7 @@
   test_session_switcher.cpp
   test_screen_event_handler.cpp
   test_mir_screen.cpp
+  test_mir_input_configuration.cpp
 
   advanceable_timer.cpp
 )

=== added file 'tests/unit-tests/test_mir_input_configuration.cpp'
--- tests/unit-tests/test_mir_input_configuration.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/test_mir_input_configuration.cpp	2016-01-27 14:14:14 +0000
@@ -0,0 +1,114 @@
+/*
+ * 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: Andreas Pokorny <[e-mail]>
+ */
+
+
+#include "src/mir_input_configuration.h"
+#include "mir/input/input_device_hub.h"
+#include "mir/input/device_capability.h"
+#include "mir/input/input_device_observer.h"
+#include "mir/input/device.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+namespace mi = mir::input;
+
+using namespace ::testing;
+
+namespace
+{
+struct MockDevice : mi::Device
+{
+    MOCK_CONST_METHOD0(id, MirInputDeviceId());
+    MOCK_CONST_METHOD0(capabilities, mi::DeviceCapabilities());
+    MOCK_CONST_METHOD0(name, std::string());
+    MOCK_CONST_METHOD0(unique_id, std::string());
+    MOCK_CONST_METHOD0(pointer_configuration, mir::optional_value<mi::PointerConfiguration>());
+    MOCK_METHOD1(apply_pointer_configuration, void(mi::PointerConfiguration const&));
+    MOCK_CONST_METHOD0(touchpad_configuration, mir::optional_value<mi::TouchpadConfiguration> ());
+    MOCK_METHOD1(apply_touchpad_configuration, void(mi::TouchpadConfiguration const&));
+
+    MockDevice(mi::DeviceCapabilities caps)
+        : caps(caps)
+    {
+        ON_CALL(*this, capabilities()).WillByDefault(Return(this->caps));
+    }
+
+    mi::DeviceCapabilities caps;
+};
+
+struct MockInputDeviceHub : mi::InputDeviceHub
+{
+    MOCK_METHOD1(add_observer,void(std::shared_ptr<mi::InputDeviceObserver> const&));
+    MOCK_METHOD1(remove_observer,void(std::weak_ptr<mi::InputDeviceObserver> const&));
+};
+
+struct MirInputConfiguration : ::testing::Test
+{
+    template<typename T>
+    using shared_mock = std::shared_ptr<::testing::NiceMock<T>>;
+    shared_mock<MockInputDeviceHub> mock_hub{std::make_shared<::testing::NiceMock<MockInputDeviceHub>>()};
+    shared_mock<MockDevice> mock_mouse{
+        std::make_shared<::testing::NiceMock<MockDevice>>(mi::DeviceCapability::pointer)};
+    shared_mock<MockDevice> mock_touchpad{std::make_shared<::testing::NiceMock<MockDevice>>(
+        mi::DeviceCapability::pointer | mi::DeviceCapability::touchpad)};
+    shared_mock<MockDevice> mock_keyboard{std::make_shared<::testing::NiceMock<MockDevice>>(
+        mi::DeviceCapability::keyboard | mi::DeviceCapability::alpha_numeric)};
+
+    std::shared_ptr<mi::InputDeviceObserver> obs;
+
+    MirInputConfiguration()
+    {
+        ON_CALL(*mock_hub, add_observer(_)).WillByDefault(SaveArg<0>(&obs));
+    }
+};
+}
+
+TEST_F(MirInputConfiguration, registers_something_as_device_observer)
+{
+    EXPECT_CALL(*mock_hub, add_observer(_));
+
+    usc::MirInputConfiguration config(mock_hub);
+}
+
+TEST_F(MirInputConfiguration, configures_device_on_add)
+{
+    usc::MirInputConfiguration config(mock_hub);
+
+    EXPECT_CALL(*mock_touchpad, apply_pointer_configuration(_));
+    EXPECT_CALL(*mock_touchpad, apply_touchpad_configuration(_));
+    obs->device_added(mock_touchpad);
+}
+
+TEST_F(MirInputConfiguration, configures_mouse_on_add)
+{
+    usc::MirInputConfiguration config(mock_hub);
+
+    EXPECT_CALL(*mock_mouse, apply_pointer_configuration(_));
+    obs->device_added(mock_mouse);
+}
+
+TEST_F(MirInputConfiguration, ignores_keyboard_when_added)
+{
+    usc::MirInputConfiguration config(mock_hub);
+
+    EXPECT_CALL(*mock_keyboard, apply_touchpad_configuration(_)).Times(0);
+    EXPECT_CALL(*mock_keyboard, apply_pointer_configuration(_)).Times(0);
+    obs->device_added(mock_keyboard);
+}
+

=== modified file 'tests/unit-tests/test_mir_screen.cpp'
--- tests/unit-tests/test_mir_screen.cpp	2015-09-29 13:05:56 +0000
+++ tests/unit-tests/test_mir_screen.cpp	2016-01-27 14:14:14 +0000
@@ -21,8 +21,9 @@
 #include "src/power_state_change_reason.h"
 #include "advanceable_timer.h"
 
+#include "usc/test/mock_display.h"
+
 #include <mir/compositor/compositor.h>
-#include <mir/graphics/display.h>
 #include <mir/graphics/display_configuration.h>
 #include <mir/graphics/gl_context.h>
 #include <mir/input/touch_visualizer.h>
@@ -33,6 +34,7 @@
 #include <atomic>
 
 namespace mg = mir::graphics;
+namespace ut = usc::test;
 
 namespace
 {
@@ -43,63 +45,6 @@
     MOCK_METHOD0(stop, void());
 };
 
-struct StubDisplayConfiguration : mg::DisplayConfiguration
-{
-    StubDisplayConfiguration()
-    {
-        conf_output.power_mode = MirPowerMode::mir_power_mode_on;
-    }
-
-    void for_each_card(std::function<void(mg::DisplayConfigurationCard const&)> f) const override
-    {
-    }
-
-    void for_each_output(std::function<void(mg::DisplayConfigurationOutput const&)> f) const override
-    {
-        f(conf_output);
-    }
-
-    void for_each_output(std::function<void(mg::UserDisplayConfigurationOutput&)> f)
-    {
-        mg::UserDisplayConfigurationOutput user{conf_output};
-        f(user);
-    }
-
-    mg::DisplayConfigurationOutput conf_output;
-};
-
-struct MockDisplay : mg::Display
-{
-    void for_each_display_sync_group(std::function<void(mg::DisplaySyncGroup&)> const& f) override
-    {
-    }
-
-    std::unique_ptr<mg::DisplayConfiguration> configuration() const override
-    { return std::unique_ptr<mg::DisplayConfiguration>{new StubDisplayConfiguration{}}; }
-
-    MOCK_METHOD1(configure, void(mg::DisplayConfiguration const& conf));
-
-    void register_configuration_change_handler(
-    mg::EventHandlerRegister& ,
-    mg::DisplayConfigurationChangeHandler const& ) override {};
-
-    void register_pause_resume_handlers(
-        mg::EventHandlerRegister&,
-        mg::DisplayPauseHandler const&,
-        mg::DisplayResumeHandler const&) override
-    {
-    }
-
-    void pause() override {};
-
-    void resume() override {};
-
-    std::shared_ptr<mg::Cursor> create_hardware_cursor(std::shared_ptr<mg::CursorImage> const&) override {return{};};
-
-    std::unique_ptr<mg::GLContext> create_gl_context() override
-    { return std::unique_ptr<mg::GLContext>{};};
-};
-
 struct MockScreenHardware : usc::ScreenHardware
 {
     MOCK_METHOD0(set_dim_backlight, void());
@@ -333,8 +278,8 @@
         std::make_shared<testing::NiceMock<MockScreenHardware>>()};
     std::shared_ptr<MockCompositor> compositor{
         std::make_shared<testing::NiceMock<MockCompositor>>()};
-    std::shared_ptr<MockDisplay> display{
-        std::make_shared<testing::NiceMock<MockDisplay>>()};
+    std::shared_ptr<ut::MockDisplay> display{
+        std::make_shared<testing::NiceMock<ut::MockDisplay>>()};
     std::shared_ptr<MockTouchVisualizer> touch_visualizer{
         std::make_shared<testing::NiceMock<MockTouchVisualizer>>()};
     std::shared_ptr<AdvanceableTimer> timer{

=== modified file 'tests/unit-tests/test_screen_event_handler.cpp'
--- tests/unit-tests/test_screen_event_handler.cpp	2015-10-08 09:54:02 +0000
+++ tests/unit-tests/test_screen_event_handler.cpp	2016-01-27 14:14:14 +0000
@@ -28,6 +28,7 @@
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
+#include "linux/input.h"
 #include <atomic>
 
 namespace
@@ -64,6 +65,19 @@
         screen_event_handler.handle(*power_key_up_event);
     }
 
+    void press_a_key()
+    {
+        screen_event_handler.handle(*another_key_down_event);
+    }
+
+    void press_volume_keys()
+    {
+        screen_event_handler.handle(*vol_plus_key_down_event);
+        screen_event_handler.handle(*vol_plus_key_up_event);
+        screen_event_handler.handle(*vol_minus_key_down_event);
+        screen_event_handler.handle(*vol_minus_key_up_event);
+    }
+
     void touch_screen()
     {
         screen_event_handler.handle(*touch_event);
@@ -74,21 +88,50 @@
         screen_event_handler.handle(*pointer_event);
     }
 
-    static const int32_t POWER_KEY_CODE = 26;
     mir::EventUPtr power_key_down_event = mir::events::make_event(
         MirInputDeviceId{1}, std::chrono::nanoseconds(0),
 	    0, mir_keyboard_action_down,
-        POWER_KEY_CODE, 0, mir_input_event_modifier_none);
+        0, KEY_POWER, mir_input_event_modifier_none);
 
     mir::EventUPtr power_key_up_event = mir::events::make_event(
         MirInputDeviceId{1}, std::chrono::nanoseconds(0),
 	    0, mir_keyboard_action_up,
-        POWER_KEY_CODE, 0, mir_input_event_modifier_none);
+        0, KEY_POWER, mir_input_event_modifier_none);
+
+    mir::EventUPtr vol_plus_key_down_event = mir::events::make_event(
+        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
+	    0, mir_keyboard_action_down,
+        0, KEY_VOLUMEUP, mir_input_event_modifier_none);
+
+    mir::EventUPtr vol_plus_key_up_event = mir::events::make_event(
+        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
+	    0, mir_keyboard_action_up,
+        0, KEY_VOLUMEUP, mir_input_event_modifier_none);
+
+    mir::EventUPtr vol_minus_key_down_event = mir::events::make_event(
+        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
+	    0, mir_keyboard_action_down,
+        0, KEY_VOLUMEDOWN, mir_input_event_modifier_none);
+
+    mir::EventUPtr vol_minus_key_up_event = mir::events::make_event(
+        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
+	    0, mir_keyboard_action_up,
+        0, KEY_VOLUMEDOWN, mir_input_event_modifier_none);
+
+    mir::EventUPtr another_key_down_event = mir::events::make_event(
+        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
+	    0, mir_keyboard_action_down,
+        0, KEY_A, mir_input_event_modifier_none);
+
+    mir::EventUPtr another_key_up_event = mir::events::make_event(
+        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
+	    0, mir_keyboard_action_up,
+        0, KEY_A, mir_input_event_modifier_none);
 
     mir::EventUPtr touch_event = mir::events::make_event(
         MirInputDeviceId{1}, std::chrono::nanoseconds(0),
 	    0, mir_input_event_modifier_none);
-    
+
     mir::EventUPtr pointer_event = mir::events::make_event(
         MirInputDeviceId{1}, std::chrono::nanoseconds(0),
 	    0, mir_input_event_modifier_none,
@@ -160,13 +203,54 @@
     touch_screen();
 }
 
-TEST_F(AScreenEventHandler, keeps_display_on_temporarily_on_pointer_event)
-{
+TEST_F(AScreenEventHandler, turns_on_screen_and_filters_first_pointer_event_when_screen_is_off)
+{
+    mock_screen.mock_mode = MirPowerMode::mir_power_mode_off;
+    EXPECT_CALL(mock_screen,
+                set_screen_power_mode(MirPowerMode::mir_power_mode_on,
+                                      PowerStateChangeReason::unknown));
+
+    auto const event_filtered = screen_event_handler.handle(*pointer_event);
+    EXPECT_TRUE(event_filtered);
+}
+
+TEST_F(AScreenEventHandler, turns_on_screen_and_propagates_keys_when_screen_is_off)
+{
+    mock_screen.mock_mode = MirPowerMode::mir_power_mode_off;
+    EXPECT_CALL(mock_screen,
+                set_screen_power_mode(MirPowerMode::mir_power_mode_on,
+                                      PowerStateChangeReason::unknown));
+
+    auto const event_filtered = screen_event_handler.handle(*another_key_down_event);
+    EXPECT_FALSE(event_filtered);
+}
+
+TEST_F(AScreenEventHandler, keeps_display_on_temporarily_for_pointer_event_when_screen_is_on)
+{
+    mock_screen.mock_mode = MirPowerMode::mir_power_mode_on;
     EXPECT_CALL(mock_screen, keep_display_on_temporarily());
 
     move_pointer();
 }
 
+TEST_F(AScreenEventHandler, keeps_display_on_temporarily_key_event_when_screen_is_on)
+{
+    mock_screen.mock_mode = MirPowerMode::mir_power_mode_on;
+    EXPECT_CALL(mock_screen, keep_display_on_temporarily());
+
+    press_a_key();
+}
+
+TEST_F(AScreenEventHandler, does_not_affect_screen_state_for_volume_keys)
+{
+    using namespace testing;
+
+    EXPECT_CALL(mock_screen, keep_display_on_temporarily()).Times(0);
+    EXPECT_CALL(mock_screen, set_screen_power_mode(_,_)).Times(0);
+
+    press_volume_keys();
+}
+
 TEST_F(AScreenEventHandler, sets_screen_mode_off_normal_press_release)
 {
     EXPECT_CALL(mock_screen,
@@ -198,10 +282,12 @@
     release_power_key();
 }
 
-TEST_F(AScreenEventHandler, passes_through_all_handled_events)
+TEST_F(AScreenEventHandler, passes_through_all_handled_events_when_screen_is_on)
 {
     using namespace testing;
 
+    mock_screen.mock_mode = MirPowerMode::mir_power_mode_on;
+
     EXPECT_FALSE(screen_event_handler.handle(*power_key_down_event));
     EXPECT_FALSE(screen_event_handler.handle(*power_key_up_event));
     EXPECT_FALSE(screen_event_handler.handle(*touch_event));

=== modified file 'tools/png2header.py'
--- tools/png2header.py	2015-06-11 09:15:46 +0000
+++ tools/png2header.py	2016-01-27 14:14:14 +0000
@@ -67,7 +67,7 @@
     print "    unsigned char pixel_data[%d * %d * %d + 1];" % image_info
     print "} %s = {" % variable_name
     print "    %d, %d, %d," % image_info
-    print tocstring(image.tostring())
+    print tocstring(image.tobytes())
     print "};"
 
 def show_usage():
@@ -82,5 +82,6 @@
 variable_name = sys.argv[2]
 
 image = Image.open(image_filename)
-premultiply(image)
+if image.mode == 'RGBA':
+    premultiply(image)
 export(image, variable_name)