Merge lp:~afrantzis/unity-system-compositor/notification-timeouts into lp:unity-system-compositor

[Alexandros Frantzis]

Support different screen timeout values for notifications.

Support different screen timeout values for notifications.

The notification timeouts are configurable during USC startup as Mir options (either command line or env. variables). Their default values are 15s for power-off and 12s for dimming.

Other components that want to wake the screen up for a notification need to use the existing dbus method:

com.canonical.Unity.Screen.setScreenPowerMode(mode, reason)

with mode 1 (on) and reason 'notification' (= integer value 4)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:230
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/246/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-wily-amd64-ci/34
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-wily-armhf-ci/34
        deb: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-wily-armhf-ci/34/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-wily-i386-ci/34

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

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

Looks reasonable

review: Approve

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-04-07 13:36:48 +0000
+++ src/CMakeLists.txt	2015-07-15 14:20:45 +0000
@@ -25,6 +25,7 @@
   screen_event_handler.cpp
   server.cpp
   session_switcher.cpp
+  steady_clock.cpp
   system_compositor.cpp
   thread_name.cpp
   unity_screen_service.cpp

=== added file 'src/clock.h'
--- src/clock.h	1970-01-01 00:00:00 +0000
+++ src/clock.h	2015-07-15 14:20:45 +0000
@@ -0,0 +1,41 @@
+/*
+ * 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_CLOCK_H_
+#define USC_CLOCK_H_
+
+#include <mir/time/types.h>
+#include <chrono>
+
+namespace usc
+{
+
+class Clock
+{
+public:
+    virtual ~Clock() = default;
+
+    virtual mir::time::Timestamp now() const = 0;
+
+protected:
+    Clock() = default;
+    Clock(Clock const&) = delete;
+    Clock& operator=(Clock const&) = delete;
+};
+
+}
+
+#endif

=== modified file 'src/mir_screen.cpp'
--- src/mir_screen.cpp	2015-04-22 21:01:37 +0000
+++ src/mir_screen.cpp	2015-07-15 14:20:45 +0000
@@ -15,6 +15,7 @@
  */
 
 #include "mir_screen.h"
+#include "clock.h"
 
 #include <mir/main_loop.h>
 #include <mir/time/alarm_factory.h>
@@ -37,19 +38,21 @@
     std::shared_ptr<mir::graphics::Display> const& display,
     std::shared_ptr<mir::input::TouchVisualizer> const& touch_visualizer,
     std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory,
-    std::chrono::milliseconds power_off_timeout,
-    std::chrono::milliseconds dimmer_timeout)
+    std::shared_ptr<usc::Clock> const& clock,
+    Timeouts inactivity_timeouts,
+    Timeouts notification_timeouts)
     : screen_hardware{screen_hardware},
       compositor{compositor},
       display{display},
       touch_visualizer{touch_visualizer},
       alarm_factory{alarm_factory},
+      clock{clock},
       power_off_alarm{alarm_factory->create_alarm(
               std::bind(&usc::MirScreen::power_off_alarm_notification, this))},
       dimmer_alarm{alarm_factory->create_alarm(
               std::bind(&usc::MirScreen::dimmer_alarm_notification, this))},
-      power_off_timeout{power_off_timeout},
-      dimming_timeout{dimmer_timeout},
+      inactivity_timeouts(inactivity_timeouts),
+      notification_timeouts(notification_timeouts),
       current_power_mode{MirPowerMode::mir_power_mode_on},
       restart_timers{true},
       power_state_change_handler{[](MirPowerMode,PowerStateChangeReason){}}
@@ -60,7 +63,7 @@
      * to this point. See bug #1410381.
      */
     compositor->start();
-    reset_timers_l();
+    reset_timers_l(PowerStateChangeReason::inactivity);
 }
 
 usc::MirScreen::~MirScreen() = default;
@@ -68,7 +71,7 @@
 void usc::MirScreen::keep_display_on_temporarily()
 {
     std::lock_guard<std::mutex> lock{guard};
-    reset_timers_l();
+    reset_timers_l(PowerStateChangeReason::inactivity);
     if (current_power_mode == MirPowerMode::mir_power_mode_on)
         screen_hardware->set_normal_backlight();
 }
@@ -121,13 +124,13 @@
     std::chrono::seconds the_dimming_timeout{raw_dimmer_timeout};
 
     if (raw_poweroff_timeout >= 0)
-        power_off_timeout = std::chrono::duration_cast<std::chrono::milliseconds>(the_power_off_timeout);
+        inactivity_timeouts.power_off_timeout = std::chrono::duration_cast<std::chrono::milliseconds>(the_power_off_timeout);
 
     if (raw_dimmer_timeout >= 0)
-        dimming_timeout = std::chrono::duration_cast<std::chrono::milliseconds>(the_dimming_timeout);
+        inactivity_timeouts.dimming_timeout = std::chrono::duration_cast<std::chrono::milliseconds>(the_dimming_timeout);
 
     cancel_timers_l();
-    reset_timers_l();
+    reset_timers_l(PowerStateChangeReason::inactivity);
 }
 
 void usc::MirScreen::set_screen_power_mode_l(MirPowerMode mode, PowerStateChangeReason reason)
@@ -138,7 +141,7 @@
         if (current_power_mode == MirPowerMode::mir_power_mode_on)
             screen_hardware->set_normal_backlight();
         configure_display_l(mode, reason);
-        reset_timers_l();
+        reset_timers_l(reason);
     }
     else
     {
@@ -194,38 +197,67 @@
 {
     power_off_alarm->cancel();
     dimmer_alarm->cancel();
+    next_power_off = {};
+    next_dimming = {};
 }
 
-void usc::MirScreen::reset_timers_l()
+void usc::MirScreen::reset_timers_l(PowerStateChangeReason reason)
 {
     if (restart_timers && current_power_mode != MirPowerMode::mir_power_mode_off)
     {
-        if (power_off_timeout.count() > 0)
-            power_off_alarm->reschedule_in(power_off_timeout);
-
-        if (dimming_timeout.count() > 0)
-            dimmer_alarm->reschedule_in(dimming_timeout);
+        auto const timeouts = timeouts_for(reason);
+        auto const now = clock->now();
+
+        if (timeouts.power_off_timeout.count() > 0)
+        {
+            auto const new_next_power_off = now + timeouts.power_off_timeout;
+            if (new_next_power_off > next_power_off)
+            {
+                power_off_alarm->reschedule_in(timeouts.power_off_timeout);
+                next_power_off = new_next_power_off;
+            }
+        }
+
+        if (timeouts.dimming_timeout.count() > 0)
+        {
+            auto const new_next_dimming = now + timeouts.dimming_timeout;
+            if (new_next_dimming > next_dimming)
+            {
+                dimmer_alarm->reschedule_in(timeouts.dimming_timeout);
+                next_dimming = new_next_dimming;
+            }
+        }
     }
 }
 
 void usc::MirScreen::enable_inactivity_timers_l(bool enable)
 {
     if (enable)
-        reset_timers_l();
+        reset_timers_l(PowerStateChangeReason::inactivity);
     else
         cancel_timers_l();
 }
 
+usc::MirScreen::Timeouts usc::MirScreen::timeouts_for(PowerStateChangeReason reason)
+{
+    if (reason == PowerStateChangeReason::notification)
+        return notification_timeouts;
+    else
+        return inactivity_timeouts;
+}
+
 void usc::MirScreen::power_off_alarm_notification()
 {
     std::lock_guard<std::mutex> lock{guard};
     configure_display_l(MirPowerMode::mir_power_mode_off, PowerStateChangeReason::inactivity);
+    next_power_off = {};
 }
 
 void usc::MirScreen::dimmer_alarm_notification()
 {
     std::lock_guard<std::mutex> lock{guard};
     screen_hardware->set_dim_backlight();
+    next_dimming = {};
 }
 
 void usc::MirScreen::set_touch_visualization_enabled(bool enabled)

=== modified file 'src/mir_screen.h'
--- src/mir_screen.h	2015-04-22 21:01:37 +0000
+++ src/mir_screen.h	2015-07-15 14:20:45 +0000
@@ -18,6 +18,7 @@
 #define USC_MIR_SCREEN_H_
 
 #include "screen.h"
+#include <mir/time/types.h>
 
 #include <chrono>
 #include <memory>
@@ -37,17 +38,25 @@
 {
 class Server;
 class ScreenHardware;
+class Clock;
 
 class MirScreen: public Screen
 {
 public:
+    struct Timeouts
+    {
+        std::chrono::milliseconds power_off_timeout;
+        std::chrono::milliseconds dimming_timeout;
+    };
+
     MirScreen(std::shared_ptr<usc::ScreenHardware> const& screen_hardware,
               std::shared_ptr<mir::compositor::Compositor> const& compositor,
               std::shared_ptr<mir::graphics::Display> const& display,
               std::shared_ptr<mir::input::TouchVisualizer> const& touch_visualizer,
               std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory,
-              std::chrono::milliseconds power_off_timeout,
-              std::chrono::milliseconds dimmer_timeout);
+              std::shared_ptr<usc::Clock> const& clock,
+              Timeouts inactivity_timeouts,
+              Timeouts notification_timeouts);
     ~MirScreen();
 
     void enable_inactivity_timers(bool enable) override;
@@ -69,8 +78,9 @@
     void configure_display_l(MirPowerMode mode, PowerStateChangeReason reason);
 
     void cancel_timers_l();
-    void reset_timers_l();
+    void reset_timers_l(PowerStateChangeReason reason);
     void enable_inactivity_timers_l(bool flag);
+    Timeouts timeouts_for(PowerStateChangeReason reason);
 
     void power_off_alarm_notification();
     void dimmer_alarm_notification();
@@ -81,12 +91,15 @@
     std::shared_ptr<mir::graphics::Display> const display;
     std::shared_ptr<mir::input::TouchVisualizer> const touch_visualizer;
     std::shared_ptr<mir::time::AlarmFactory> const alarm_factory;
+    std::shared_ptr<usc::Clock> const clock;
     std::unique_ptr<mir::time::Alarm> const power_off_alarm;
     std::unique_ptr<mir::time::Alarm> const dimmer_alarm;
 
     std::mutex guard;
-    std::chrono::milliseconds power_off_timeout;
-    std::chrono::milliseconds dimming_timeout;
+    Timeouts inactivity_timeouts;
+    Timeouts notification_timeouts;
+    mir::time::Timestamp next_power_off{};
+    mir::time::Timestamp next_dimming{};
     MirPowerMode current_power_mode;
     bool restart_timers;
     PowerStateChangeHandler power_state_change_handler;

=== modified file 'src/power_state_change_reason.h'
--- src/power_state_change_reason.h	2014-06-17 00:35:13 +0000
+++ src/power_state_change_reason.h	2015-07-15 14:20:45 +0000
@@ -22,7 +22,8 @@
     unknown = 0,
     inactivity = 1,
     power_key = 2,
-    proximity = 3
+    proximity = 3,
+    notification = 4
 };
 
 #endif

=== modified file 'src/server.cpp'
--- src/server.cpp	2015-06-03 16:21:07 +0000
+++ src/server.cpp	2015-07-15 14:20:45 +0000
@@ -25,6 +25,7 @@
 #include "screen_event_handler.h"
 #include "powerd_mediator.h"
 #include "unity_screen_service.h"
+#include "steady_clock.h"
 
 #include <mir/input/cursor_listener.h>
 #include <mir/server_status_listener.h>
@@ -117,6 +118,8 @@
     add_configuration_option("shutdown-timeout", "The time in milli-seconds the power key must be held to initiate a clean system shutdown",  mir::OptionType::integer);
     add_configuration_option("power-key-ignore-timeout", "The time in milli-seconds the power key must be held to ignore - must be less than shutdown-timeout",  mir::OptionType::integer);
     add_configuration_option("disable-inactivity-policy", "Disables handling user inactivity and power key",  mir::OptionType::boolean);
+    add_configuration_option("notification-display-off-timeout", "The time in seconds before the screen is turned off after a notification arrives",  mir::OptionType::integer);
+    add_configuration_option("notification-display-dim-timeout", "The time in seconds before the screen is dimmed after a notification arrives",  mir::OptionType::integer);
 
     set_command_line(argc, const_cast<char const **>(argv));
 
@@ -237,8 +240,13 @@
                 the_display(),
                 the_touch_visualizer(),
                 the_main_loop(),
-                inactivity_display_off_timeout(),
-                inactivity_display_dim_timeout());
+                the_clock(),
+                MirScreen::Timeouts{
+                    inactivity_display_off_timeout(),
+                    inactivity_display_dim_timeout()},
+                MirScreen::Timeouts{
+                    notification_display_off_timeout(),
+                    notification_display_dim_timeout()});
         });
 }
 
@@ -276,6 +284,15 @@
         });
 }
 
+std::shared_ptr<usc::Clock> usc::Server::the_clock()
+{
+    return clock(
+        [this]
+        {
+            return std::make_shared<SteadyClock>();
+        });
+}
+
 std::string usc::Server::dbus_bus_address()
 {
     static char const* const default_bus_address{"unix:path=/var/run/dbus/system_bus_socket"};

=== modified file 'src/server.h'
--- src/server.h	2015-04-24 14:40:28 +0000
+++ src/server.h	2015-07-15 14:20:45 +0000
@@ -42,6 +42,7 @@
 class Screen;
 class ScreenHardware;
 class UnityScreenService;
+class Clock;
 
 class Server : private mir::Server
 {
@@ -63,6 +64,7 @@
     virtual std::shared_ptr<mir::input::EventFilter> the_screen_event_handler();
     virtual std::shared_ptr<ScreenHardware> the_screen_hardware();
     virtual std::shared_ptr<UnityScreenService> the_unity_screen_service();
+    virtual std::shared_ptr<Clock> the_clock();
 
     bool show_version()
     {
@@ -110,6 +112,20 @@
             seconds{the_options()->get("inactivity-display-dim-timeout", 45)});
     }
 
+    std::chrono::milliseconds notification_display_off_timeout()
+    {
+        using namespace std::chrono;
+        return duration_cast<milliseconds>(
+            seconds{the_options()->get("notification-display-off-timeout", 15)});
+    }
+
+    std::chrono::milliseconds notification_display_dim_timeout()
+    {
+        using namespace std::chrono;
+        return duration_cast<milliseconds>(
+            seconds{the_options()->get("notification-display-dim-timeout", 12)});
+    }
+
     std::chrono::milliseconds shutdown_timeout()
     {
         return std::chrono::milliseconds{
@@ -145,6 +161,7 @@
     mir::CachedPtr<mir::input::EventFilter> screen_event_handler;
     mir::CachedPtr<ScreenHardware> screen_hardware;
     mir::CachedPtr<UnityScreenService> unity_screen_service;
+    mir::CachedPtr<Clock> clock;
 };
 
 }

=== added file 'src/steady_clock.cpp'
--- src/steady_clock.cpp	1970-01-01 00:00:00 +0000
+++ src/steady_clock.cpp	2015-07-15 14:20:45 +0000
@@ -0,0 +1,22 @@
+/*
+ * 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/>.
+ */
+
+#include "steady_clock.h"
+
+mir::time::Timestamp usc::SteadyClock::now() const
+{
+    return clock.now();
+}

=== added file 'src/steady_clock.h'
--- src/steady_clock.h	1970-01-01 00:00:00 +0000
+++ src/steady_clock.h	2015-07-15 14:20:45 +0000
@@ -0,0 +1,36 @@
+/*
+ * 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_STEADY_CLOCK_H_
+#define USC_STEADY_CLOCK_H_
+
+#include "clock.h"
+
+namespace usc
+{
+
+class SteadyClock : public Clock
+{
+public:
+    mir::time::Timestamp now() const override;
+
+private:
+    std::chrono::steady_clock clock;
+};
+
+}
+
+#endif

=== modified file 'tests/unit-tests/advanceable_timer.cpp'
--- tests/unit-tests/advanceable_timer.cpp	2015-03-16 10:24:45 +0000
+++ tests/unit-tests/advanceable_timer.cpp	2015-07-15 14:20:45 +0000
@@ -123,14 +123,8 @@
 std::unique_ptr<mir::time::Alarm> AdvanceableTimer::create_alarm(
     std::function<void()> const& callback)
 {
-    decltype(now) now_tmp;
-    {
-        std::lock_guard<std::mutex> lock{now_mutex};
-        now_tmp = now;
-    }
-
     auto const adv_alarm =
-        std::make_shared<detail::AdvanceableAlarm>(now_tmp, callback);
+        std::make_shared<detail::AdvanceableAlarm>(now(), callback);
 
     register_alarm(adv_alarm);
 
@@ -147,7 +141,7 @@
 {
     {
         std::lock_guard<std::mutex> lock{now_mutex};
-        now += advance;
+        now_ += advance;
     }
     trigger_alarms();
 }
@@ -189,13 +183,7 @@
         if (alarm)
         {
             lock.unlock();
-            decltype(now) now_tmp;
-            {
-                std::lock_guard<std::mutex> lock{now_mutex};
-                now_tmp = now;
-            }
-
-            alarm->update_now(now_tmp);
+            alarm->update_now(now());
             lock.lock();
         }
     }
@@ -209,3 +197,9 @@
             }),
         end(alarms));
 }
+
+mir::time::Timestamp AdvanceableTimer::now() const
+{
+    std::lock_guard<std::mutex> lock{now_mutex};
+    return now_;
+}

=== modified file 'tests/unit-tests/advanceable_timer.h'
--- tests/unit-tests/advanceable_timer.h	2015-03-16 10:24:45 +0000
+++ tests/unit-tests/advanceable_timer.h	2015-07-15 14:20:45 +0000
@@ -20,6 +20,7 @@
 #define USC_TESTS_ADVANCEABLE_TIMER_H_
 
 #include <mir/time/alarm_factory.h>
+#include "src/clock.h"
 
 #include <vector>
 #include <mutex>
@@ -30,22 +31,26 @@
 class AdvanceableAlarm;
 }
 
-class AdvanceableTimer : public mir::time::AlarmFactory
+class AdvanceableTimer : public mir::time::AlarmFactory, public usc::Clock
 {
 public:
+    // mir::time::AlarmFactory
     std::unique_ptr<mir::time::Alarm> create_alarm(
         std::function<void()> const& callback) override;
     std::unique_ptr<mir::time::Alarm> create_alarm(
         std::shared_ptr<mir::LockableCallback> const& callback) override;
 
+    // usc::Clock
+    mir::time::Timestamp now() const override;
+
     void advance_by(std::chrono::milliseconds advance);
 
 private:
     void register_alarm(std::shared_ptr<detail::AdvanceableAlarm> const& alarm);
     void trigger_alarms();
 
-    std::mutex now_mutex;
-    mir::time::Timestamp now{};
+    mutable std::mutex now_mutex;
+    mir::time::Timestamp now_{};
     std::mutex alarms_mutex;
     std::vector<std::weak_ptr<detail::AdvanceableAlarm>> alarms;
 };

=== modified file 'tests/unit-tests/test_mir_screen.cpp'
--- tests/unit-tests/test_mir_screen.cpp	2015-04-29 14:30:49 +0000
+++ tests/unit-tests/test_mir_screen.cpp	2015-07-15 14:20:45 +0000
@@ -129,8 +129,17 @@
 
 struct AMirScreen : testing::Test
 {
-    std::chrono::milliseconds power_off_timeout{5000};
-    std::chrono::milliseconds dimmer_timeout{4000};
+    std::chrono::seconds const power_off_timeout{60};
+    std::chrono::seconds const dimmer_timeout{50};
+    std::chrono::seconds const notification_power_off_timeout{15};
+    std::chrono::seconds const notification_dimmer_timeout{12};
+
+    std::chrono::seconds const five_seconds{5};
+    std::chrono::seconds const ten_seconds{10};
+    std::chrono::seconds const fifteen_seconds{15};
+    std::chrono::seconds const thirty_seconds{30};
+    std::chrono::seconds const fourty_seconds{40};
+    std::chrono::seconds const fifty_seconds{50};
 
     void expect_screen_is_turned_off()
     {
@@ -201,8 +210,9 @@
         display,
         touch_visualizer,
         timer,
-        power_off_timeout,
-        dimmer_timeout};
+        timer,
+        {power_off_timeout, dimmer_timeout},
+        {notification_power_off_timeout, notification_dimmer_timeout}};
 };
 
 }
@@ -259,31 +269,31 @@
 TEST_F(AMirScreen, keeps_screen_on_temporarily_when_already_on)
 {
     using namespace testing;
-    std::chrono::seconds const three_seconds{3};
-    std::chrono::seconds const one_second{1};
+    std::chrono::seconds const fourty_seconds{40};
+    std::chrono::seconds const ten_seconds{10};
 
     expect_no_reconfiguration();
 
     // After keep_display_on_temporarily the timeouts should
     // be reset...
-    timer->advance_by(three_seconds);
+    timer->advance_by(fourty_seconds);
     mir_screen.keep_display_on_temporarily();
 
-    // ... so 3 seconds after the reset (total 6 from start)
+    // ... so 40 seconds after the reset (total 80 from start)
     // should trigger neither dim nor power off
-    timer->advance_by(three_seconds);
+    timer->advance_by(fourty_seconds);
 
     verify_and_clear_expectations();
 
-    // A second more, 4 seconds from reset, the screen should dim
+    // Tens seconds more, 50 seconds from reset, the screen should dim
     expect_screen_is_turned_dim();
-    timer->advance_by(one_second);
+    timer->advance_by(ten_seconds);
 
     verify_and_clear_expectations();
 
-    // A second more, 5 seconds from reset, the screen should power off
+    // Ten seconds second more, 60 seconds from reset, the screen should power off
     expect_screen_is_turned_off();
-    timer->advance_by(one_second);
+    timer->advance_by(ten_seconds);
 
     verify_and_clear_expectations();
 }
@@ -367,3 +377,132 @@
     EXPECT_THAT(handler_reason, Eq(toggle_reason));
     EXPECT_THAT(handler_mode, Eq(MirPowerMode::mir_power_mode_off));
 }
+
+TEST_F(AMirScreen, turns_screen_off_after_15s_for_notification)
+{
+    turn_screen_off();
+
+    expect_screen_is_turned_on();
+    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
+                                     PowerStateChangeReason::notification);
+    verify_and_clear_expectations();
+
+    expect_screen_is_turned_off();
+    timer->advance_by(notification_power_off_timeout);
+}
+
+TEST_F(AMirScreen, keep_display_on_temporarily_overrides_notification_timeout)
+{
+    turn_screen_off();
+
+    expect_screen_is_turned_on();
+    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
+                                     PowerStateChangeReason::notification);
+    verify_and_clear_expectations();
+
+    // At T=10 we request a temporary keep display on (e.g. user has touched
+    // the screen)
+    timer->advance_by(ten_seconds);
+    mir_screen.keep_display_on_temporarily();
+
+    // At T=20 nothing should happen since keep display on temporarily
+    // has reset the timers (so the notification timeout of 15s is overriden).
+    expect_no_reconfiguration();
+    timer->advance_by(ten_seconds);
+    verify_and_clear_expectations();
+
+    // At T=70 (10 + 60) the screen should turn off due to the normal
+    // inactivity timeout
+    expect_screen_is_turned_off();
+    timer->advance_by(fifty_seconds);
+}
+
+TEST_F(AMirScreen, notification_timeout_extends_active_timeout)
+{
+    // At T=0 we turn the screen on, and normal inactivity timeouts
+    // are reset
+    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
+                                     PowerStateChangeReason::power_key);
+
+    // At T=50 we get a notification
+    timer->advance_by(fifty_seconds);
+    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
+                                     PowerStateChangeReason::notification);
+    verify_and_clear_expectations();
+
+    // At T=60 the screen should still be active because the notification
+    // has extended the timeout.
+    expect_no_reconfiguration();
+    timer->advance_by(ten_seconds);
+    verify_and_clear_expectations();
+
+    // At T=65 (50 + 15) the screen should turn off due to the notification
+    // inactivity timeout
+    expect_screen_is_turned_off();
+    timer->advance_by(five_seconds);
+}
+
+TEST_F(AMirScreen, notification_timeout_does_not_reduce_active_timeout)
+{
+    // At T=0 we turn the screen on, and normal inactivity timeouts
+    // are reset
+    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
+                                     PowerStateChangeReason::power_key);
+
+
+    // At T=30 we get a notification
+    timer->advance_by(thirty_seconds);
+    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
+                                     PowerStateChangeReason::notification);
+    verify_and_clear_expectations();
+
+    // At T=45 the screen should still be active because the notification
+    // has not reduced the active timeout.
+    expect_no_reconfiguration();
+    timer->advance_by(fifteen_seconds);
+    verify_and_clear_expectations();
+
+    // At T=50 the screen should be dimmed
+    expect_screen_is_turned_dim();
+    timer->advance_by(five_seconds);
+    verify_and_clear_expectations();
+
+    // At T=60 the screen should turn off due to the normal
+    // inactivity timeout
+    expect_screen_is_turned_off();
+    timer->advance_by(ten_seconds);
+}
+
+TEST_F(AMirScreen, notification_timeout_can_extend_only_dimming)
+{
+    std::chrono::seconds const two_seconds{2};
+    std::chrono::seconds const eight_seconds{8};
+
+    // At T=0 we turn the screen on, and normal inactivity timeouts
+    // are reset
+    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
+                                     PowerStateChangeReason::power_key);
+
+    // At T=40 we get a notification
+    timer->advance_by(fourty_seconds);
+    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
+                                     PowerStateChangeReason::notification);
+    verify_and_clear_expectations();
+
+    // At T=50 nothing should happen since the notification has
+    // extended the dimming timeout
+    expect_no_reconfiguration();
+    timer->advance_by(ten_seconds);
+    verify_and_clear_expectations();
+
+    // At T=52 (40 + 12) screen should be dimmed due to the notification
+    // dimming timeout
+    expect_screen_is_turned_dim();
+    timer->advance_by(two_seconds);
+    verify_and_clear_expectations();
+
+    // At T=60 the screen should turn off due to the normal
+    // inactivity timeout
+    expect_screen_is_turned_off();
+    timer->advance_by(eight_seconds);
+}