Mir

Merge lp:~andreas-pokorny/mir/add-timer-to-main-loop into lp:mir

add-timer-to-main-loop
Merge into development-branch

Proposed by Andreas Pokorny on 2014-04-23

Status:	Merged
Approved by:	kevin gunn on 2014-05-13
Approved revision:	no longer in the source branch.
Merged at revision:	1626
Proposed branch:	lp:~andreas-pokorny/mir/add-timer-to-main-loop
Merge into:	lp:mir
Diff against target:	909 lines (+694/-34) 12 files modified include/server/mir/asio_main_loop.h (+5/-0) include/server/mir/main_loop.h (+2/-1) include/server/mir/time/alarm.h (+86/-0) include/server/mir/time/timer.h (+70/-0) include/test/mir_test/wait_object.h (+58/-0) include/test/mir_test_doubles/stub_timer.h (+70/-0) src/server/asio_main_loop.cpp (+138/-0) tests/integration-tests/client/test_screencast.cpp (+5/-32) tests/mir_test/CMakeLists.txt (+2/-1) tests/mir_test/wait_object.cpp (+35/-0) tests/unit-tests/graphics/mesa/test_linux_virtual_terminal.cpp (+1/-0) tests/unit-tests/test_asio_main_loop.cpp (+222/-0)
To merge this branch:	bzr merge lp:~andreas-pokorny/mir/add-timer-to-main-loop
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration		Approve on 2014-05-13
Alberto Aguirre (community)			Approve on 2014-05-13
Alexandros Frantzis (community)			Approve on 2014-05-13
Daniel van Vugt			Needs Fixing on 2014-05-13
Chris Halse Rogers			Approve on 2014-05-13
Alan Griffiths		2014-04-23	Abstain on 2014-05-12
Kevin DuBois (community)			Needs Information on 2014-04-25
Review via email: mp+216881@code.launchpad.net

Commit message

Shameless Copy of Christopher Halse Rogers Timer extension

This version is an untouched copy of the Timer/Alarm changes proposed
with the 1hz-rendering-always branch. This extension is especially helpful
for a clean implementation of the ANR detection when sending input events

Description of the change

This is Christophers Timer code which was provided in the 1hz-rendering-always branch. Since the future of the MP is unsure I propose adding this part to mir/devel. Should be rejected if the other one hits devel..

This functionality is helpful for implementing the application-not-responding treatment for the input sender split. So part of the input improvements for qt based unity8 compositor in mir.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-04-23:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1384/rebuild

review: Approve (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-04-23:

I can't help wondering why Timer & Alarm are not in namespace mir::time

But I suspect the answer will be "I'm just copying code".

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-04-23:

108 + virtual bool reschedule_in(std::chrono::milliseconds delay) = 0;

It would probably be useful to have "reschedule_for(mir::time::Timestamp timeout_time)" too.

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-04-23:

I'm a bit concerned about using real time intervals in tests - and not mocking out the clock. (And the above)

Will think more prescriptively tomorrow.

review: Abstain

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2014-04-24:

> I'm a bit concerned about using real time intervals in tests - and not mocking
> out the clock. (And the above)
>
> Will think more prescriptively tomorrow.

We could mock it in unit tests and have some that uses the clock in integration tests.

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2014-04-24:

So far addressed apart from:

> I'm a bit concerned about using real time intervals in tests - and not mocking
> out the clock. (And the above)

Need to dig deeper into asio to understand if that is possible with reasonable effort.

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-04-24:

> Will think more prescriptively tomorrow.

Sorry, been sidetracked by trust session work.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-04-24:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1397/rebuild

review: Approve (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-04-24:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1400/rebuild

review: Approve (continuous-integration)

Revision history for this message

Kevin DuBois (kdub) wrote on 2014-04-25:

could the branch be stacked upon the 1hz renderering branch somehow? some of the review comments there apply here too.

review: Needs Information

Revision history for this message

Chris Halse Rogers (raof) wrote on 2014-04-25:

I'll rebase the 1hz rendering branch on this, when it's not a public holiday.

Revision history for this message

Chris Halse Rogers (raof) wrote on 2014-04-28:

I'm not sure we need reschedule_for / notify_at (which is why I didn't add them), but they're obvious things we might want to do in the future. +0.

590 + MOCK_METHOD2(notify_in_delegate,
591 + mir::time::Alarm*(std::chrono::milliseconds,
592 + std::function<void()>));
593 +
594 + std::unique_ptr<mir::time::Alarm> notify_in(std::chrono::milliseconds delay,
595 + std::function<void()> callback)
596 + {
597 + return std::unique_ptr<mir::time::Alarm>{notify_in_delegate(delay, callback)};
598 + }

I have recently discovered that we have mir_test/gmock_fixes.h, which allows us to directly return a std::unique_ptr from a mock. The mock object should use this, rather than this indirection trick.

816 + // Somewhat counterintuitively we need some work on the mainloop to keep it running.
817 + auto dummy_alarm = ml.notify_in(std::chrono::milliseconds{1000}, [](){});

The comment (and all the other ones to that effect) is no longer true; you've pulled in the test and io::work that resolves it.

review: Needs Fixing

Revision history for this message

Alexandros Frantzis (afrantzis) wrote on 2014-04-28:

320 + void notify_done();
323 + template<typename rep, typename period>
324 + bool wait_for(std::chrono::duration<rep, period> delay);

I got confused trying to figure out how these operations are related to the WatchDog object lifecycle, and it seems the answer is that they are not related at all, they are there only for convenience. It would be cleaner to move them to a separate object, e.g. a WaitObject (see tests/integration-tests/client/test_screencast.cpp for a class with similar functionality).

761 + runner.notify_done();

Not needed.

704 + EXPECT_TRUE(runner.wait_for(std::chrono::milliseconds{100}));
729 + EXPECT_TRUE(runner.wait_for(std::chrono::milliseconds{100}));
...

I am wary of these expectations. It's conceivable that heavy loads in our CI builders could cause significant delays, enough for these tests to fail.

review: Needs Fixing

Revision history for this message

Alexandros Frantzis (afrantzis) wrote on 2014-04-28:

> I am wary of these expectations. It's conceivable that heavy loads in our CI builders could
> cause significant delays, enough for these tests to fail.

This is not a blocker, but we should keep an eye out for such failures and react accordingly.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-04-28:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1414/rebuild

review: Approve (continuous-integration)

Revision history for this message

Alberto Aguirre (albaguirre) wrote on 2014-04-29:

Not blocking:

691 +TEST(AsioMainLoopTest, alarm_fires_with_correct_delay)
865 +TEST(AsioMainLoopTest, alarm_fires_at_correct_time_point)

The test names are misleading as there are no expectations setup to actually test what the name implies; but I can see that would be tricky to do and satisfy the expectations under valgrind and CI.

750 + EXPECT_EQ(mir::time::Alarm::Triggered, alarm->state());
766 + EXPECT_EQ(mir::time::Alarm::Pending, alarm->state());
784 + EXPECT_EQ(mir::time::Alarm::Cancelled, alarm->state());
833 + ASSERT_EQ(mir::time::Alarm::Triggered, alarm->state());
835 + EXPECT_EQ(mir::time::Alarm::Pending, alarm->state())
838 + EXPECT_EQ(mir::time::Alarm::Triggered, alarm->state());
861 + EXPECT_EQ(mir::time::Alarm::Triggered, alarm->state())

These would read better as EXPECT_THAT(alarm->state(), Eq(mir::time::Alarm::Triggered)); etc...

841 +TEST(AsioMainLoopTest, rescheduled_alarm_cancels_previous_scheduling)
857 + EXPECT_TRUE(alarm->reschedule_in(std::chrono::milliseconds{150}));
858 + EXPECT_EQ(mir::time::Alarm::Pending, alarm->state());
859 +
860 + EXPECT_TRUE(runner.wait_for(std::chrono::milliseconds{500}));
861 + EXPECT_EQ(mir::time::Alarm::Triggered, alarm->state());
862 + EXPECT_EQ(1, call_count);
863 +}

What if the previous scheduling fires? Line 860-862 could still run and satisfy the expectations. Given the current implementation this again requires checking time intervals so not blocking for this.

review: Approve

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-04-29:

79 + enum State
80 + {
81 + Pending, /**< Will trigger the callback at some point in the future */
82 + Cancelled, /**< The callback has been cancelled before being triggered */
83 + Triggered /**< The callback has been called */
84 + };

Should be "pending", "cancelled" & "triggered"

http://unity.ubuntu.com/mir/cppguide/index.html?showone=Enumerator_Names#Enumerator_Names

review: Needs Fixing

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-04-29:

101 + virtual bool cancel() = 0;

I wonder if it would be more useful to return the "after" state. (Also for other similar functions)

Revision history for this message

Chris Halse Rogers (raof) wrote on 2014-05-05:

@Alan - the state is guaranteed to be either cancelled or triggered, so returning the “after” state is no more useful.

That said, I think it would be more useful if it returned whether or not the cancel had any effect - ie: did it transition from Pending to Cancelled or not?

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-05-09:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1576/rebuild

review: Approve (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-05-12:

I'm not going to block on this, but I am going to mention a concern: This adds another collection of unit tests that are slower than *any* acceptance tests. Vis:

$ ctest | grep sec$ | sort -n -b -k 7,7 -r | head -n 5
73/191 Test #73: mir_unit_tests.BufferQueueTest.* ........................................... Passed 3.71 sec
137/191 Test #137: mir_unit_tests.MultiThreadedCompositor.* ................................... Passed 3.36 sec
69/191 Test #69: mir_unit_tests.AsioMainLoopAlarmTest.* ..................................... Passed 1.08 sec
181/191 Test #181: mir_unit_tests.UdevWrapperDeathTest.* ...................................... Passed 0.51 sec
16/191 Test #16: mir_acceptance_tests.ServerShutdown/OnSignal.* ............................. Passed 0.51 sec

"Unit tests" that take more than milliseconds are a cause for concern. As are tests that rely on the system clock.

review: Abstain

Revision history for this message

Chris Halse Rogers (raof) wrote on 2014-05-13:

This seems OK to me.

While it would be nicer to divorce this from the system clock, I don't think it's really feasible. It looks like it might be possible to wedge in a fake timesource into boost::asio but that looks fraught with fraughtness.

review: Approve

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2014-05-13:

Text conflict in include/server/mir/asio_main_loop.h
Text conflict in include/server/mir/main_loop.h
Text conflict in src/server/asio_main_loop.cpp
Text conflict in tests/unit-tests/test_asio_main_loop.cpp
4 conflicts encountered.

review: Needs Fixing

Revision history for this message

Alexandros Frantzis (afrantzis) wrote on 2014-05-13:

@WaitObject

I recently discovered that we have mt::WaitCondition which provides similar functionality, perhaps we should merge the two classes (not a blocker, we can do this in an upcoming MP).

> I am wary of these expectations. It's conceivable that heavy loads in our CI builders could cause significant delays, enough for these tests to fail.

I am still wary... but let's see...

+class Timer

Our usual style is to make the constructor and deleted CopyAssign protected (not that it makes any practical difference).

review: Approve

Revision history for this message

Alberto Aguirre (albaguirre) wrote on 2014-05-13:

Needs rebasing as Daniel pointed out.

review: Needs Fixing

Revision history for this message

Alberto Aguirre (albaguirre) wrote on 2014-05-13:

LGTM.

review: Approve

Revision history for this message

kevin gunn (kgunn72) wrote on 2014-05-13:

i believe this covers off duflu's "needs fixing" as well.
small note, still missing api to create an unscheduled alarm, but landing now as its a prereq for power changes

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-05-13:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1614/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) on 2014-05-13:

review: Approve (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Andreas Pokorny

Emanuele Antonio Faraone

Gerry Boland

Mir development team

 === modified file 'include/server/mir/asio_main_loop.h'
 --- include/server/mir/asio_main_loop.h	2014-05-08 16:15:26 +0000
 +++ include/server/mir/asio_main_loop.h	2014-05-13 19:41:32 +0000
@@ -49,6 +49,10 @@
          std::initializer_list<int> fd,
          std::function<void(int)> const& handler);
++    std::unique_ptr<time::Alarm> notify_in(std::chrono::milliseconds delay,
++                                           std::function<void()> callback) override;
++    std::unique_ptr<time::Alarm> notify_at(mir::time::Timestamp time_point,
++                                           std::function<void()> callback) override;
      void enqueue(void const* owner, ServerAction const& action);
      void pause_processing_for(void const* owner);
      void resume_processing_for(void const* owner);
@@ -60,6 +64,7 @@
      void process_server_actions();
      boost::asio::io_service io;
++    boost::asio::io_service::work work;
      std::vector<std::unique_ptr<SignalHandler>> signal_handlers;
      std::vector<std::unique_ptr<FDHandler>> fd_handlers;
      std::mutex server_actions_mutex;
 === modified file 'include/server/mir/main_loop.h'
 --- include/server/mir/main_loop.h	2014-05-08 16:15:26 +0000
 +++ include/server/mir/main_loop.h	2014-05-13 19:41:32 +0000
@@ -20,12 +20,13 @@
  #define MIR_MAIN_LOOP_H_
  #include "mir/graphics/event_handler_register.h"
++#include "mir/time/timer.h"
  #include "mir/server_action_queue.h"
  namespace mir
+ {
--class MainLoop : public graphics::EventHandlerRegister,
++class MainLoop : public graphics::EventHandlerRegister, public time::Timer,
                   public ServerActionQueue
+ {
  public:
 === added file 'include/server/mir/time/alarm.h'
 --- include/server/mir/time/alarm.h	1970-01-01 00:00:00 +0000
 +++ include/server/mir/time/alarm.h	2014-05-13 19:41:32 +0000
@@ -0,0 +1,86 @@
++/*
++ * 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: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#ifndef MIR_TIME_ALARM_H_
++#define MIR_TIME_ALARM_H_
++
++#include "mir/time/clock.h"
++
++namespace mir
++{
++namespace time
++{
++
++/**
++ * A one-shot, resettable handle to trigger a callback at a later time
++ * \note All members of Alarm are threadsafe
++ */
++class Alarm
++{
++public:
++    enum State
++    {
++        pending,    /**< Will trigger the callback at some point in the future */
++        cancelled,  /**< The callback has been cancelled before being triggered */
++        triggered   /**< The callback has been called */
++    };
++
++
++    Alarm() = default;
++    /**
++     * \note Destruction of the Alarm guarantees that the callback will not subsequently be called
++     */
++    virtual ~Alarm() = default;
++
++    /**
++     * Cancels a pending alarm
++     *
++     * \note Has no effect if the Alarm is in the Triggered state.
++     * \note cancel() is idempotent
++     *
++     * \return True iff the state of the Alarm is now Cancelled
++     */
++    virtual bool cancel() = 0;
++    virtual State state() const = 0;
++
++    /**
++     * Reschedule the alarm
++     * \param delay    Delay, in milliseconds, before the Alarm will be triggered
++     * \return         True if this reschedule supercedes a previous not-yet-triggered timeout
++     *
++     * \note This cancels any previous timeout set.
++     */
++    virtual bool reschedule_in(std::chrono::milliseconds delay) = 0;
++
++    /**
++     * Reschedule the alarm
++     * \param timeout  Time point when the alarm should be triggered
++     * \return         True if this reschedule supercedes a previous not-yet-triggered timeout
++     *
++     * \note This cancels any previous timeout set.
++     */
++    virtual bool reschedule_for(Timestamp timeout) = 0;
++
++    Alarm(Alarm const&) = delete;
++    Alarm& operator=(Alarm const&) = delete;
++};
++
++}
++}
++#endif
++
 === added file 'include/server/mir/time/timer.h'
 --- include/server/mir/time/timer.h	1970-01-01 00:00:00 +0000
 +++ include/server/mir/time/timer.h	2014-05-13 19:41:32 +0000
@@ -0,0 +1,70 @@
++/*
++ * 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: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++
++#ifndef MIR_TIME_TIMER_H_
++#define MIR_TIME_TIMER_H_
++
++#include "mir/time/alarm.h"
++
++#include <chrono>
++#include <functional>
++#include <memory>
++
++namespace mir
++{
++namespace time
++{
++
++class Alarm;
++
++class Timer
++{
++public:
++    Timer() = default;
++    virtual ~Timer() = default;
++    /**
++     * \brief Create an Alarm that calls the callback after the specified delay
++     *
++     * \param delay     Time from now, in milliseconds, that the callback will fire
++     * \param callback  Function to call when the Alarm signals
++     *
++     * \return A handle to an Alarm that will fire after delay ms.
++     */
++    virtual std::unique_ptr<Alarm> notify_in(std::chrono::milliseconds delay,
++                                             std::function<void()> callback) = 0;
++    /**
++     * \brief Create an Alarm that calls the callback at the specified time
++     *
++     * \param time_point Time point when the alarm should be triggered
++     * \param callback  Function to call when the Alarm signals
++     *
++     * \return A handle to an Alarm that will fire after delay ms.
++     */
++    virtual std::unique_ptr<Alarm> notify_at(Timestamp time_point,
++                                             std::function<void()> callback) = 0;
++
++
++    Timer(Timer const&) = delete;
++    Timer& operator=(Timer const&) = delete;
++};
++
++}
++}
++
++#endif // MIR_TIME_TIMER_H_
 === added file 'include/test/mir_test/wait_object.h'
 --- include/test/mir_test/wait_object.h	1970-01-01 00:00:00 +0000
 +++ include/test/mir_test/wait_object.h	2014-05-13 19:41:32 +0000
@@ -0,0 +1,58 @@
++/*
++ * 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: Alexandros Frantzis <alexandros.frantzis@canonical.com>
++ *              Andreas Pokorny <andreas.pokorny@canonical.com>
++*/
++
++#ifndef MIR_TEST_WAIT_OBJECT_H_
++#define MIR_TEST_WAIT_OBJECT_H_
++
++#include <mutex>
++#include <condition_variable>
++#include <chrono>
++#include <boost/throw_exception.hpp>
++
++namespace mir
++{
++namespace test
++{
++
++class WaitObject
++{
++public:
++    void notify_ready();
++    void wait_until_ready();
++    template<typename Representation, typename Period>
++    void wait_until_ready(std::chrono::duration<Representation, Period> const& span)
++    {
++        std::unique_lock<std::mutex> lock{mutex};
++        if (!cv.wait_for(lock, span, [this] { return ready; }))
++        {
++            BOOST_THROW_EXCEPTION(std::runtime_error("WaitObject timed out"));
++        }
++    }
++
++private:
++    std::mutex mutex;
++    std::condition_variable cv;
++    bool ready = false;
++};
++
++}
++}
++
++#endif
++
 === added file 'include/test/mir_test_doubles/stub_timer.h'
 --- include/test/mir_test_doubles/stub_timer.h	1970-01-01 00:00:00 +0000
 +++ include/test/mir_test_doubles/stub_timer.h	2014-05-13 19:41:32 +0000
@@ -0,0 +1,70 @@
++/*
++ * 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: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#ifndef MIR_TEST_DOUBLES_STUB_TIMER_H_
++#define MIR_TEST_DOUBLES_STUB_TIMER_H_
++
++#include "mir/time/alarm.h"
++#include "mir/time/timer.h"
++
++namespace mir
++{
++namespace test
++{
++namespace doubles
++{
++
++class StubAlarm : public mir::time::Alarm
++{
++    bool cancel() override
++    {
++        return false;
++    }
++    State state() const override
++    {
++        return Cancelled;
++    }
++    bool reschedule_in(std::chrono::milliseconds) override
++    {
++        return false;
++    }
++    bool reschedule_for(mir::time::Timestamp) override
++    {
++        return false;
++    }
++};
++
++class StubTimer : public mir::time::Timer
++{
++    std::unique_ptr<mir::time::Alarm> notify_in(std::chrono::milliseconds, std::function<void(void)>) override
++    {
++        return std::unique_ptr<mir::time::Alarm>{new StubAlarm};
++    }
++
++    std::unique_ptr<mir::time::Alarm> notify_at(mir::time::Timestamp, std::function<void(void)>) override
++    {
++        return std::unique_ptr<mir::time::Alarm>{new StubAlarm};
++    }
++};
++
++}
++}
++}
++
++
++#endif // MIR_TEST_DOUBLES_STUB_TIMER_H_
 === modified file 'src/server/asio_main_loop.cpp'
 --- src/server/asio_main_loop.cpp	2014-05-08 16:15:26 +0000
 +++ src/server/asio_main_loop.cpp	2014-05-13 19:41:32 +0000
@@ -18,7 +18,11 @@
  #include "mir/asio_main_loop.h"
++#include "boost/date_time/posix_time/conversion.hpp"
++
  #include <cassert>
++#include <mutex>
++#include <condition_variable>
  class mir::AsioMainLoop::SignalHandler
+ {
@@ -109,6 +113,7 @@
   * to compile.
   */
  mir::AsioMainLoop::AsioMainLoop()
++    : work{io}
+ {
+ }
@@ -154,6 +159,139 @@
      fd_handlers.push_back(std::move(fd_handler));
+ }
++namespace
++{
++class AlarmImpl : public mir::time::Alarm
++{
++public:
++    AlarmImpl(boost::asio::io_service& io,
++              std::chrono::milliseconds delay,
++              std::function<void(void)> callback);
++
++    AlarmImpl(boost::asio::io_service& io,
++              mir::time::Timestamp time_point,
++              std::function<void(void)> callback);
++
++    ~AlarmImpl() noexcept override;
++
++    bool cancel() override;
++    State state() const override;
++
++    bool reschedule_in(std::chrono::milliseconds delay) override;
++    bool reschedule_for(mir::time::Timestamp time_point) override;
++private:
++    void update_timer();
++    struct InternalState
++    {
++        explicit InternalState(std::function<void(void)> callback)
++            : callback{callback}
++        {
++        }
++
++        mutable std::mutex m;
++        std::function<void(void)> callback;
++        State state;
++    };
++
++    boost::asio::deadline_timer timer;
++    std::shared_ptr<InternalState> data;
++};
++
++AlarmImpl::AlarmImpl(boost::asio::io_service& io,
++                     std::chrono::milliseconds delay,
++                     std::function<void ()> callback)
++    : timer{io},
++      data{std::make_shared<InternalState>(callback)}
++{
++    reschedule_in(delay);
++}
++
++AlarmImpl::AlarmImpl(boost::asio::io_service& io,
++                     mir::time::Timestamp time_point,
++                     std::function<void ()> callback)
++    : timer{io},
++      data{std::make_shared<InternalState>(callback)}
++{
++    reschedule_for(time_point);
++}
++
++AlarmImpl::~AlarmImpl() noexcept
++{
++    AlarmImpl::cancel();
++}
++
++bool AlarmImpl::cancel()
++{
++    std::lock_guard<decltype(data->m)> lock(data->m);
++    if (data->state == triggered)
++        return false;
++
++    data->state = cancelled;
++    timer.cancel();
++    return true;
++}
++
++mir::time::Alarm::State AlarmImpl::state() const
++{
++    std::lock_guard<decltype(data->m)> lock(data->m);
++
++    return data->state;
++}
++
++bool AlarmImpl::reschedule_in(std::chrono::milliseconds delay)
++{
++    bool cancelling = timer.expires_from_now(boost::posix_time::milliseconds{delay.count()});
++    update_timer();
++    return cancelling;
++}
++
++bool AlarmImpl::reschedule_for(mir::time::Timestamp time_point)
++{
++    bool cancelling =
++        timer.expires_at(boost::posix_time::from_time_t(
++                std::chrono::high_resolution_clock::to_time_t(time_point)
++                ));
++    update_timer();
++    return cancelling;
++}
++
++void AlarmImpl::update_timer()
++{
++    std::lock_guard<decltype(data->m)> lock(data->m);
++    // Awkwardly, we can't stop the async_wait handler from being called
++    // on a destroyed AlarmImpl. This means we need to wedge a shared_ptr
++    // into the async_wait callback.
++    std::weak_ptr<InternalState> possible_data = data;
++    timer.async_wait([possible_data](boost::system::error_code const& ec)
++    {
++        auto data = possible_data.lock();
++        if (!data)
++            return;
++
++        std::unique_lock<decltype(data->m)> lock(data->m);
++        if (!ec && data->state == pending)
++        {
++            data->state = triggered;
++            lock.unlock();
++            data->callback();
++        }
++    });
++    data->state = pending;
++}
++}
++
++std::unique_ptr<mir::time::Alarm> mir::AsioMainLoop::notify_in(std::chrono::milliseconds delay,
++                                                               std::function<void()> callback)
++{
++    return std::unique_ptr<mir::time::Alarm>{new AlarmImpl{io, delay, callback}};
++}
++
++std::unique_ptr<mir::time::Alarm> mir::AsioMainLoop::notify_at(mir::time::Timestamp time_point,
++                                                               std::function<void()> callback)
++{
++    return std::unique_ptr<mir::time::Alarm>{new AlarmImpl{io, time_point, callback}};
++
++}
  void mir::AsioMainLoop::enqueue(void const* owner, ServerAction const& action)
+ {
+     {
 === modified file 'tests/integration-tests/client/test_screencast.cpp'
 --- tests/integration-tests/client/test_screencast.cpp	2014-03-06 18:57:08 +0000
 +++ tests/integration-tests/client/test_screencast.cpp	2014-05-13 19:41:32 +0000
@@ -23,13 +23,11 @@
  #include "mir_test/test_protobuf_server.h"
  #include "mir_test/stub_server_tool.h"
  #include "mir_test/pipe.h"
++#include "mir_test/wait_object.h"
  #include <gtest/gtest.h>
  #include <thread>
--#include <mutex>
--#include <condition_variable>
--#include <boost/throw_exception.hpp>
  namespace mcl = mir::client;
  namespace mt = mir::test;
@@ -37,31 +35,6 @@
  namespace
+ {
--class WaitObject
--{
--public:
--    void notify_ready()
--    {
--        std::unique_lock<std::mutex> lock{mutex};
--        ready = true;
--        cv.notify_all();
--    }
--
--    void wait_until_ready()
--    {
--        std::unique_lock<std::mutex> lock{mutex};
--        if (!cv.wait_for(lock, std::chrono::seconds{10}, [this] { return ready; }))
--        {
--            BOOST_THROW_EXCEPTION(std::runtime_error("WaitObject timed out"));
--        }
--    }
--
--private:
--    std::mutex mutex;
--    std::condition_variable cv;
--    bool ready = false;
--};
--
  struct StubScreencastServerTool : mt::StubServerTool
+ {
      void create_screencast(
@@ -129,13 +102,13 @@
      protobuf_parameters.set_pixel_format(0);
      mir::protobuf::Screencast protobuf_screencast;
--    WaitObject wait_rpc;
++    mt::WaitObject wait_rpc;
      protobuf_server->create_screencast(
          nullptr,
          &protobuf_parameters,
          &protobuf_screencast,
--        google::protobuf::NewCallback(&wait_rpc, &WaitObject::notify_ready));
++        google::protobuf::NewCallback(&wait_rpc, &mt::WaitObject::notify_ready));
      wait_rpc.wait_until_ready();
@@ -167,13 +140,13 @@
      protobuf_screencast_id.set_value(0);
      mir::protobuf::Buffer protobuf_buffer;
--    WaitObject wait_rpc;
++    mt::WaitObject wait_rpc;
      protobuf_server->screencast_buffer(
          nullptr,
          &protobuf_screencast_id,
          &protobuf_buffer,
--        google::protobuf::NewCallback(&wait_rpc, &WaitObject::notify_ready));
++        google::protobuf::NewCallback(&wait_rpc, &mt::WaitObject::notify_ready));
      wait_rpc.wait_until_ready();
 === modified file 'tests/mir_test/CMakeLists.txt'
 --- tests/mir_test/CMakeLists.txt	2014-04-30 21:25:02 +0000
 +++ tests/mir_test/CMakeLists.txt	2014-05-13 19:41:32 +0000
@@ -6,4 +6,5 @@
    cross_process_action.cpp
    spin_wait.cpp
    popen.cpp
--)
 \ No newline at end of file
++  wait_object.cpp
++)
 === added file 'tests/mir_test/wait_object.cpp'
 --- tests/mir_test/wait_object.cpp	1970-01-01 00:00:00 +0000
 +++ tests/mir_test/wait_object.cpp	2014-05-13 19:41:32 +0000
@@ -0,0 +1,35 @@
++/*
++ * 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: Alexandros Frantzis <alexandros.frantzis@canonical.com>
++ *              Andreas Pokorny <andreas.pokorny@canonical.com>
++ */
++
++#include "mir_test/wait_object.h"
++
++namespace mt = mir::test;
++
++void mt::WaitObject::notify_ready()
++{
++    std::unique_lock<std::mutex> lock{mutex};
++    ready = true;
++    cv.notify_all();
++}
++
++void mt::WaitObject::wait_until_ready()
++{
++    wait_until_ready(std::chrono::seconds{10});
++}
++
 === modified file 'tests/unit-tests/graphics/mesa/test_linux_virtual_terminal.cpp'
 --- tests/unit-tests/graphics/mesa/test_linux_virtual_terminal.cpp	2014-05-06 14:44:57 +0000
 +++ tests/unit-tests/graphics/mesa/test_linux_virtual_terminal.cpp	2014-05-13 19:41:32 +0000
@@ -22,6 +22,7 @@
  #include "mir_test/fake_shared.h"
  #include "mir_test_doubles/mock_display_report.h"
++#include "mir_test/gmock_fixes.h"
  #include <gtest/gtest.h>
  #include <gmock/gmock.h>
 === modified file 'tests/unit-tests/test_asio_main_loop.cpp'
 --- tests/unit-tests/test_asio_main_loop.cpp	2014-05-08 16:15:26 +0000
 +++ tests/unit-tests/test_asio_main_loop.cpp	2014-05-13 19:41:32 +0000
@@ -17,19 +17,48 @@
   */
  #include "mir/asio_main_loop.h"
++#include "mir/time/high_resolution_clock.h"
  #include "mir_test/pipe.h"
++#include "mir_test/auto_unblock_thread.h"
++#include "mir_test/wait_object.h"
  #include <gtest/gtest.h>
  #include <gmock/gmock.h>
  #include <thread>
  #include <atomic>
++#include <functional>
++#include <mutex>
++#include <condition_variable>
++#include <array>
++#include <boost/throw_exception.hpp>
  #include <sys/types.h>
  #include <unistd.h>
  namespace mt = mir::test;
++namespace
++{
++
++class AsioMainLoopAlarmTest : public ::testing::Test
++{
++public:
++    mir::AsioMainLoop ml;
++    int call_count{0};
++    mt::WaitObject wait;
++
++    struct UnblockMainLoop : mt::AutoUnblockThread
++    {
++        UnblockMainLoop(mir::AsioMainLoop & loop)
++            : mt::AutoUnblockThread([&loop]() {loop.stop();},
++                                    [&loop]() {loop.run();})
++        {}
++    };
++};
++
++}
++
  TEST(AsioMainLoopTest, signal_handled)
+ {
      int const signum{SIGUSR1};
@@ -294,6 +323,199 @@
      EXPECT_EQ(elems_to_send[2], elems_read[2]);
+ }
++TEST_F(AsioMainLoopAlarmTest, main_loop_runs_until_stop_called)
++{
++    std::mutex checkpoint_mutex;
++    std::condition_variable checkpoint;
++    bool hit_checkpoint{false};
++
++    auto fire_on_mainloop_start = ml.notify_in(std::chrono::milliseconds{0},
++                                               [&checkpoint_mutex, &checkpoint, &hit_checkpoint]()
++    {
++        std::unique_lock<decltype(checkpoint_mutex)> lock(checkpoint_mutex);
++        hit_checkpoint = true;
++        checkpoint.notify_all();
++    });
++
++    UnblockMainLoop unblocker(ml);
++
++    {
++        std::unique_lock<decltype(checkpoint_mutex)> lock(checkpoint_mutex);
++        ASSERT_TRUE(checkpoint.wait_for(lock, std::chrono::milliseconds{10}, [&hit_checkpoint]() { return hit_checkpoint; }));
++    }
++
++    auto alarm = ml.notify_in(std::chrono::milliseconds{10}, [this]
++    {
++        wait.notify_ready();
++    });
++
++    EXPECT_NO_THROW(wait.wait_until_ready(std::chrono::milliseconds{50}));
++
++    ml.stop();
++    // Main loop should be stopped now
++
++    hit_checkpoint = false;
++    auto should_not_fire =  ml.notify_in(std::chrono::milliseconds{0},
++                                         [&checkpoint_mutex, &checkpoint, &hit_checkpoint]()
++    {
++        std::unique_lock<decltype(checkpoint_mutex)> lock(checkpoint_mutex);
++        hit_checkpoint = true;
++        checkpoint.notify_all();
++    });
++
++    std::unique_lock<decltype(checkpoint_mutex)> lock(checkpoint_mutex);
++    EXPECT_FALSE(checkpoint.wait_for(lock, std::chrono::milliseconds{50}, [&hit_checkpoint]() { return hit_checkpoint; }));
++}
++
++TEST_F(AsioMainLoopAlarmTest, alarm_fires_with_correct_delay)
++{
++    auto alarm = ml.notify_in(std::chrono::milliseconds{50}, [this]()
++    {
++        wait.notify_ready();
++    });
++
++    UnblockMainLoop unblocker(ml);
++
++    EXPECT_NO_THROW(wait.wait_until_ready(std::chrono::milliseconds{100}));
++}
++
++TEST_F(AsioMainLoopAlarmTest, multiple_alarms_fire)
++{
++    int const alarm_count{10};
++    std::atomic<int> call_count{0};
++    std::array<std::unique_ptr<mir::time::Alarm>, alarm_count> alarms;
++
++    for (auto& alarm : alarms)
++    {
++        alarm = ml.notify_in(std::chrono::milliseconds{50}, [this, &call_count]()
++        {
++            call_count.fetch_add(1);
++            if (call_count == alarm_count)
++                wait.notify_ready();
++        });
++    }
++
++    UnblockMainLoop unblocker(ml);
++
++    EXPECT_NO_THROW(wait.wait_until_ready(std::chrono::milliseconds{100}));
++    for (auto& alarm : alarms)
++        EXPECT_EQ(mir::time::Alarm::triggered, alarm->state());
++}
++
++
++TEST_F(AsioMainLoopAlarmTest, alarm_changes_to_triggered_state)
++{
++    auto alarm = ml.notify_in(std::chrono::milliseconds{50}, [this]()
++    {
++        wait.notify_ready();
++    });
++
++    UnblockMainLoop unblocker(ml);
++
++    EXPECT_NO_THROW(wait.wait_until_ready(std::chrono::milliseconds{100}));
++
++    EXPECT_EQ(mir::time::Alarm::triggered, alarm->state());
++}
++
++TEST_F(AsioMainLoopAlarmTest, alarm_starts_in_pending_state)
++{
++    auto alarm = ml.notify_in(std::chrono::milliseconds{50}, [this]() {});
++
++    UnblockMainLoop unblocker(ml);
++
++    EXPECT_EQ(mir::time::Alarm::pending, alarm->state());
++}
++
++TEST_F(AsioMainLoopAlarmTest, cancelled_alarm_doesnt_fire)
++{
++    auto alarm = ml.notify_in(std::chrono::milliseconds{200}, [this]()
++    {
++        wait.notify_ready();
++    });
++
++    UnblockMainLoop unblocker(ml);
++
++    EXPECT_TRUE(alarm->cancel());
++    EXPECT_THROW(wait.wait_until_ready(std::chrono::milliseconds{300}), std::runtime_error);
++    EXPECT_EQ(mir::time::Alarm::cancelled, alarm->state());
++}
++
++TEST_F(AsioMainLoopAlarmTest, destroyed_alarm_doesnt_fire)
++{
++    auto alarm = ml.notify_in(std::chrono::milliseconds{200}, [this]()
++    {
++        wait.notify_ready();
++    });
++
++    UnblockMainLoop unblocker(ml);
++
++    alarm.reset(nullptr);
++
++    EXPECT_THROW(wait.wait_until_ready(std::chrono::milliseconds{300}), std::runtime_error);
++}
++
++TEST_F(AsioMainLoopAlarmTest, rescheduled_alarm_fires_again)
++{
++    std::mutex m;
++    std::condition_variable called;
++
++    auto alarm = ml.notify_in(std::chrono::milliseconds{0}, [this, &m, &called]()
++    {
++        std::unique_lock<decltype(m)> lock(m);
++        call_count++;
++        if (call_count == 2)
++            wait.notify_ready();
++        called.notify_all();
++    });
++
++    UnblockMainLoop unblocker(ml);
++
++    {
++        std::unique_lock<decltype(m)> lock(m);
++        ASSERT_TRUE(called.wait_for(lock,
++                                    std::chrono::milliseconds{50},
++                                    [this](){ return call_count == 1; }));
++    }
++
++    ASSERT_EQ(mir::time::Alarm::triggered, alarm->state());
++    alarm->reschedule_in(std::chrono::milliseconds{100});
++    EXPECT_EQ(mir::time::Alarm::pending, alarm->state());
++
++    EXPECT_NO_THROW(wait.wait_until_ready(std::chrono::milliseconds{500}));
++    EXPECT_EQ(mir::time::Alarm::triggered, alarm->state());
++}
++
++TEST_F(AsioMainLoopAlarmTest, rescheduled_alarm_cancels_previous_scheduling)
++{
++    auto alarm = ml.notify_in(std::chrono::milliseconds{100}, [this]()
++    {
++        call_count++;
++        wait.notify_ready();
++    });
++
++    UnblockMainLoop unblocker(ml);
++
++    EXPECT_TRUE(alarm->reschedule_in(std::chrono::milliseconds{150}));
++    EXPECT_EQ(mir::time::Alarm::pending, alarm->state());
++
++    EXPECT_NO_THROW(wait.wait_until_ready(std::chrono::milliseconds{500}));
++    EXPECT_EQ(mir::time::Alarm::triggered, alarm->state());
++    EXPECT_EQ(1, call_count);
++}
++
++TEST_F(AsioMainLoopAlarmTest, alarm_fires_at_correct_time_point)
++{
++    mir::time::HighResolutionClock clock;
++
++    mir::time::Timestamp real_soon = clock.sample() + std::chrono::microseconds{120};
++
++    auto alarm = ml.notify_at(real_soon, [this]() { wait.notify_ready(); });
++
++    UnblockMainLoop unblocker(ml);
++
++    EXPECT_NO_THROW(wait.wait_until_ready(std::chrono::milliseconds{200}));
++}
++
  TEST(AsioMainLoopTest, dispatches_action)
+ {
      using namespace testing;