Merge lp:~andreas-pokorny/unity-system-compositor/expose-powerkey-state-and-screen-toggle-controller-interface into lp:unity-system-compositor

[Andreas Pokorny]

Add enablePowerModeToggle, disablePowerModeToggle and power key signals to com.canonical.Unity.Screen

Adds two new interface parts to com.canonical.Unity.Screen:

DBus methods for controlling wither power button toggles screen power mode:
  * enablePowerModeToggle
  * disablePowerModeToggle

DBus signals for power key down/up sequences:
  * powerKeyUp
  * powerKeyDown

Note that most LOC of the diff are caused due to the decomposition necessary to unit test the new logic.

[lp:~andreas-pokorny/unity-system-compositor/expose-powerkey-state-and-screen-toggle-controller-interface]

191. By Andreas Pokorny on 2014-11-06

Remove debug output

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[Alberto Aguirre (albaguirre)]

DBus methods for controlling wither power button toggles screen power mode:
  * enablePowerModeToggle
  * disablePowerModeToggle

Umm I wonder if this should be exposed. We certainly don't want just any client to override this policy - say what if the client requesting this crashed and never restored the power key policy?
The user now can't get the screen to shut off.

Maybe a request like in keepDisplayOn is needed, at least if the requesting client dies the power key policy can go back to default.

I guess an apparmor policy would be needed to access those controls so that they are not abused either.

review: Needs Information

[Andreas Pokorny (andreas-pokorny)]

> DBus methods for controlling wither power button toggles screen power mode:
> * enablePowerModeToggle
> * disablePowerModeToggle
>
> Umm I wonder if this should be exposed. We certainly don't want just any
> client to override this policy - say what if the client requesting this
> crashed and never restored the power key policy?
> The user now can't get the screen to shut off.
>
> Maybe a request like in keepDisplayOn is needed, at least if the requesting
> client dies the power key policy can go back to default.
>
> I guess an apparmor policy would be needed to access those controls so that
> they are not abused either.

ok, good idea.

[Robert Carr (robertcarr)]

What's going on here? Looks like the bug is still open to some extent (read the final comment on the remaining error states).

I'm not sure this is the correct approach...shoul the telephony service be listening to the powerKey event or rather should it be listening to the power state change event from powerd or whomever

[Andreas Pokorny (andreas-pokorny)]

> What's going on here? Looks like the bug is still open to some extent (read
> the final comment on the remaining error states).
>
> I'm not sure this is the correct approach...shoul the telephony service be
> listening to the powerKey event or rather should it be listening to the power
> state change event from powerd or whomever

For RTM a simpler solution was used that would still results into the power state being toggled.
The expected behavior is that on an incoming call pressing the power key is consumed by rejecting/silencing the call, so without turning the display off or on in that case.

And yes the approach outlined here is ugly too.

[Alan Griffiths (alan-griffiths)]

Text conflict in src/CMakeLists.txt
Contents conflict in src/dbus_screen.cpp
Contents conflict in src/dbus_screen.h
Text conflict in src/mir_screen.cpp
Text conflict in src/mir_screen.h
Text conflict in src/screen_event_handler.cpp
Text conflict in src/screen_event_handler.h
Text conflict in src/system_compositor.cpp
Text conflict in src/system_compositor.h
Text conflict in tests/unit-tests/CMakeLists.txt
10 conflicts encountered.

review: Needs Fixing

Unmerged revisions

191. By Andreas Pokorny on 2014-11-06

Remove debug output

190. By Andreas Pokorny on 2014-11-06

missing initialization

189. By Andreas Pokorny on 2014-11-06

Adds enable/disable interface for screen toggle

188. By Andreas Pokorny on 2014-11-05

dropping voice call tracking and manual dbus signaling again

187. By Andreas Pokorny on 2014-11-05

fixed and reduced call_added and call_removed signature

186. By Andreas Pokorny on 2014-11-05

Adds an ofono call state observer

During a call the screen toggle through the power key is disabled. The powerkey is supposed to be processed by telephony-service to silence and/or terminate the call.

185. By Andreas Pokorny on 2014-11-04

moving gmock utitlity for unique_ptr to separate file

184. By Andreas Pokorny on 2014-11-04

Make PowerKey handling and related parts unit-testable

This change does not change any of the existing behavior. It just moves calls to system()
or other parts of the unity system compositor behind interfaces.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-08-14 19:42:15 +0000
+++ CMakeLists.txt	2014-11-06 10:16:42 +0000
@@ -53,12 +53,12 @@
 add_subdirectory(spinner/)
 add_subdirectory(src/)
 
-#enable_testing()
-
-#option(MIR_ENABLE_TESTS "Build tests" ON)
-
-#if (MIR_ENABLE_TESTS)
-#  find_package(Gtest REQUIRED)
-#  include_directories(${GMOCK_INCLUDE_DIR} ${GTEST_INCLUDE_DIR})
-#  add_subdirectory(tests/)
-#endif ()
+enable_testing()
+
+option(MIR_ENABLE_TESTS "Build tests" ON)
+
+if (MIR_ENABLE_TESTS)
+  find_package(Gtest REQUIRED)
+  include_directories(${GMOCK_INCLUDE_DIR} ${GTEST_INCLUDE_DIR})
+  add_subdirectory(tests/)
+endif ()

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2014-09-16 00:20:05 +0000
+++ src/CMakeLists.txt	2014-11-06 10:16:42 +0000
@@ -20,12 +20,14 @@
   external_spinner.cpp
   powerd_mediator.cpp
   powerkey_handler.cpp
+  powerkey_mediator.cpp
   screen_state_handler.cpp
   server_configuration.cpp
   session_coordinator.cpp
   session_switcher.cpp
   surface_coordinator.cpp
   system_compositor.cpp
+  system_impl.cpp
   worker_thread.cpp
 )
 

=== modified file 'src/dbus_screen.cpp'
--- src/dbus_screen.cpp	2014-10-10 22:43:34 +0000
+++ src/dbus_screen.cpp	2014-11-06 10:16:42 +0000
@@ -18,6 +18,7 @@
 #include "dbus_screen_adaptor.h"
 #include "dbus_screen_observer.h"
 #include "power_state_change_reason.h"
+#include "screen_toggle_controller.h"
 #include "worker_thread.h"
 
 #include <atomic>
@@ -53,11 +54,12 @@
 }
 
 
-DBusScreen::DBusScreen(DBusScreenObserver& observer, QObject *parent)
+DBusScreen::DBusScreen(QObject *parent)
     : QObject(parent),
       dbus_adaptor{new DBusScreenAdaptor(this)},
       service_watcher{new QDBusServiceWatcher()},
-      observer{&observer},
+      observer{nullptr},
+      controller{nullptr},
       worker_thread{new usc::WorkerThread("USC/DBusHandler")}
 {
     QDBusConnection bus = QDBusConnection::systemBus();
@@ -78,6 +80,38 @@
 
 DBusScreen::~DBusScreen() = default;
 
+void DBusScreen::set_dbus_observer(DBusScreenObserver *obs)
+{
+    observer = obs;
+}
+
+void DBusScreen::set_screen_toggle_controller(usc::ScreenToggleController *ctrl)
+{
+    controller = ctrl;
+}
+
+void DBusScreen::power_key_up()
+{
+    emit powerKeyUp();
+}
+
+void DBusScreen::power_key_short()
+{
+}
+
+void DBusScreen::power_key_long()
+{
+}
+
+void DBusScreen::power_key_very_long()
+{
+}
+
+void DBusScreen::power_key_down()
+{
+    emit powerKeyDown();
+}
+
 bool DBusScreen::setScreenPowerMode(const QString &mode, int reason)
 {
     if (!is_valid_reason(reason))
@@ -107,21 +141,11 @@
     return true;
 }
 
-void DBusScreen::emit_power_state_change(MirPowerMode power_mode, PowerStateChangeReason reason)
+void DBusScreen::power_state_change(MirPowerMode power_mode, PowerStateChangeReason reason)
 {
-    QDBusMessage message =  QDBusMessage::createSignal("/com/canonical/Unity/Screen",
-        "com.canonical.Unity.Screen", "DisplayPowerStateChange");
-
-    int power_state = (power_mode == MirPowerMode::mir_power_mode_off) ? 0 : 1;
-
-    QVariant state(power_state);
-    QList<QVariant> arguments;
-    arguments.append(state);
-    arguments.append(static_cast<int>(reason));
-    message.setArguments(arguments);
-
-    QDBusConnection bus = QDBusConnection::systemBus();
-    bus.send(message);
+    emit DisplayPowerStateChange(
+        (power_mode == MirPowerMode::mir_power_mode_off) ? 0 : 1,
+        static_cast<int>(reason));
 }
 
 int DBusScreen::keepDisplayOn()
@@ -175,6 +199,22 @@
         remove_requestor(requestor, lock);
 }
 
+void DBusScreen::enablePowerModeToggle()
+{
+    std::cout << "enablePowerModeToggle" << std::endl;
+    if (!controller)
+        return;
+    controller->enable_screen_toggle();
+}
+
+void DBusScreen::disablePowerModeToggle()
+{
+    std::cout << "disablePowerModeToggle" << std::endl;
+    if (!controller)
+        return;
+    controller->disable_screen_toggle();
+}
+
 void DBusScreen::remove_display_on_requestor(QString const& requestor)
 {
     std::lock_guard<decltype(guard)> lock{guard};

=== modified file 'src/dbus_screen.h'
--- src/dbus_screen.h	2014-09-22 17:19:52 +0000
+++ src/dbus_screen.h	2014-11-06 10:16:42 +0000
@@ -17,7 +17,8 @@
 #ifndef DBUS_SCREEN_H_
 #define DBUS_SCREEN_H_
 
-#include <mir_toolkit/common.h>
+#include "screen_power_state_listener.h"
+#include "powerkey_state_listener.h"
 
 #include <memory>
 #include <mutex>
@@ -28,38 +29,54 @@
 #include <QtCore>
 #include <QDBusContext>
 
-namespace usc {class WorkerThread;}
+namespace usc {
+class WorkerThread;
+class ScreenToggleController;
+}
 
 class DBusScreenAdaptor;
 class DBusScreenObserver;
 class QDBusInterface;
 class QDBusServiceWatcher;
-enum class PowerStateChangeReason;
 
-class DBusScreen : public QObject, protected QDBusContext
+class DBusScreen : public QObject, protected QDBusContext, public usc::PowerKeyStateListener, public usc::ScreenPowerStateListener
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "com.canonical.Unity.Screen")
 
 public:
-    explicit DBusScreen(DBusScreenObserver& observer, QObject *parent = 0);
+    explicit DBusScreen(QObject *parent = 0);
     virtual ~DBusScreen();
 
-    void emit_power_state_change(MirPowerMode mode, PowerStateChangeReason reason);
+    void set_dbus_observer(DBusScreenObserver *observer);
+    void set_screen_toggle_controller(usc::ScreenToggleController *controller);
+    void power_state_change(MirPowerMode mode, PowerStateChangeReason reason) override;
+    void power_key_down() override;
+    void power_key_short() override;
+    void power_key_long() override;
+    void power_key_very_long() override;
+    void power_key_up() override;
 
 public Q_SLOTS:
     bool setScreenPowerMode(const QString &mode, int reason);
     int keepDisplayOn();
     void removeDisplayOnRequest(int id);
+    void enablePowerModeToggle();
+    void disablePowerModeToggle();
 
     //TODO: Expose same DBus powerd interface for now
     void setUserBrightness(int brightness);
     void userAutobrightnessEnable(bool enable);
 
     void setInactivityTimeouts(int poweroff_timeout, int dimmer_timeout);
-    
+
     void setTouchVisualizationEnabled(bool enabled);
 
+Q_SIGNALS:
+    void powerKeyUp();
+    void powerKeyDown();
+    void DisplayPowerStateChange(int power_state, int reason);
+
 private Q_SLOTS:
     void remove_display_on_requestor(QString const& requestor);
 
@@ -70,7 +87,8 @@
     std::unique_ptr<DBusScreenAdaptor> dbus_adaptor;
     std::unique_ptr<QDBusServiceWatcher> service_watcher;
     std::unordered_map<std::string, std::unordered_set<int>> display_requests;
-    DBusScreenObserver* const observer;
+    DBusScreenObserver* observer;
+    usc::ScreenToggleController* controller;
     std::unique_ptr<usc::WorkerThread> worker_thread;
 };
 

=== modified file 'src/dbus_screen_observer.h'
--- src/dbus_screen_observer.h	2014-09-04 22:30:24 +0000
+++ src/dbus_screen_observer.h	2014-11-06 10:16:42 +0000
@@ -17,6 +17,8 @@
 #ifndef DBUS_SCREEN_OBSERVER_H_
 #define DBUS_SCREEN_OBSERVER_H_
 
+#include "mir_toolkit/common.h"
+
 enum class PowerStateChangeReason;
 
 class DBusScreenObserver
@@ -25,6 +27,7 @@
     virtual ~DBusScreenObserver() = default;
 
     virtual void set_screen_power_mode(MirPowerMode mode, PowerStateChangeReason reason) = 0;
+    virtual void toggle_screen_power_mode(PowerStateChangeReason reason) = 0;
     virtual void keep_display_on(bool on) = 0;
     virtual void set_brightness(int brightness) = 0;
     virtual void enable_auto_brightness(bool enable) = 0;

=== added file 'src/inactivty_tracker.h'
--- src/inactivty_tracker.h	1970-01-01 00:00:00 +0000
+++ src/inactivty_tracker.h	2014-11-06 10:16:42 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef INACTIVITY_TRACKER_H_
+#define INACTIVITY_TRACKER_H_
+
+class  InactivtyTracker
+{
+public:
+    InactivtyTracker() = default;
+    virtual ~InactivtyTracker() = default;
+    virtual void enable_inactivity_timers(bool enable) = 0;
+protected:
+    InactivtyTracker(InactivtyTracker const&) = delete;
+    InactivtyTracker& operator=(InactivtyTracker const&) = delete;
+};
+
+#endif
+

=== modified file 'src/powerkey_handler.cpp'
--- src/powerkey_handler.cpp	2014-07-21 21:33:35 +0000
+++ src/powerkey_handler.cpp	2014-11-06 10:16:42 +0000
@@ -15,36 +15,37 @@
  */
 
 #include "powerkey_handler.h"
-#include "screen_state_handler.h"
-#include "power_state_change_reason.h"
+#include "powerkey_state_listener.h"
 
 #include <mir/time/timer.h>
 
-#include <cstdio>
-#include "dbus_screen.h"
-#include "powerd_mediator.h"
+#include <chrono>
+#include <algorithm>
 
 namespace mi = mir::input;
 
-PowerKeyHandler::PowerKeyHandler(mir::time::Timer& timer,
+usc::PowerKeyHandler::PowerKeyHandler(mir::time::Timer& timer,
                                  std::chrono::milliseconds power_key_ignore_timeout,
                                  std::chrono::milliseconds shutdown_timeout,
-                                 ScreenStateHandler& screen_state_handler)
-    : long_press_detected{false},
-      screen_state_handler{&screen_state_handler},
+                                 std::initializer_list<usc::PowerKeyStateListener*> listener)
+    : power_key{KeyState::Released},
       power_key_ignore_timeout{power_key_ignore_timeout},
       shutdown_timeout{shutdown_timeout},
       shutdown_alarm{timer.create_alarm([this]{ shutdown_alarm_notification(); })},
-      long_press_alarm{timer.create_alarm([this]{ long_press_notification(); })}
+      long_press_alarm{timer.create_alarm([this]{ long_press_notification(); })},
+      key_state_listener{listener}
 {
+    if (power_key_ignore_timeout > shutdown_timeout)
+        throw std::invalid_argument("shutdown timeout must be larger than power key ignore timeout");
+    if (power_key_ignore_timeout.count() == 0 ||
+        shutdown_timeout.count() == 0)
+        throw std::invalid_argument("timeouts must be non-zero");
 }
 
-PowerKeyHandler::~PowerKeyHandler() = default;
+usc::PowerKeyHandler::~PowerKeyHandler() = default;
 
-bool PowerKeyHandler::handle(MirEvent const& event)
+bool usc::PowerKeyHandler::handle(MirEvent const& event)
 {
-    static const int32_t POWER_KEY_CODE = 26;
-
     if (event.type == mir_event_type_key &&
         event.key.key_code == POWER_KEY_CODE)
     {
@@ -56,36 +57,52 @@
     return false;
 }
 
-void PowerKeyHandler::power_key_down()
-{
-    std::lock_guard<std::mutex> lock{guard};
-    screen_state_handler->enable_inactivity_timers(false);
-    long_press_detected = false;
-    long_press_alarm->reschedule_in(power_key_ignore_timeout);
-    shutdown_alarm->reschedule_in(shutdown_timeout);
-}
-
-void PowerKeyHandler::power_key_up()
-{
-    std::lock_guard<std::mutex> lock{guard};
-    shutdown_alarm->cancel();
-    long_press_alarm->cancel();
-    if (!long_press_detected)
-    {
-        screen_state_handler->toggle_screen_power_mode(PowerStateChangeReason::power_key);
-    }
-}
-
-void PowerKeyHandler::shutdown_alarm_notification()
-{
-    screen_state_handler->set_screen_power_mode(
-        MirPowerMode::mir_power_mode_off, PowerStateChangeReason::power_key);
-    system("shutdown -P now");
-}
-
-void PowerKeyHandler::long_press_notification()
-{
-    screen_state_handler->set_screen_power_mode(
-        MirPowerMode::mir_power_mode_on, PowerStateChangeReason::power_key);
-    long_press_detected = true;
+void usc::PowerKeyHandler::power_key_down()
+{
+    if (try_transistion(KeyState::Released, KeyState::Pressed))
+    {
+        long_press_alarm->reschedule_in(power_key_ignore_timeout);
+        shutdown_alarm->reschedule_in(shutdown_timeout);
+        std::for_each(begin(key_state_listener), end(key_state_listener), [](usc::PowerKeyStateListener* item){item->power_key_down();});
+    }
+}
+
+void usc::PowerKeyHandler::power_key_up()
+{
+    if (try_transistion(KeyState::Pressed, KeyState::Released))
+    {
+        shutdown_alarm->cancel();
+        long_press_alarm->cancel();
+        std::for_each(begin(key_state_listener), end(key_state_listener), [](usc::PowerKeyStateListener* item){item->power_key_short();});
+    }
+    else if (try_transistion(KeyState::LongPressed, KeyState::Released))
+    {
+        shutdown_alarm->cancel();
+    }
+    else if (try_transistion(KeyState::VeryLongPressed, KeyState::Released))
+    {
+        // both alarms already fired
+    }
+    std::for_each(begin(key_state_listener), end(key_state_listener), [](usc::PowerKeyStateListener* item){item->power_key_up();});
+}
+
+void usc::PowerKeyHandler::shutdown_alarm_notification()
+{
+    if (try_transistion(KeyState::LongPressed, KeyState::VeryLongPressed))
+    {
+        std::for_each(begin(key_state_listener), end(key_state_listener), [](usc::PowerKeyStateListener* item){item->power_key_very_long();});
+    }
+}
+
+void usc::PowerKeyHandler::long_press_notification()
+{
+    if (try_transistion(KeyState::Pressed, KeyState::LongPressed))
+    {
+        std::for_each(begin(key_state_listener), end(key_state_listener), [](usc::PowerKeyStateListener* item){item->power_key_long();});
+    }
+}
+
+bool usc::PowerKeyHandler::try_transistion(KeyState from, KeyState to)
+{
+    return std::atomic_compare_exchange_strong(&power_key, &from, to);
 }

=== modified file 'src/powerkey_handler.h'
--- src/powerkey_handler.h	2014-07-21 21:33:35 +0000
+++ src/powerkey_handler.h	2014-11-06 10:16:42 +0000
@@ -22,11 +22,12 @@
 #include <mutex>
 #include <memory>
 #include <atomic>
+#include <vector>
 #include <chrono>
+#include <initializer_list>
 
 namespace mir
 {
-class DefaultServerConfiguration;
 namespace time
 {
 class Alarm;
@@ -34,7 +35,9 @@
 }
 }
 
-class ScreenStateHandler;
+namespace usc
+{
+class PowerKeyStateListener;
 
 class PowerKeyHandler : public mir::input::EventFilter
 {
@@ -42,29 +45,38 @@
     PowerKeyHandler(mir::time::Timer& timer,
                     std::chrono::milliseconds power_key_ignore_timeout,
                     std::chrono::milliseconds shutdown_timeout,
-                    ScreenStateHandler& screen_state_handler);
+                    std::initializer_list<PowerKeyStateListener*> listener);
 
     ~PowerKeyHandler();
 
     bool handle(MirEvent const& event) override;
 
+    static const int32_t POWER_KEY_CODE = 26;
+
 private:
     void power_key_up();
     void power_key_down();
     void shutdown_alarm_notification();
     void long_press_notification();
 
-    std::mutex guard;
-    std::atomic<bool> long_press_detected;
+    enum class KeyState
+    {
+        Released,
+        Pressed,
+        LongPressed,
+        VeryLongPressed
+    };
+    bool try_transistion(KeyState from, KeyState to);
 
-    ScreenStateHandler* screen_state_handler;
+    std::atomic<KeyState> power_key;
 
     std::chrono::milliseconds power_key_ignore_timeout;
     std::chrono::milliseconds shutdown_timeout;
 
     std::unique_ptr<mir::time::Alarm> shutdown_alarm;
     std::unique_ptr<mir::time::Alarm> long_press_alarm;
-
+    std::vector<PowerKeyStateListener*> const key_state_listener;
 };
+}
 
 #endif

=== added file 'src/powerkey_mediator.cpp'
--- src/powerkey_mediator.cpp	1970-01-01 00:00:00 +0000
+++ src/powerkey_mediator.cpp	2014-11-06 10:16:42 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#include "powerkey_mediator.h"
+#include "dbus_screen_observer.h"
+#include "power_state_change_reason.h"
+#include "inactivty_tracker.h"
+#include "system.h"
+
+usc::PowerKeyMediator::PowerKeyMediator(DBusScreenObserver & observer, InactivtyTracker & tracker, System& sys)
+    : screen_observer{observer}, inactivity_tracker(tracker), sys(sys)
+{
+}
+
+void usc::PowerKeyMediator::power_key_down()
+{
+    inactivity_tracker.enable_inactivity_timers(false);
+}
+
+void usc::PowerKeyMediator::power_key_short()
+{
+    if (screen_toggle_enabled)
+        screen_observer.toggle_screen_power_mode(PowerStateChangeReason::power_key);
+}
+
+void usc::PowerKeyMediator::power_key_long()
+{
+    // screen is turned on so that the shutdown/restart/cancel dialog that is displayed
+    // by the shell can be seen
+    screen_observer.set_screen_power_mode(
+        MirPowerMode::mir_power_mode_on, PowerStateChangeReason::power_key);
+}
+
+void usc::PowerKeyMediator::power_key_very_long()
+{
+    screen_observer.set_screen_power_mode(
+        MirPowerMode::mir_power_mode_off, PowerStateChangeReason::power_key);
+    sys.shutdown();
+}
+
+void usc::PowerKeyMediator::power_key_up()
+{
+}
+
+void usc::PowerKeyMediator::enable_screen_toggle()
+{
+    screen_toggle_enabled = true;
+}
+
+void usc::PowerKeyMediator::disable_screen_toggle()
+{
+    screen_toggle_enabled = false;
+}

=== added file 'src/powerkey_mediator.h'
--- src/powerkey_mediator.h	1970-01-01 00:00:00 +0000
+++ src/powerkey_mediator.h	2014-11-06 10:16:42 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef POWER_KEY_MEDIATOR_
+#define POWER_KEY_MEDIATOR_
+
+#include "powerkey_state_listener.h"
+#include "screen_toggle_controller.h"
+
+#include <atomic>
+
+class InactivtyTracker;
+class DBusScreenObserver;
+class System;
+
+namespace usc
+{
+
+class PowerKeyMediator : public PowerKeyStateListener, public ScreenToggleController
+{
+public:
+    PowerKeyMediator(DBusScreenObserver& observer, InactivtyTracker& handler, System& sys);
+    void power_key_down() override;
+    void power_key_short() override;
+    void power_key_long() override;
+    void power_key_very_long() override;
+    void power_key_up() override;
+
+    void enable_screen_toggle() override;
+    void disable_screen_toggle() override;
+private:
+    DBusScreenObserver& screen_observer;
+    InactivtyTracker& inactivity_tracker;
+    System& sys;
+    std::atomic<bool> screen_toggle_enabled{true};
+};
+
+}
+
+#endif

=== added file 'src/powerkey_state_listener.h'
--- src/powerkey_state_listener.h	1970-01-01 00:00:00 +0000
+++ src/powerkey_state_listener.h	2014-11-06 10:16:42 +0000
@@ -0,0 +1,40 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef POWER_KEY_STATE_LISTENER_
+#define POWER_KEY_STATE_LISTENER_
+
+namespace usc
+{
+
+class PowerKeyStateListener
+{
+public:
+    PowerKeyStateListener() = default;
+    virtual ~PowerKeyStateListener() = default;
+    virtual void power_key_down() = 0;
+    virtual void power_key_short() = 0;
+    virtual void power_key_long() = 0;
+    virtual void power_key_very_long() = 0;
+    virtual void power_key_up() = 0;
+protected:
+    PowerKeyStateListener(PowerKeyStateListener const&) = delete;
+    PowerKeyStateListener& operator=(PowerKeyStateListener const&) = delete;
+};
+
+}
+
+#endif

=== added file 'src/screen_power_state_listener.h'
--- src/screen_power_state_listener.h	1970-01-01 00:00:00 +0000
+++ src/screen_power_state_listener.h	2014-11-06 10:16:42 +0000
@@ -0,0 +1,40 @@
+/*
+ * Copyright © 2013-2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef USC_SCREEN_POWER_STATE_LISTENER_H_
+#define USC_SCREEN_POWER_STATE_LISTENER_H_
+
+#include <mir_toolkit/common.h>
+
+enum class PowerStateChangeReason;
+
+namespace usc
+{
+
+class ScreenPowerStateListener
+{
+public:
+    ScreenPowerStateListener() = default;
+    virtual ~ScreenPowerStateListener() = default;
+    virtual void power_state_change(MirPowerMode mode, PowerStateChangeReason reason) = 0;
+private:
+    ScreenPowerStateListener(ScreenPowerStateListener const&) = delete;
+    ScreenPowerStateListener& operator=(ScreenPowerStateListener const&) = delete;
+};
+
+}
+
+#endif

=== modified file 'src/screen_state_handler.cpp'
--- src/screen_state_handler.cpp	2014-09-22 17:19:52 +0000
+++ src/screen_state_handler.cpp	2014-11-06 10:16:42 +0000
@@ -13,8 +13,12 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+#define QT_NO_KEYWORDS
 
 #include "screen_state_handler.h"
+#include "powerd_mediator.h"
+#include "power_state_change_reason.h"
+#include "screen_power_state_listener.h"
 
 #include <mir/main_loop.h>
 #include <mir/time/timer.h>
@@ -25,10 +29,6 @@
 #include <mir/input/touch_visualizer.h>
 
 #include <cstdio>
-#include "dbus_screen.h"
-#include "dbus_screen_observer.h"
-#include "powerd_mediator.h"
-#include "power_state_change_reason.h"
 
 namespace mi = mir::input;
 namespace mc = mir::compositor;
@@ -36,7 +36,8 @@
 
 ScreenStateHandler::ScreenStateHandler(std::shared_ptr<mir::DefaultServerConfiguration> const& config,
                                        std::chrono::milliseconds poweroff_timeout,
-                                       std::chrono::milliseconds dimmer_timeout)
+                                       std::chrono::milliseconds dimmer_timeout,
+                                       usc::ScreenPowerStateListener & screen_state_listener)
     : current_power_mode{MirPowerMode::mir_power_mode_on},
       restart_timers{true},
       power_off_timeout{poweroff_timeout},
@@ -47,7 +48,7 @@
               std::bind(&ScreenStateHandler::power_off_alarm_notification, this))},
       dimmer_alarm{config->the_main_loop()->create_alarm(
               std::bind(&ScreenStateHandler::dimmer_alarm_notification, this))},
-      dbus_screen{new DBusScreen(*this)}
+      screen_state_listener{screen_state_listener}
 {
     reset_timers_l();
 }
@@ -181,7 +182,7 @@
 
     current_power_mode = mode;
 
-    dbus_screen->emit_power_state_change(mode, reason);
+    screen_state_listener.power_state_change(mode, reason);
 
     if (!power_on)
         powerd_mediator->allow_suspend();

=== modified file 'src/screen_state_handler.h'
--- src/screen_state_handler.h	2014-09-04 22:30:24 +0000
+++ src/screen_state_handler.h	2014-11-06 10:16:42 +0000
@@ -19,6 +19,7 @@
 
 #include "mir/input/event_filter.h"
 #include "dbus_screen_observer.h"
+#include "inactivty_tracker.h"
 
 #include <chrono>
 #include <memory>
@@ -38,26 +39,29 @@
 }
 }
 
-class ScreenStateHandler: public mir::input::EventFilter, public DBusScreenObserver
+namespace usc { class ScreenPowerStateListener;}
+
+class ScreenStateHandler: public mir::input::EventFilter, public DBusScreenObserver, public InactivtyTracker
 {
 public:
     ScreenStateHandler(std::shared_ptr<mir::DefaultServerConfiguration> const& config,
                        std::chrono::milliseconds power_off_timeout,
-                       std::chrono::milliseconds dimmer_timeout);
+                       std::chrono::milliseconds dimmer_timeout,
+                       usc::ScreenPowerStateListener& screen_state_listener);
     virtual ~ScreenStateHandler();
 
     //from EventFilter
     bool handle(MirEvent const& event) override;
 
-    void enable_inactivity_timers(bool enable);
-    void toggle_screen_power_mode(PowerStateChangeReason reason);
+    void enable_inactivity_timers(bool enable) override;
 
     void set_screen_power_mode(MirPowerMode mode, PowerStateChangeReason reason) override;
+    void toggle_screen_power_mode(PowerStateChangeReason reason) override;
     void keep_display_on(bool on) override;
     void set_brightness(int brightness) override;
     void enable_auto_brightness(bool enable) override;
     void set_inactivity_timeouts(int power_off_timeout, int dimmer_timeout) override;
-    
+
     void set_touch_visualization_enabled(bool enabled) override;
 
 private:
@@ -86,7 +90,7 @@
     std::unique_ptr<mir::time::Alarm> power_off_alarm;
     std::unique_ptr<mir::time::Alarm> dimmer_alarm;
 
-    std::unique_ptr<DBusScreen> dbus_screen;
+    usc::ScreenPowerStateListener& screen_state_listener;
 };
 
 #endif

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

=== added file 'src/system.h'
--- src/system.h	1970-01-01 00:00:00 +0000
+++ src/system.h	2014-11-06 10:16:42 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef UNITY_SYSTEM_COMPOSITOR_SYSTEM_H_
+#define UNITY_SYSTEM_COMPOSITOR_SYSTEM_H_
+
+/*!
+ * Interfaces to low level c-library functionality.
+ */
+class System
+{
+public:
+    System() = default;
+    virtual ~System() = default;
+    virtual void shutdown() = 0;
+protected:
+    System(System const&) = delete;
+    System& operator=(System const&) = delete;
+};
+
+#endif
+

=== modified file 'src/system_compositor.cpp'
--- src/system_compositor.cpp	2014-07-18 06:37:51 +0000
+++ src/system_compositor.cpp	2014-11-06 10:16:42 +0000
@@ -24,6 +24,8 @@
 #include "spinner.h"
 #include "screen_state_handler.h"
 #include "powerkey_handler.h"
+#include "powerkey_mediator.h"
+#include "dbus_screen.h"
 
 // Qt headers will introduce a #define of "signals"
 // but some mir headers use "signals" as a variable name in
@@ -93,6 +95,8 @@
 {
 }
 
+usc::SystemCompositor::~SystemCompositor() = default;
+
 void usc::SystemCompositor::run()
 {
     if (config->show_version())
@@ -155,14 +159,24 @@
         std::chrono::milliseconds power_key_ignore_timeout{config->power_key_ignore_timeout()};
         std::chrono::milliseconds shutdown_timeout{config->shutdown_timeout()};
 
+        dbus_screen = std::unique_ptr<DBusScreen>(new DBusScreen);
         screen_state_handler = std::make_shared<ScreenStateHandler>(config,
             std::chrono::duration_cast<std::chrono::milliseconds>(inactivity_display_off_timeout),
-            std::chrono::duration_cast<std::chrono::milliseconds>(inactivity_display_dim_timeout));
+            std::chrono::duration_cast<std::chrono::milliseconds>(inactivity_display_dim_timeout),
+            *dbus_screen
+            );
+
+        dbus_screen->set_dbus_observer(screen_state_handler.get());
+
+        power_key_mediator = std::make_shared<PowerKeyMediator>(*screen_state_handler, *screen_state_handler, system_impl);
+
+        dbus_screen->set_screen_toggle_controller(power_key_mediator.get());
 
         power_key_handler = std::make_shared<PowerKeyHandler>(*(config->the_main_loop()),
             power_key_ignore_timeout,
             shutdown_timeout,
-            *screen_state_handler);
+            std::initializer_list<PowerKeyStateListener*>{power_key_mediator.get(), dbus_screen.get()}
+            );
 
         auto composite_filter = config->the_composite_event_filter();
         composite_filter->append(screen_state_handler);

=== modified file 'src/system_compositor.h'
--- src/system_compositor.h	2014-07-14 14:26:17 +0000
+++ src/system_compositor.h	2014-11-06 10:16:42 +0000
@@ -22,13 +22,17 @@
 
 #include <memory>
 
+#include "system_impl.h"
+
 class ScreenStateHandler;
-class PowerKeyHandler;
+class DBusScreen;
 
 namespace usc
 {
 
 class ServerConfiguration;
+class PowerKeyMediator;
+class PowerKeyHandler;
 class DMConnection;
 class Spinner;
 
@@ -36,6 +40,7 @@
 {
 public:
     SystemCompositor(std::shared_ptr<ServerConfiguration> const& config);
+    ~SystemCompositor();
     void run();
 
 private:
@@ -45,8 +50,11 @@
     std::shared_ptr<ServerConfiguration> const config;
     std::shared_ptr<DMConnection> const dm_connection;
     std::shared_ptr<Spinner> const spinner;
+    std::unique_ptr<DBusScreen> dbus_screen;
     std::shared_ptr<ScreenStateHandler> screen_state_handler;
+    std::shared_ptr<PowerKeyMediator> power_key_mediator;
     std::shared_ptr<PowerKeyHandler> power_key_handler;
+    SystemImpl system_impl;
 };
 
 }

=== added file 'src/system_impl.cpp'
--- src/system_impl.cpp	1970-01-01 00:00:00 +0000
+++ src/system_impl.cpp	2014-11-06 10:16:42 +0000
@@ -0,0 +1,25 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#include "system_impl.h"
+#include <cstdlib>
+
+void SystemImpl::shutdown()
+{
+    std::system("shutdown -P now");
+}

=== added file 'src/system_impl.h'
--- src/system_impl.h	1970-01-01 00:00:00 +0000
+++ src/system_impl.h	2014-11-06 10:16:42 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef SYSTEM_IMPL_H
+#define SYSTEM_IMPL_H
+
+#include "system.h"
+
+class SystemImpl : public System
+{
+public:
+    void shutdown() override;
+};
+
+#endif
+

=== modified file 'tests/unit-tests/CMakeLists.txt'
--- tests/unit-tests/CMakeLists.txt	2014-07-09 06:58:05 +0000
+++ tests/unit-tests/CMakeLists.txt	2014-11-06 10:16:42 +0000
@@ -23,6 +23,8 @@
   usc_unit_tests
 
   test_session_switcher.cpp
+  test_powerkey_handler.cpp
+  test_powerkey_mediator.cpp
 )
 
 target_link_libraries(

=== added file 'tests/unit-tests/gmock-fixes.h'
--- tests/unit-tests/gmock-fixes.h	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/gmock-fixes.h	2014-11-06 10:16:42 +0000
@@ -0,0 +1,106 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef USC_GMOCK_FIXES_H_
+#define USC_GMOCK_FIXES_H_
+#include <gmock/gmock.h>
+
+// copied from mir code base
+namespace testing
+{
+namespace internal
+{
+
+template<typename T>
+class ActionResultHolder<std::unique_ptr<T>>
+: public UntypedActionResultHolderBase {
+ public:
+  explicit ActionResultHolder(std::unique_ptr<T>&& a_value) :
+  value_(std::move(a_value)) {}
+
+  // The compiler-generated copy constructor and assignment operator
+  // are exactly what we need, so we don't need to define them.
+
+  // Returns the held value and deletes this object.
+  std::unique_ptr<T> GetValueAndDelete() const {
+      std::unique_ptr<T> retval(std::move(value_));
+    delete this;
+    return std::move(retval);
+  }
+
+  // Prints the held value as an action's result to os.
+  virtual void PrintAsActionResult(::std::ostream* os) const {
+    *os << "\n          Returns: ";
+    // T may be a reference type, so we don't use UniversalPrint().
+    UniversalPrinter<std::unique_ptr<T>>::Print(value_, os);
+  }
+
+  // Performs the given mock function's default action and returns the
+  // result in a new-ed ActionResultHolder.
+  template <typename F>
+  static ActionResultHolder* PerformDefaultAction(
+      const FunctionMockerBase<F>* func_mocker,
+      const typename Function<F>::ArgumentTuple& args,
+      const string& call_description) {
+    return new ActionResultHolder(
+        func_mocker->PerformDefaultAction(args, call_description));
+  }
+
+  // Performs the given action and returns the result in a new-ed
+  // ActionResultHolder.
+  template <typename F>
+  static ActionResultHolder*
+  PerformAction(const Action<F>& action,
+                const typename Function<F>::ArgumentTuple& args) {
+    return new ActionResultHolder(action.Perform(args));
+  }
+
+ private:
+  std::unique_ptr<T> mutable value_;
+
+  // T could be a reference type, so = isn't supported.
+  GTEST_DISALLOW_ASSIGN_(ActionResultHolder);
+};
+
+}
+
+template<typename T>
+class DefaultValue<std::unique_ptr<T>> {
+ public:
+  // Unsets the default value for type T.
+  static void Clear() {}
+
+  // Returns true iff the user has set the default value for type T.
+  static bool IsSet() { return false; }
+
+  // Returns true if T has a default return value set by the user or there
+  // exists a built-in default value.
+  static bool Exists() {
+    return true;
+  }
+
+  // Returns the default value for type T if the user has set one;
+  // otherwise returns the built-in default value if there is one;
+  // otherwise aborts the process.
+  static std::unique_ptr<T> Get() {
+    return std::unique_ptr<T>();
+  }
+};
+
+}
+
+#endif
+

=== added file 'tests/unit-tests/mock_dbus_screen_observer.h'
--- tests/unit-tests/mock_dbus_screen_observer.h	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/mock_dbus_screen_observer.h	2014-11-06 10:16:42 +0000
@@ -0,0 +1,38 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef USC_MOCK_DBUS_SCREEN_OBSERER_H_
+#define USC_MOCK_DBUS_SCREEN_OBSERER_H_
+
+#include "src/dbus_screen_observer.h"
+
+#include <gmock/gmock.h>
+
+class MockDBusScreenObserver : public DBusScreenObserver
+{
+public:
+    MOCK_METHOD2(set_screen_power_mode, void(MirPowerMode, PowerStateChangeReason));
+    MOCK_METHOD1(toggle_screen_power_mode, void(PowerStateChangeReason));
+    MOCK_METHOD1(keep_display_on, void(bool));
+    MOCK_METHOD1(set_brightness, void(int));
+    MOCK_METHOD1(enable_auto_brightness, void(bool));
+    MOCK_METHOD2(set_inactivity_timeouts, void(int, int));
+    MOCK_METHOD1(set_touch_visualization_enabled, void(bool));
+};
+
+#endif

=== added file 'tests/unit-tests/test_powerkey_handler.cpp'
--- tests/unit-tests/test_powerkey_handler.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/test_powerkey_handler.cpp	2014-11-06 10:16:42 +0000
@@ -0,0 +1,366 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#include "src/powerkey_handler.h"
+#include "src/powerkey_state_listener.h"
+#include "mir/time/alarm.h"
+#include "mir/time/timer.h"
+
+#include "gmock-fixes.h"
+#include <gtest/gtest.h>
+
+namespace mti = mir::time;
+
+class MockAlarm : public mir::time::Alarm
+{
+public:
+    std::function<void()> callback;
+
+    MOCK_METHOD0(cancel,bool());
+    MOCK_CONST_METHOD0(state, State());
+    MOCK_METHOD1(reschedule_in, bool(std::chrono::milliseconds));
+    MOCK_METHOD1(reschedule_for, bool(mti::Timestamp));
+};
+
+class MockTimer : public mti::Timer
+{
+public:
+    MOCK_METHOD2(notify_in,
+                 std::unique_ptr<mti::Alarm>(std::chrono::milliseconds,
+                                             std::function<void()>));
+    MOCK_METHOD2(notify_at, std::unique_ptr<mti::Alarm>(mti::Timestamp,
+                                                        std::function<void()>));
+    MOCK_METHOD1(create_alarm, std::unique_ptr<mti::Alarm>(std::function<void()>));
+};
+
+class MockPowerKeyStateListener : public usc::PowerKeyStateListener
+{
+public:
+    MOCK_METHOD0(power_key_down,void());
+    MOCK_METHOD0(power_key_short, void());
+    MOCK_METHOD0(power_key_long, void());
+    MOCK_METHOD0(power_key_very_long, void());
+    MOCK_METHOD0(power_key_up, void());
+};
+
+class TestPowerKeyHandler : public ::testing::Test
+{
+public:
+    TestPowerKeyHandler()
+    {
+        using namespace ::testing;
+        ON_CALL(mock_timer,create_alarm(_))
+            .WillByDefault(Invoke([this](std::function<void()> callback) -> std::unique_ptr<mti::Alarm>
+                                  {return create_alarm(callback);} )
+                           );
+
+        power_key_down_event.key.action = mir_key_action_down;
+        power_key_down_event.key.key_code = usc::PowerKeyHandler::POWER_KEY_CODE;
+
+        power_key_up_event.key.action = mir_key_action_up;
+        power_key_up_event.key.key_code = usc::PowerKeyHandler::POWER_KEY_CODE;
+
+        non_power_key.key.action = mir_key_action_down;
+        non_power_key.key.key_code = usc::PowerKeyHandler::POWER_KEY_CODE + 1;
+    }
+
+    std::unique_ptr<mti::Alarm> create_alarm(std::function<void()> callback)
+    {
+        // TODO find a better way to keep track of alarms created by KeyStateHandler
+        if (!long_timeout)
+        {
+            long_timeout = new ::testing::NiceMock<MockAlarm>;
+            long_timeout->callback = callback;
+            // potentially violating against unique_ptr here
+            return std::unique_ptr<mti::Alarm>(long_timeout);
+        }
+        if(!short_timeout)
+        {
+            short_timeout = new ::testing::NiceMock<MockAlarm>;
+            short_timeout->callback = callback;
+            // potentially violating against unique_ptr here
+            return std::unique_ptr<mti::Alarm>(short_timeout);
+        }
+        return nullptr;
+    }
+
+    ::testing::NiceMock<MockAlarm> * short_timeout = nullptr;
+    ::testing::NiceMock<MockAlarm> * long_timeout = nullptr;
+    ::testing::NiceMock<MockTimer> mock_timer;
+    ::testing::NiceMock<MockPowerKeyStateListener> mock_key_state_listener;
+
+    std::chrono::milliseconds short_delay{1};
+    std::chrono::milliseconds long_delay{2};
+    std::chrono::milliseconds zero_timeout{0};
+
+    MirEvent power_key_down_event{ mir_event_type_key };
+    MirEvent power_key_up_event{ mir_event_type_key };
+    MirEvent non_power_key{ mir_event_type_key };
+};
+
+TEST_F(TestPowerKeyHandler, creates_two_alarms)
+{
+    using namespace ::testing;
+    EXPECT_CALL(mock_timer,create_alarm(_)).Times(2);
+    usc::PowerKeyHandler key_handler(mock_timer, short_delay, long_delay, {&mock_key_state_listener});
+}
+
+TEST_F(TestPowerKeyHandler, schedules_timers_on_power_key_down)
+{
+    usc::PowerKeyHandler key_handler(mock_timer, short_delay, long_delay, {&mock_key_state_listener});
+
+    EXPECT_CALL(*short_timeout,reschedule_in(short_delay)).Times(1);
+    EXPECT_CALL(*long_timeout,reschedule_in(long_delay)).Times(1);
+
+    key_handler.handle(power_key_down_event);
+}
+
+TEST_F(TestPowerKeyHandler, re_schedules_and_cancel_timers)
+{
+    using namespace ::testing;
+    usc::PowerKeyHandler key_handler(mock_timer, short_delay, long_delay, {&mock_key_state_listener});
+
+    Sequence s;
+    EXPECT_CALL(*short_timeout,reschedule_in(short_delay)).InSequence(s);
+    EXPECT_CALL(*long_timeout,reschedule_in(long_delay)).InSequence(s);
+    EXPECT_CALL(*long_timeout,cancel()).InSequence(s);
+    EXPECT_CALL(*short_timeout,cancel()).InSequence(s);
+    EXPECT_CALL(*short_timeout,reschedule_in(short_delay)).InSequence(s);
+    EXPECT_CALL(*long_timeout,reschedule_in(long_delay)).InSequence(s);
+    EXPECT_CALL(*long_timeout,cancel()).InSequence(s);
+    EXPECT_CALL(*short_timeout,cancel()).InSequence(s);
+    EXPECT_CALL(*short_timeout,reschedule_in(short_delay)).InSequence(s);
+    EXPECT_CALL(*long_timeout,reschedule_in(long_delay)).InSequence(s);
+    EXPECT_CALL(*long_timeout,cancel()).InSequence(s);
+    EXPECT_CALL(*short_timeout,cancel()).InSequence(s);
+
+    key_handler.handle(power_key_down_event);
+    key_handler.handle(power_key_up_event);
+    key_handler.handle(power_key_down_event);
+    key_handler.handle(power_key_up_event);
+    key_handler.handle(power_key_down_event);
+    key_handler.handle(power_key_up_event);
+}
+
+TEST_F(TestPowerKeyHandler, never_filters_key_events)
+{
+    using namespace testing;
+    usc::PowerKeyHandler key_handler(mock_timer, short_delay, long_delay, {&mock_key_state_listener});
+
+    EXPECT_THAT(key_handler.handle(power_key_down_event), Eq(false));
+    EXPECT_THAT(key_handler.handle(power_key_up_event), Eq(false));
+    EXPECT_THAT(key_handler.handle(non_power_key), Eq(false));
+}
+
+TEST_F(TestPowerKeyHandler, cancels_timers_on_power_key_up)
+{
+    usc::PowerKeyHandler key_handler(mock_timer, short_delay, long_delay, {&mock_key_state_listener});
+
+    EXPECT_CALL(*long_timeout,cancel()).Times(1);
+    EXPECT_CALL(*short_timeout,cancel()).Times(1);
+
+    key_handler.handle(power_key_down_event);
+    key_handler.handle(power_key_up_event);
+}
+
+TEST_F(TestPowerKeyHandler, throws_on_wrong_timeouts)
+{
+    EXPECT_THROW({
+                 usc::PowerKeyHandler key_handler(mock_timer, long_delay, short_delay, {&mock_key_state_listener});
+    }, std::invalid_argument);
+}
+
+TEST_F(TestPowerKeyHandler, ignores_spurious_up_down_events)
+{
+    using namespace ::testing;
+    usc::PowerKeyHandler key_handler(mock_timer, short_delay, long_delay, {&mock_key_state_listener});
+
+    Sequence seq;
+
+    EXPECT_CALL(*short_timeout,reschedule_in(short_delay))
+        .InSequence(seq);
+    EXPECT_CALL(*long_timeout,reschedule_in(long_delay))
+        .InSequence(seq);
+    EXPECT_CALL(*long_timeout,cancel())
+        .InSequence(seq);
+    EXPECT_CALL(*short_timeout,cancel())
+        .InSequence(seq);
+
+    key_handler.handle(power_key_down_event);
+    key_handler.handle(power_key_down_event);
+    key_handler.handle(power_key_down_event);
+    key_handler.handle(power_key_up_event);
+    key_handler.handle(power_key_up_event);
+    key_handler.handle(power_key_up_event);
+}
+
+TEST_F(TestPowerKeyHandler, forwards_down_events_to_key_state_listener)
+{
+    usc::PowerKeyHandler key_handler(mock_timer, short_delay, long_delay, {&mock_key_state_listener});
+
+    EXPECT_CALL(mock_key_state_listener, power_key_down());
+    key_handler.handle(power_key_down_event);
+}
+
+TEST_F(TestPowerKeyHandler, forwards_up_events_to_key_state_listener)
+{
+    usc::PowerKeyHandler key_handler(mock_timer, short_delay, long_delay, {&mock_key_state_listener});
+
+    EXPECT_CALL(mock_key_state_listener, power_key_up());
+    key_handler.handle(power_key_down_event);
+    key_handler.handle(power_key_up_event);
+}
+
+TEST_F(TestPowerKeyHandler, down_short_up_up_comes_in_sequence)
+{
+    using namespace ::testing;
+    usc::PowerKeyHandler key_handler(mock_timer, short_delay, long_delay, {&mock_key_state_listener});
+
+    Sequence s;
+
+    EXPECT_CALL(mock_key_state_listener, power_key_down()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_short()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_up()).InSequence(s);
+    key_handler.handle(power_key_down_event);
+    key_handler.handle(power_key_up_event);
+}
+
+TEST_F(TestPowerKeyHandler, down_long_up_comes_in_sequence)
+{
+    using namespace ::testing;
+    usc::PowerKeyHandler key_handler(mock_timer, short_delay, long_delay, {&mock_key_state_listener});
+
+    Sequence s;
+
+    EXPECT_CALL(mock_key_state_listener, power_key_down()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_long()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_up()).InSequence(s);
+
+    key_handler.handle(power_key_down_event);
+    short_timeout->callback();
+    key_handler.handle(power_key_up_event);
+}
+
+TEST_F(TestPowerKeyHandler, down_very_long_up_comes_in_sequence)
+{
+    using namespace ::testing;
+    usc::PowerKeyHandler key_handler(mock_timer, short_delay, long_delay, {&mock_key_state_listener});
+
+    Sequence s;
+
+    EXPECT_CALL(mock_key_state_listener, power_key_down()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_long()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_very_long()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_up()).InSequence(s);
+
+    key_handler.handle(power_key_down_event);
+    short_timeout->callback();
+    long_timeout->callback();
+    key_handler.handle(power_key_up_event);
+}
+
+TEST_F(TestPowerKeyHandler, spurious_alarm_callbacks_dont_cause_calls)
+{
+    using namespace ::testing;
+    usc::PowerKeyHandler key_handler(mock_timer, short_delay, long_delay, {&mock_key_state_listener});
+
+    Sequence s;
+
+    EXPECT_CALL(mock_key_state_listener, power_key_down()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_short()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_up()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_very_long()).Times(0);
+    EXPECT_CALL(mock_key_state_listener, power_key_long()).Times(0);
+
+    key_handler.handle(power_key_down_event);
+    key_handler.handle(power_key_up_event);
+
+    long_timeout->callback();
+    long_timeout->callback();
+    short_timeout->callback();
+    short_timeout->callback();
+}
+
+TEST_F(TestPowerKeyHandler, spurious_alarm_callbacks_dont_cause_calls_after_first_timeout)
+{
+    using namespace ::testing;
+    usc::PowerKeyHandler key_handler(mock_timer, short_delay, long_delay, {&mock_key_state_listener});
+
+    Sequence s;
+
+    EXPECT_CALL(mock_key_state_listener, power_key_down()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_long()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_up()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_very_long()).Times(0);
+    EXPECT_CALL(mock_key_state_listener, power_key_short()).Times(0);
+
+    key_handler.handle(power_key_down_event);
+    short_timeout->callback();
+    key_handler.handle(power_key_up_event);
+
+    long_timeout->callback();
+    long_timeout->callback();
+    short_timeout->callback();
+    short_timeout->callback();
+}
+
+TEST_F(TestPowerKeyHandler, multiple_sequences_work)
+{
+    using namespace ::testing;
+    usc::PowerKeyHandler key_handler(mock_timer, short_delay, long_delay, {&mock_key_state_listener});
+
+    Sequence s;
+
+    EXPECT_CALL(mock_key_state_listener, power_key_down()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_long()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_up()).InSequence(s);
+
+    EXPECT_CALL(mock_key_state_listener, power_key_down()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_short()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_up()).InSequence(s);
+
+    EXPECT_CALL(mock_key_state_listener, power_key_down()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_long()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_very_long()).InSequence(s);
+    EXPECT_CALL(mock_key_state_listener, power_key_up()).InSequence(s);
+
+    key_handler.handle(power_key_down_event);
+    short_timeout->callback();
+    key_handler.handle(power_key_up_event);
+
+    key_handler.handle(power_key_down_event);
+    key_handler.handle(power_key_up_event);
+
+    key_handler.handle(power_key_down_event);
+    short_timeout->callback();
+    long_timeout->callback();
+    key_handler.handle(power_key_up_event);
+}
+
+TEST_F(TestPowerKeyHandler, throws_on_zero_timeouts)
+{
+    using namespace ::testing;
+    EXPECT_THROW({
+                 usc::PowerKeyHandler key_handler(mock_timer, zero_timeout, long_delay, {&mock_key_state_listener});
+        }, std::invalid_argument
+        );
+    EXPECT_THROW({
+                 usc::PowerKeyHandler key_handler(mock_timer, short_delay, zero_timeout, {&mock_key_state_listener});
+        }, std::invalid_argument
+        );
+}

=== added file 'tests/unit-tests/test_powerkey_mediator.cpp'
--- tests/unit-tests/test_powerkey_mediator.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/test_powerkey_mediator.cpp	2014-11-06 10:16:42 +0000
@@ -0,0 +1,138 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#include "src/powerkey_mediator.h"
+#include "src/inactivty_tracker.h"
+#include "src/power_state_change_reason.h"
+#include "src/system.h"
+
+#include "mock_dbus_screen_observer.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+class MockInactivityTracker : public InactivtyTracker
+{
+public:
+    MOCK_METHOD1(enable_inactivity_timers, void(bool));
+};
+
+class MockSystem : public System
+{
+public:
+    MOCK_METHOD0(shutdown,void());
+};
+
+class PowerKeyMediatorTest : public ::testing::Test
+{
+public:
+    ::testing::NiceMock<MockInactivityTracker> mock_tracker;
+    ::testing::NiceMock<MockDBusScreenObserver> mock_screen_observer;
+    ::testing::NiceMock<MockSystem> mock_system;
+    usc::PowerKeyMediator key_mediator{mock_screen_observer, mock_tracker, mock_system};
+};
+
+TEST_F(PowerKeyMediatorTest, power_key_down_disables_inactivity_timers)
+{
+    EXPECT_CALL(mock_tracker, enable_inactivity_timers(false)).Times(3);
+
+    key_mediator.power_key_down();
+    key_mediator.power_key_short();
+    key_mediator.power_key_up();
+
+    key_mediator.power_key_down();
+    key_mediator.power_key_long();
+    key_mediator.power_key_up();
+
+    key_mediator.power_key_down();
+    key_mediator.power_key_very_long();
+    key_mediator.power_key_up();
+}
+
+TEST_F(PowerKeyMediatorTest, power_key_short_sequence_toggles_screen_power_state)
+{
+    EXPECT_CALL(mock_screen_observer, toggle_screen_power_mode(PowerStateChangeReason::power_key));
+
+    key_mediator.power_key_down();
+    key_mediator.power_key_short();
+    key_mediator.power_key_up();
+}
+
+TEST_F(PowerKeyMediatorTest, power_key_long_sequence_forces_power_on_screen_state)
+{
+    EXPECT_CALL(mock_screen_observer, set_screen_power_mode(
+        MirPowerMode::mir_power_mode_on, PowerStateChangeReason::power_key));
+
+    key_mediator.power_key_down();
+    key_mediator.power_key_long();
+    key_mediator.power_key_up();
+}
+
+TEST_F(PowerKeyMediatorTest, power_key_very_long_sequence_forces_power_off_screen_state_and_shutdown)
+{
+    EXPECT_CALL(mock_screen_observer, set_screen_power_mode(
+        MirPowerMode::mir_power_mode_off, PowerStateChangeReason::power_key));
+    EXPECT_CALL(mock_system,shutdown());
+
+    key_mediator.power_key_down();
+    key_mediator.power_key_very_long();
+    key_mediator.power_key_up();
+}
+
+TEST_F(PowerKeyMediatorTest, screen_toggle_can_be_deactivated)
+{
+    EXPECT_CALL(mock_screen_observer, toggle_screen_power_mode(PowerStateChangeReason::power_key))
+        .Times(0);
+
+    key_mediator.disable_screen_toggle();
+
+    key_mediator.power_key_down();
+    key_mediator.power_key_short();
+    key_mediator.power_key_up();
+}
+
+TEST_F(PowerKeyMediatorTest, screen_toggle_can_be_deactivated_during_key_down)
+{
+    EXPECT_CALL(mock_screen_observer, toggle_screen_power_mode(PowerStateChangeReason::power_key))
+        .Times(0);
+
+    key_mediator.power_key_down();
+
+    key_mediator.disable_screen_toggle();
+
+    key_mediator.power_key_short();
+    key_mediator.power_key_up();
+}
+
+TEST_F(PowerKeyMediatorTest, screen_toggle_can_be_reactivated)
+{
+    EXPECT_CALL(mock_screen_observer, toggle_screen_power_mode(PowerStateChangeReason::power_key))
+        .Times(1);
+
+    key_mediator.disable_screen_toggle();
+
+    key_mediator.power_key_down();
+    key_mediator.power_key_short();
+    key_mediator.power_key_up();
+
+    key_mediator.enable_screen_toggle();
+
+    key_mediator.power_key_down();
+    key_mediator.power_key_short();
+    key_mediator.power_key_up();
+}