Mir

Merge lp:~andreas-pokorny/mir/add-dispatchable-alarm-factory into lp:mir

add-dispatchable-alarm-factory
Merge into development-branch

Proposed by Andreas Pokorny on 2016-03-23

Status:	Work in progress
Proposed branch:	lp:~andreas-pokorny/mir/add-dispatchable-alarm-factory
Merge into:	lp:mir
Diff against target:	1309 lines (+1145/-26) 15 files modified include/common/mir/dispatch/alarm_factory.h (+57/-0) include/common/mir/lockable_callback.h (+3/-3) include/common/mir/time/alarm.h (+3/-3) include/common/mir/time/alarm_factory.h (+4/-4) include/common/mir/time/steady_timer_fd.h (+43/-0) include/common/mir/time/timer_fd.h (+68/-0) include/test/mir/test/doubles/mock_alarm_factory.h (+49/-0) src/common/dispatch/CMakeLists.txt (+1/-0) src/common/dispatch/alarm_factory.cpp (+400/-0) src/common/symbols.map (+25/-15) src/common/time/CMakeLists.txt (+1/-0) src/common/time/steady_timer_fd.cpp (+51/-0) tests/unit-tests/dispatch/CMakeLists.txt (+1/-0) tests/unit-tests/dispatch/test_dispatchable_alarm_factory.cpp (+438/-0) tests/unit-tests/test_glib_main_loop.cpp (+1/-1)
To merge this branch:	bzr merge lp:~andreas-pokorny/mir/add-dispatchable-alarm-factory
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Chris Halse Rogers		2016-03-23	Needs Fixing on 2016-04-01
Mir CI Bot	continuous-integration		Needs Fixing on 2016-03-31
Alan Griffiths			Abstain on 2016-03-30
Review via email: mp+289959@code.launchpad.net

Commit message

Add mir::dispatch::AlarmFactory

Implementation of mir::time::AlarmFactory that works with mir::dispatch::Dispatchable and supports all the state transitions required by the test suite accumulated in test_glib_main_loop.cpp.

With this change several GPL interfaces defined inside the mirserver API have been moved to mircommon and LGPL.

Description of the change

Adds an AlarmFactory that works inside a MultiplexingDispatchable and is hence not connected to a MainLoop. The implementation was driven by the test cases for the GLibMainLoop.

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-03-23:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/643/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-03-24:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/650/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-03-26:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/664/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Chris Halse Rogers (raof) wrote on 2016-03-28:

Overall: what is the purpose of this alarm factory? I presume it's to get key-repeat timers that are dispatched appropriately?

Nit:
+ struct Alarm;
+ struct AlarmData;

Both of these have significant interfaces and significant internal state; is there any reason why they're not declared as classes? Relatedly: C++ *really* should have not introduced the “class” keyword.

The code looks fine, although you should add documentation for the new public interfaces.

review: Needs Fixing

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-03-29:

> Overall: what is the purpose of this alarm factory? I presume it's to get key-
> repeat timers that are dispatched appropriately?

Yes. Not sending repeat events on a different thread than all other input events. Not having to pass *the* mainloop instance to the platform, where device tracking and handling repeat is even simpler. Oh and yes .. creating multiple mainloops also has fascinating effects that I want to avoid.

>
> Nit:
> + struct Alarm;
> + struct AlarmData;
>
> Both of these have significant interfaces and significant internal state; is
> there any reason why they're not declared as classes? Relatedly: C++ *really*
> should have not introduced the “class” keyword.

Of course they started out as simple structs before I remembered all the gory behavior details of Alarms..

> The code looks fine, although you should add documentation for the new public
> interfaces.

sure

lp:~andreas-pokorny/mir/add-dispatchable-alarm-factory updated on 2016-03-29

3416. By Andreas Pokorny on 2016-03-29: Cleanups..
- add doxygen for new headers
- struct/class changes
- consume expired timer counts on dispatch
3417. By Andreas Pokorny on 2016-03-29: some more doxygen

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-03-29:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/689/rebuild

review: Approve (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2016-03-29:

+class AlarmFactory : public ReadableFd, public time::AlarmFactory

ReadableFd is not designed to be derived from. Nor does "AlarmFactory is a ReadableFd" make sense to me. Even "AlarmFactory is a Dispatchable" seems dubious.

I see no use of relevant_events(), watch_fd() is used internally and by DispatchableAlarmFactory.yields_timer_fd - but the latter doesn't really seem like a required behaviour, just (possibly unnecessary) testing of implementation detail.

Why not use composition?

class AlarmFactory : public time::AlarmFactory
{
...
ReadableFd fd;
};

auto AlarmFactory::dispatch(FdEvents events)
-> bool { return fd.dispatch(events); }

review: Needs Fixing

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-03-30:

> +class AlarmFactory : public ReadableFd, public time::AlarmFactory
>
> ReadableFd is not designed to be derived from. Nor does "AlarmFactory is a
> ReadableFd" make sense to me. Even "AlarmFactory is a Dispatchable" seems
> dubious.
>
> I see no use of relevant_events(), watch_fd() is used internally and by
> DispatchableAlarmFactory.yields_timer_fd - but the latter doesn't really seem
> like a required behaviour, just (possibly unnecessary) testing of
> implementation detail.

The use of those methods is not visible because I split the implementation and its uses in separate MPs.

> Why not use composition?
>
> class AlarmFactory : public time::AlarmFactory
> {
> ...
> ReadableFd fd;
> };
>
> auto AlarmFactory::dispatch(FdEvents events)
> -> bool { return fd.dispatch(events); }

Why would there ever be a dispatch function when that implementation is not deriving md::Dispatchable? I could do that with composition and have a shared_ptr<Dispatchable> member, and provide access to that - to allow the caller to register the AlarmFactory to the MultiplexingDispatcher. But that would only add complexity to the life time dependencies between AlarmFactory and the dispatcher instance.. If you still think composition is better in this case I would go with:

class AlarmFactory : public time::AlarmFactory, public dispatch::Dispatchable
{
...
std::shared_ptr<Dispatchable> const timer_fd;
};

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-03-30:

oops I meant:
class AlarmFactory : public time::AlarmFactory, public dispatch::Dispatchable
{
...
ReadableFd const timer_fd;
};

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2016-03-30:

> oops I meant:
> class AlarmFactory : public time::AlarmFactory, public dispatch::Dispatchable
> {
> ...
> ReadableFd const timer_fd;
> };

Hmm. If that's the intention I prefer:

class AlarmFactory : public time::AlarmFactory, public dispatch::Dispatchable,
private ReadableFd
{
...
};

But for that dispatch::Dispatchable needs to be a virtual base class of ReadableFd.

review: Abstain

lp:~andreas-pokorny/mir/add-dispatchable-alarm-factory updated on 2016-03-30

3418. By Andreas Pokorny on 2016-03-30: Remove ReadableFd

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-03-30:

> > oops I meant:
> > class AlarmFactory : public time::AlarmFactory, public
> dispatch::Dispatchable
> > {
> > ...
> > ReadableFd const timer_fd;
> > };
>
> Hmm. If that's the intention I prefer:
>
> class AlarmFactory : public time::AlarmFactory, public dispatch::Dispatchable,
> private ReadableFd
> {
> ...
> };
>
> But for that dispatch::Dispatchable needs to be a virtual base class of
> ReadableFd.

I guess reusing ReadableFd is not really worth the trouble.. got rid of it in the latest change.

lp:~andreas-pokorny/mir/add-dispatchable-alarm-factory updated on 2016-03-30

3419. By Andreas Pokorny on 2016-03-30: merge lp:mir
3420. By Andreas Pokorny on 2016-03-30: resolve merge conflict

Revision history for this message

Chris Halse Rogers (raof) wrote on 2016-03-31:

Hm. Now that I read the docs, isn't TimerFd very nearly a time::Alarm implementation already?

It seems that this would be substantially simpler if you dispatchable::AlarmFactory just created a TimerFd per alarm and either added it to an internal MultiplexingDispatchable (and remained an implementation of Dispatchable) or took a reference to a MultiplexingDispatchable in the constructor and stopped implementing Dispatchable.

The downside is that tests of dispatchable::AlarmFactory become anchored to real time, but I'm not a big fan of significantly increasing the complexity of code in order to make tests run faster.

Did you try this in an earlier iteration and it turned out to be difficult?

review: Needs Information

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2016-03-31:

> Hm. Now that I read the docs, isn't TimerFd very nearly a time::Alarm
> implementation already?
>
> It seems that this would be substantially simpler if you
> dispatchable::AlarmFactory just created a TimerFd per alarm and either added
> it to an internal MultiplexingDispatchable (and remained an implementation of
> Dispatchable) or took a reference to a MultiplexingDispatchable in the
> constructor and stopped implementing Dispatchable.
>
> The downside is that tests of dispatchable::AlarmFactory become anchored to
> real time, but I'm not a big fan of significantly increasing the complexity of
> code in order to make tests run faster.
>
> Did you try this in an earlier iteration and it turned out to be difficult?

I considered the idea of having one fd per alarm. Given the way I wanted to use the Alarm* interfaces (by creating and destroying alarms on key presses), my gut feeling made me go with a single fd solution. The fact that I factored out real time with the TimerFd interface from the beginning and having the test cases already available, made driving the implementation simple.

A one fd per alarm solution rule out the complexity to exclude parallel access in the pending and canceled timer containers because the containers would not be needed. Also AlarmData would not be needed, but that did not really contribute to complexity. I think one would still need the other parts - tracking the executed state, and having a separate Alarm::Internal which plays the Dispatchable, and is decoupled in its life time, because the caller owns the Alarm via a unique ptr, while the MultiplexingDispacher just shares ownership of the Dispatchable. So roughly one out of three reasons for complexity would be gone..

Revision history for this message

Chris Halse Rogers (raof) wrote on 2016-03-31:

I don't think you need a separate Alarm::Internal, because you can just register the relevant mir::Fd + std::function<> pair with the MultiplexingDispatchable.

I'm OK with it as it is, but still have the gut feeling that it could be significantly simpler.

review: Approve

Revision history for this message

Chris Halse Rogers (raof) wrote on 2016-03-31:

Bah, I'm wavering. Maybe convince me a bit more that this isn't needlessly complex :)

review: Needs Information

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2016-03-31:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/710/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Chris Halse Rogers (raof) wrote on 2016-04-01:

Download full text (3.8 KiB)

Ok.

I've got one guaranteed needs-fixing, which is that the TimerFd interface is incorrect - it combines both a factory for TimerFds and the TimerFd interface itself, with the result that there's nothing stopping you allocating a mir::Fd from one TimerFd implementation and using it on another.

It should be split into TimerFdProvider and TimerFd interfaces.

Secondarily, I'm pretty sure the simplification would work - here's mostly complete code:

class AlarmFactory : public Dispatchable, public time::AlarmFactory
{
public:
    AlarmFactory(std::shared_ptr<time::TimerFdProvider> const& timer_source);
    std::unique_ptr<time::Alarm> create_alarm(std::function<void()> const& callback) override;
    std::unique_ptr<time::Alarm> create_alarm(std::unique_ptr<LockableCallback>&& callback) override;

    Fd watch_fd() const override;
    bool dispatch(FdEvents events) override;
    FdEvents relevant_events() const override;
private:
    std::shared_ptr<time::TimerFdProvider> const timer_source;
    MultiplexingDispatchable multiplexer;
};

class Alarm : public mt::Alarm
{
public:
    Alarm(
        std::unique_ptr<mt::TimerFd>&& timer,
        std::unique_ptr<mir::LockableCallback>&& callback,
        md::MultiplexingDispatchable& multiplexer)
        : timer{std::move(timer)},
          callback{callback.release(),
              [this](auto* victim)
              {
                  destroyed.notify_all();
                  delete victim;
              }}
    {
        std::weak_ptr<mir::LockableCallback> weak_cb = this->callback;
        auto internal_callback = [this, weak_cb]()
            {
                if (auto cb = weak_cb.lock())
                {
                    std::lock_guard<decltype(state_mutex)> lock{state_mutex};

                    if (state_holder == mt::Alarm::State::pending)
                    {
                        state_holder = mt::Alarm::State::triggered;
                        (*cb)();
                    }
                }
                return !weak_cb.expired();
            }
        multiplexer.add_watch(this->timer->fd(), internal_callback);
    }

    ~Alarm()
    {
        {
            std::lock_guard<decltype(state_mutex)> lock(state_mutex);

            if (state_holder == triggered)
            {
                // Either there are no pending calls or we're currently in the callback.
                // In either case, we don't have to wait.
                return;
            }
        }

        cancel();
        std::weak_ptr<mir::LockableCallback> canary = callback;
        callback.reset();

// We need to be triggered once more to remove us from the MultiplexingDispatchable.
reschedule_in(0ms);

        // Might be better to take shared ownership of the MultiplexingDispatchable and
        // manually remove_watch() us. Would let us not have to wait for a dispatch() iteration.
        if (!canary.expired())
        {
            std::unique_lock<decltype(state_mutex)> lock(state_mutex);

destroyed.wait(lock, [this]() { canary.expired(); });
}

}

    bool cancel() override
    {
        std::unique_lock<decltype(state_mutex)> lock(state_mutex);

...

Unmerged revisions

3420. By Andreas Pokorny on 2016-03-30

resolve merge conflict

3419. By Andreas Pokorny on 2016-03-30

merge lp:mir

3418. By Andreas Pokorny on 2016-03-30

Remove ReadableFd

3417. By Andreas Pokorny on 2016-03-29

some more doxygen

3416. By Andreas Pokorny on 2016-03-29

Cleanups..
- add doxygen for new headers
- struct/class changes
- consume expired timer counts on dispatch

3415. By Andreas Pokorny on 2016-03-23

fix init of itimerspec

3414. By Andreas Pokorny on 2016-03-22

Add mir::dispatch::AlarmFactory

Implementation of mir::time::AlarmFactory that works with mir::dispatch::Dispatchable and supports all the state transitions required by the test suite accumulated in test_glib_main_loop.cpp.

With this change several GPL interfaces defined inside the mirserver API have been moved to mircommon and LGPL.

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

 === added file 'include/common/mir/dispatch/alarm_factory.h'
 --- include/common/mir/dispatch/alarm_factory.h	1970-01-01 00:00:00 +0000
 +++ include/common/mir/dispatch/alarm_factory.h	2016-03-30 14:25:37 +0000
@@ -0,0 +1,57 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
++ */
++
++#ifndef MIR_DISPATCH_ALARM_FACTORY_H
++#define MIR_DISPATCH_ALARM_FACTORY_H
++
++#include "mir/time/alarm_factory.h"
++#include "mir/dispatch/dispatchable.h"
++#include "mir/fd.h"
++
++namespace mir
++{
++namespace time
++{
++class Clock;
++class TimerFd;
++}
++namespace dispatch
++{
++
++class AlarmFactory : public Dispatchable, public time::AlarmFactory
++{
++public:
++    AlarmFactory(std::shared_ptr<time::Clock> const& clock, std::shared_ptr<time::TimerFd> const& fd_source);
++    std::unique_ptr<time::Alarm> create_alarm(std::function<void()> const& callback) override;
++    std::unique_ptr<time::Alarm> create_alarm(std::shared_ptr<LockableCallback> const& callback) override;
++
++    Fd watch_fd() const override;
++    bool dispatch(FdEvents events) override;
++    FdEvents relevant_events() const override;
++private:
++    class Alarm;
++    class AlarmData;
++
++    friend class Alarm;
++    mir::Fd const timer_fd;
++    std::shared_ptr<AlarmData> const data;
++};
++
++}
++}
++#endif
 === renamed file 'include/server/mir/lockable_callback.h' => 'include/common/mir/lockable_callback.h'
 --- include/server/mir/lockable_callback.h	2015-02-24 23:45:39 +0000
 +++ include/common/mir/lockable_callback.h	2016-03-30 14:25:37 +0000
@@ -2,15 +2,15 @@
   * 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,
++ * under the terms of the GNU Lesser General Public License version 3,
   * as published by the Free Software Foundation.
+  *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- * GNU General Public License for more details.
++ * GNU Lesser General Public License for more details.
+  *
-- * You should have received a copy of the GNU General Public License
++ * You should have received a copy of the GNU Lesser General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  *
   * Authored by: Alberto Aguirre <alberto.aguirre@canonical.com>
 === renamed file 'include/server/mir/time/alarm.h' => 'include/common/mir/time/alarm.h'
 --- include/server/mir/time/alarm.h	2016-01-29 08:18:22 +0000
 +++ include/common/mir/time/alarm.h	2016-03-30 14:25:37 +0000
@@ -2,15 +2,15 @@
   * 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,
++ * under the terms of the GNU Lesser General Public License version 3,
   * as published by the Free Software Foundation.
+  *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-- * GNU General Public License for more details.
++ * GNU Lesser General Public License for more details.
+  *
-- * You should have received a copy of the GNU General Public License
++ * You should have received a copy of the GNU Lesser General Public License
   * along with this program. If not, see <http://www.gnu.org/licenses/>.
+  *
   * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
 === renamed file 'include/server/mir/time/alarm_factory.h' => 'include/common/mir/time/alarm_factory.h'
 --- include/server/mir/time/alarm_factory.h	2015-06-17 05:20:42 +0000
 +++ include/common/mir/time/alarm_factory.h	2016-03-30 14:25:37 +0000
@@ -1,16 +1,16 @@
  /*
-- * Copyright © 2014-2015 Canonical Ltd.
++ * Copyright © 2014-2016 Canonical Ltd.
+  *
   * This program is free software: you can redistribute it and/or modify it
-- * under the terms of the GNU General Public License version 3,
++ * under the terms of the GNU Lesser General Public License version 3,
   * as published by the Free Software Foundation.
+  *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-- * GNU General Public License for more details.
++ * GNU Lesser General Public License for more details.
+  *
-- * You should have received a copy of the GNU General Public License
++ * You should have received a copy of the GNU Lesser General Public License
   * along with this program. If not, see <http://www.gnu.org/licenses/>.
+  *
   * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
 === added file 'include/common/mir/time/steady_timer_fd.h'
 --- include/common/mir/time/steady_timer_fd.h	1970-01-01 00:00:00 +0000
 +++ include/common/mir/time/steady_timer_fd.h	2016-03-30 14:25:37 +0000
@@ -0,0 +1,43 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
++ */
++
++#ifndef MIR_TIME_STEADY_TIMER_FD_
++#define MIR_TIME_STEADY_TIMER_FD_
++
++#include "mir/time/timer_fd.h"
++
++namespace mir
++{
++namespace time
++{
++
++/**
++ * SteadyTimerFd creates timer file descriptors using CLOCK_MONOTONIC.
++ */
++class SteadyTimerFd : public TimerFd
++{
++public:
++    SteadyTimerFd();
++    Fd create_timer() override;
++    void schedule_for(Fd& fd, Timestamp timeout) override;
++    void cancel(Fd& fd) override;
++};
++
++}
++}
++#endif
 === added file 'include/common/mir/time/timer_fd.h'
 --- include/common/mir/time/timer_fd.h	1970-01-01 00:00:00 +0000
 +++ include/common/mir/time/timer_fd.h	2016-03-30 14:25:37 +0000
@@ -0,0 +1,68 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
++ */
++
++#ifndef MIR_TIME_TIMER_FD_H_
++#define MIR_TIME_TIMER_FD_H_
++
++#include "mir/fd.h"
++#include "mir/time/types.h"
++
++#include <chrono>
++
++namespace mir
++{
++namespace time
++{
++
++/**
++ * TimerFd provides timers that notify via file descriptors.
++ */
++class TimerFd
++{
++public:
++    TimerFd() = default;
++    virtual ~TimerFd() = default;
++    /**
++     * Create an unconfigured timer and return a file descriptor to monitor it.
++     *
++     * \returns a file descriptor to monitor the timer
++     */
++    virtual mir::Fd create_timer() = 0;
++    /**
++     * Configure the timer monitored by the file descriptor to expire at the given \a timestamp.
++     *
++     * \param[in] timestamp the timestamp
++     * \param[in] fd file descriptor of the timer
++     */
++    virtual void schedule_for(mir::Fd &fd, mir::time::Timestamp timestamp) = 0;
++    /**
++     * Cancel the timer.
++     *
++     * After that call the timer can be configured again using schedule_for.
++     *
++     * \param[in] fd file descriptor of the timer
++     */
++    virtual void cancel(mir::Fd& fd) = 0;
++protected:
++    TimerFd(TimerFd const&) = delete;
++    TimerFd& operator=(TimerFd const&) = delete;
++};
++
++}
++}
++#endif
 === added file 'include/test/mir/test/doubles/mock_alarm_factory.h'
 --- include/test/mir/test/doubles/mock_alarm_factory.h	1970-01-01 00:00:00 +0000
 +++ include/test/mir/test/doubles/mock_alarm_factory.h	2016-03-30 14:25:37 +0000
@@ -0,0 +1,49 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 3 as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
++ */
++
++#ifndef MIR_TEST_DOUBLES_MOCK_ALARM_FACTORY_H
++#define MIR_TEST_DOUBLES_MOCK_ALARM_FACTORY_H
++
++#include "mir/time/alarm_factory.h"
++
++namespace mir
++{
++namespace test
++{
++namespace doubles
++{
++
++struct MockAlarmFactory : public mir::time::AlarmFactory
++{
++    MOCK_METHOD1(create_alarm_adapter, mir::time::Alarm*(std::function<void()> const&));
++    MOCK_METHOD1(create_lockable_alarm_adapter, mir::time::Alarm*(std::shared_ptr<mir::LockableCallback> const&));
++    std::unique_ptr<mir::time::Alarm> create_alarm(std::function<void()> const& cb)
++    {
++        return std::unique_ptr<mir::time::Alarm>(create_alarm_adapter(cb));
++    }
++
++    std::unique_ptr<mir::time::Alarm> create_alarm(std::shared_ptr<mir::LockableCallback> const& lcb)
++    {
++        return std::unique_ptr<mir::time::Alarm>(create_lockable_alarm_adapter(lcb));
++    }
++};
++
++}
++}
++}
++#endif
 === modified file 'src/common/dispatch/CMakeLists.txt'
 --- src/common/dispatch/CMakeLists.txt	2016-01-29 08:18:22 +0000
 +++ src/common/dispatch/CMakeLists.txt	2016-03-30 14:25:37 +0000
@@ -17,6 +17,7 @@
  list(
    APPEND MIR_COMMON_SOURCES
    ${CMAKE_CURRENT_SOURCE_DIR}/action_queue.cpp
++  ${CMAKE_CURRENT_SOURCE_DIR}/alarm_factory.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/multiplexing_dispatchable.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/readable_fd.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/threaded_dispatcher.cpp
 === added file 'src/common/dispatch/alarm_factory.cpp'
 --- src/common/dispatch/alarm_factory.cpp	1970-01-01 00:00:00 +0000
 +++ src/common/dispatch/alarm_factory.cpp	2016-03-30 14:25:37 +0000
@@ -0,0 +1,400 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
++ */
++
++#include "mir/dispatch/alarm_factory.h"
++#include "mir/time/timer_fd.h"
++#include "mir/time/clock.h"
++#include "mir/lockable_callback.h"
++#include "mir/optional_value.h"
++
++#include <map>
++#include <vector>
++#include <unordered_set>
++#include <mutex>
++#include <chrono>
++#include <algorithm>
++#include <atomic>
++#include <condition_variable>
++#include <thread>
++#include <unistd.h>
++
++namespace md = mir::dispatch;
++namespace mt = mir::time;
++
++namespace
++{
++
++struct Callback : mir::LockableCallback
++{
++    Callback(std::function<void()> const& callback) : callback{callback} {}
++
++    void operator()() override
++    {
++        callback();
++    }
++    void lock() override
++    {
++    }
++    void unlock() override
++    {
++    }
++    std::function<void()> callback;
++};
++
++}
++
++
++class md::AlarmFactory::AlarmData
++{
++public:
++    AlarmData(mir::Fd fd, std::shared_ptr<mt::Clock> const& clock, std::shared_ptr<mt::TimerFd> const& fd_source);
++
++    void handle_timer();
++    void deactivate_timer(Alarm* alarm);
++    void activate_timer(mt::Timestamp timeout, Alarm* alarm);
++    void activate_timer(std::chrono::milliseconds delay, Alarm* alarm);
++
++private:
++    void erase_alarm_locked(Alarm* alarm);
++    void clear_cancelled_timers();
++    mir::Fd timer_fd;
++    std::shared_ptr<time::Clock> const clock;
++    std::shared_ptr<time::TimerFd> const fd_source;
++
++    std::mutex timer_queue_mutex;
++    std::multimap<mt::Timestamp, Alarm*> timer_queue;
++
++    std::mutex cancelled_timers_mutex;
++    std::unordered_set<Alarm*> cancelled_timers;
++};
++
++class md::AlarmFactory::Alarm : public mt::Alarm
++{
++public:
++    enum class AlarmState
++    {
++        cancelled,
++        pending,
++        executing,
++        triggered
++    };
++
++    Alarm(std::shared_ptr<mir::LockableCallback> const& callback,
++          std::shared_ptr<md::AlarmFactory::AlarmData> const& data)
++        : internal{std::make_shared<Internal>(this, callback, data)}
++    {
++    }
++
++    ~Alarm()
++    {
++        internal->cancel();
++    }
++
++    bool cancel() override
++    {
++        return internal->cancel();
++    }
++
++    State state() const override
++    {
++        return internal->state();
++    }
++
++    bool reschedule_in(std::chrono::milliseconds delay) override
++    {
++        return internal->reschedule_in(delay);
++    }
++
++    bool reschedule_for(mt::Timestamp timeout) override
++    {
++        return internal->reschedule_for(timeout);
++    }
++
++    struct Internal
++    {
++        Internal(Alarm* owner,
++                 std::shared_ptr<mir::LockableCallback> const& callback,
++                 std::shared_ptr<md::AlarmFactory::AlarmData> const& data)
++            : owner{owner}, wrapped_callback{callback}, alarm_data{data}
++        {
++        }
++        bool cancel();
++        State state() const;
++        bool reschedule_for(mt::Timestamp timeout);
++        bool reschedule_in(std::chrono::milliseconds delay);
++        void execute();
++        void pending_locked();
++        void cancelled_locked();
++
++    private:
++        Alarm* const owner;
++        std::shared_ptr<mir::LockableCallback> const wrapped_callback;
++        std::shared_ptr<md::AlarmFactory::AlarmData> const alarm_data;
++
++        mutable std::mutex alarm_mutex;
++        mir::optional_value<std::thread::id> executing_thread;
++        std::condition_variable callback_done;
++        AlarmState alarm_state{AlarmState::cancelled};
++    };
++
++    std::shared_ptr<Internal> const internal;
++};
++
++bool md::AlarmFactory::Alarm::Internal::reschedule_in(std::chrono::milliseconds delay)
++{
++    std::lock_guard<std::mutex> lock(alarm_mutex);
++    bool previously_pending = alarm_state == AlarmState::pending;
++    alarm_data->activate_timer(delay, owner);
++    return previously_pending;
++}
++
++bool md::AlarmFactory::Alarm::Internal::reschedule_for(mt::Timestamp timeout)
++{
++    std::lock_guard<std::mutex> lock(alarm_mutex);
++    bool previously_pending = alarm_state == AlarmState::pending;
++    alarm_data->activate_timer(timeout, owner);
++    return previously_pending;
++}
++
++bool md::AlarmFactory::Alarm::Internal::cancel()
++{
++    std::unique_lock<std::mutex> lock(alarm_mutex);
++    switch(alarm_state)
++    {
++    case AlarmState::pending:
++        alarm_data->deactivate_timer(owner);
++        return true;
++    case AlarmState::executing:
++        if (executing_thread.value() != std::this_thread::get_id())
++            callback_done.wait(lock);
++    default:
++    case AlarmState::cancelled:
++    case AlarmState::triggered:
++        return false;
++    }
++}
++
++mt::Alarm::State md::AlarmFactory::Alarm::Internal::state() const
++{
++    std::lock_guard<std::mutex> lock(alarm_mutex);
++    switch(alarm_state)
++    {
++    case AlarmState::pending:
++        return pending;
++    case AlarmState::cancelled:
++        return cancelled;
++    case AlarmState::executing:
++    case AlarmState::triggered:
++    default:
++        return triggered;
++    }
++}
++
++void md::AlarmFactory::Alarm::Internal::execute()
++{
++    std::lock_guard<LockableCallback> callback_lock{*wrapped_callback};
++    std::unique_lock<std::mutex> alarm_lock(alarm_mutex);
++    alarm_state = Alarm::AlarmState::executing;
++    executing_thread = std::this_thread::get_id();
++    alarm_lock.unlock();
++
++    (*wrapped_callback)();
++
++    alarm_lock.lock();
++    if (alarm_state == Alarm::AlarmState::executing)
++        alarm_state = Alarm::AlarmState::triggered;
++
++    executing_thread.consume();
++    callback_done.notify_all();
++    alarm_lock.unlock();
++}
++
++void md::AlarmFactory::Alarm::Internal::cancelled_locked()
++{
++    alarm_state = Alarm::AlarmState::cancelled;
++}
++
++void md::AlarmFactory::Alarm::Internal::pending_locked()
++{
++    alarm_state = Alarm::AlarmState::pending;
++}
++
++md::AlarmFactory::AlarmData::AlarmData(mir::Fd fd,
++                                       std::shared_ptr<time::Clock> const& clock,
++                                       std::shared_ptr<time::TimerFd> const& fd_source)
++    : timer_fd{fd}, clock{clock}, fd_source{fd_source}
++{
++}
++
++void md::AlarmFactory::AlarmData::handle_timer()
++{
++    auto now = clock->now();
++    std::vector<Alarm*> expired_timers;
++
++    {
++        std::lock_guard<std::mutex> lock(timer_queue_mutex);
++        auto alarm_upper_bound = timer_queue.upper_bound(now);
++        std::transform(
++            timer_queue.begin(),
++            alarm_upper_bound,
++            std::inserter(expired_timers, expired_timers.begin()),
++            [](auto const& entry)
++            {
++                return entry.second;
++            });
++        timer_queue.erase(timer_queue.begin(), alarm_upper_bound);
++    }
++
++    for (auto const& timer : expired_timers)
++    {
++        std::lock_guard<std::mutex> alarm_data_lock(cancelled_timers_mutex);
++        if (cancelled_timers.find(timer) != cancelled_timers.end())
++            continue;
++
++        auto timer_data = timer->internal;
++        timer_data->execute();
++    }
++
++    clear_cancelled_timers();
++
++    {
++        std::lock_guard<std::mutex> lock(timer_queue_mutex);
++        if (timer_queue.empty())
++            fd_source->cancel(timer_fd);
++        else fd_source->schedule_for(timer_fd, timer_queue.begin()->first);
++    }
++}
++
++void md::AlarmFactory::AlarmData::activate_timer(std::chrono::milliseconds delay, md::AlarmFactory::Alarm* alarm)
++{
++    activate_timer(clock->now() + delay, alarm);
++}
++
++void md::AlarmFactory::AlarmData::activate_timer(mt::Timestamp timeout, md::AlarmFactory::Alarm* alarm)
++{
++    bool optional_previous_timeout = false;
++    mt::Timestamp previous_timeout;
++    std::unique_lock<std::mutex> lock(timer_queue_mutex);
++
++    if (!timer_queue.empty())
++    {
++        previous_timeout = timer_queue.begin()->first;
++        optional_previous_timeout = true;
++
++        erase_alarm_locked(alarm);
++    }
++
++    timer_queue.insert(std::make_pair(timeout, alarm));
++
++    if ((optional_previous_timeout && timeout < previous_timeout) || !optional_previous_timeout)
++        fd_source->schedule_for(timer_fd, timeout);
++
++    alarm->internal->pending_locked();
++}
++
++void md::AlarmFactory::AlarmData::deactivate_timer(md::AlarmFactory::Alarm* alarm)
++{
++    bool removed = false;
++    mt::Timestamp previous_timeout;
++
++    {
++        std::unique_lock<std::mutex> lock(timer_queue_mutex);
++        if (!timer_queue.empty())
++        {
++            previous_timeout = timer_queue.begin()->first;
++
++            erase_alarm_locked(alarm);
++
++            removed = true;
++            alarm->internal->cancelled_locked();
++
++            if (timer_queue.empty())
++                fd_source->cancel(timer_fd);
++            else if (previous_timeout > timer_queue.begin()->first)
++                fd_source->schedule_for(timer_fd, timer_queue.begin()->first);
++        }
++    }
++
++    if (!removed)
++    {
++        std::unique_lock<std::mutex> lock(cancelled_timers_mutex);
++        cancelled_timers.insert(alarm);
++        alarm->internal->cancelled_locked();
++    }
++}
++
++md::AlarmFactory::AlarmFactory(std::shared_ptr<mt::Clock> const& clock, std::shared_ptr<mt::TimerFd> const& fd_source)
++    : timer_fd{fd_source->create_timer()},
++      data{std::make_shared<AlarmData>(watch_fd(), clock, fd_source)}
++{
++}
++
++std::unique_ptr<mt::Alarm> md::AlarmFactory::create_alarm(std::function<void()> const& callback)
++{
++    return std::make_unique<Alarm>(std::make_shared<Callback>(callback), data);
++}
++
++std::unique_ptr<mt::Alarm> md::AlarmFactory::create_alarm(std::shared_ptr<LockableCallback> const& callback)
++{
++    return std::make_unique<Alarm>(callback, data);
++}
++
++void md::AlarmFactory::AlarmData::erase_alarm_locked(Alarm* alarm)
++{
++    auto it = find_if(
++        begin(timer_queue),
++        end(timer_queue),
++        [&](auto const& item)
++        {
++            return item.second == alarm;
++        });
++
++    if (it != timer_queue.end())
++        timer_queue.erase(it);
++}
++
++void md::AlarmFactory::AlarmData::clear_cancelled_timers()
++{
++    std::lock_guard<std::mutex> lock(cancelled_timers_mutex);
++    cancelled_timers.clear();
++}
++
++mir::Fd md::AlarmFactory::watch_fd() const
++{
++    return timer_fd;
++}
++
++bool md::AlarmFactory::dispatch(FdEvents events)
++{
++    if (events & FdEvent::error)
++        return false;
++
++    if (events & FdEvent::readable)
++    {
++        uint64_t dummy;
++        read(watch_fd(), &dummy, sizeof(dummy));
++        data->handle_timer();
++    }
++
++    return true;
++}
++
++md::FdEvents md::AlarmFactory::relevant_events() const
++{
++    return FdEvent::readable;
++}
 === modified file 'src/common/symbols.map'
 --- src/common/symbols.map	2016-03-29 23:37:32 +0000
 +++ src/common/symbols.map	2016-03-30 14:25:37 +0000
@@ -219,22 +219,32 @@
      };
  } MIR_COMMON_5v19;  # <- Note Mir 0.19.0 used the wrong syntax
--MIR_COMMON_unreleased {
++MIR_COMMON_unreleased { # New functions in Mir 0.22.0?
    global:
      extern "C++" {
--       MirEvent::to_surface*;
--       MirEvent::to_resize*;
--       MirEvent::to_orientation*;
--       MirEvent::to_close_surface*;
--       MirEvent::to_keymap*;
--       MirEvent::to_input*;
--       MirEvent::to_prompt_session*;
--       MirEvent::serialize*;
--       MirEvent::deserialize*;
--       MirEvent::clone*;
--       MirInputEvent::to_keyboard*;
--       MirInputEvent::to_motion*;
--       MirMotionEvent::to_touch*;
--       MirMotionEvent::to_pointer*;
++      typeinfo?for?mir::time::SteadyTimerFd;
++      typeinfo?for?mir::dispatch::AlarmFactory;
++      vtable?for?mir::time::SteadyTimerFd;
++      vtable?for?mir::dispatch::AlarmFactory;
++      mir::time::SteadyTimerFd::SteadyTimerFd*;
++      mir::time::SteadyTimerFd::create_timer*;
++      mir::time::SteadyTimerFd::schedue_for*;
++      mir::time::SteadyTimerFd::cancel*;
++      mir::dispatch::AlarmFactory::AlarmFactory*;
++      mir::dispatch::AlarmFactory::create_alarm*;
++      MirEvent::to_surface*;
++      MirEvent::to_resize*;
++      MirEvent::to_orientation*;
++      MirEvent::to_close_surface*;
++      MirEvent::to_keymap*;
++      MirEvent::to_input*;
++      MirEvent::to_prompt_session*;
++      MirEvent::serialize*;
++      MirEvent::deserialize*;
++      MirEvent::clone*;
++      MirInputEvent::to_keyboard*;
++      MirInputEvent::to_motion*;
++      MirMotionEvent::to_touch*;
++      MirMotionEvent::to_pointer*;
      };
  } MIR_COMMON_0.19.1;
 === modified file 'src/common/time/CMakeLists.txt'
 --- src/common/time/CMakeLists.txt	2015-02-22 07:46:25 +0000
 +++ src/common/time/CMakeLists.txt	2016-03-30 14:25:37 +0000
@@ -2,4 +2,5 @@
    mirtime OBJECT
    steady_clock.cpp
++  steady_timer_fd.cpp
+ )
 === added file 'src/common/time/steady_timer_fd.cpp'
 --- src/common/time/steady_timer_fd.cpp	1970-01-01 00:00:00 +0000
 +++ src/common/time/steady_timer_fd.cpp	2016-03-30 14:25:37 +0000
@@ -0,0 +1,51 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
++ */
++
++#include "mir/time/steady_timer_fd.h"
++#include <sys/timerfd.h>
++#include <chrono>
++
++namespace mt = mir::time;
++
++mt::SteadyTimerFd::SteadyTimerFd() = default;
++
++mir::Fd mt::SteadyTimerFd::create_timer()
++{
++    return mir::Fd{timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK)};
++}
++
++void mt::SteadyTimerFd::schedule_for(mir::Fd& fd, mir::time::Timestamp timeout)
++{
++    using namespace std::chrono;
++    auto const in_seconds = duration_cast<seconds>(timeout.time_since_epoch());
++    itimerspec delay_spec;
++
++    delay_spec.it_value.tv_sec = in_seconds.count();
++    delay_spec.it_value.tv_nsec = nanoseconds(timeout.time_since_epoch() - in_seconds).count();
++    delay_spec.it_interval.tv_sec = 0;
++    delay_spec.it_interval.tv_nsec = 0;
++
++    const int absolute_timeout = TFD_TIMER_ABSTIME;
++    timerfd_settime(fd, absolute_timeout, &delay_spec, nullptr);
++}
++
++void mt::SteadyTimerFd::cancel(mir::Fd& fd)
++{
++    const itimerspec cancel_timer = {{0,0},{0,0}};
++    timerfd_settime(fd, 0, &cancel_timer, nullptr);
++}
 === modified file 'tests/unit-tests/dispatch/CMakeLists.txt'
 --- tests/unit-tests/dispatch/CMakeLists.txt	2016-01-29 08:18:22 +0000
 +++ tests/unit-tests/dispatch/CMakeLists.txt	2016-03-30 14:25:37 +0000
@@ -1,6 +1,7 @@
  list(APPEND UNIT_TEST_SOURCES
    ${CMAKE_CURRENT_SOURCE_DIR}/test_action_queue.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/test_dispatch_utils.cpp
++  ${CMAKE_CURRENT_SOURCE_DIR}/test_dispatchable_alarm_factory.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/test_multiplexing_dispatchable.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/test_readable_fd.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/test_threaded_dispatcher.cpp
 === added file 'tests/unit-tests/dispatch/test_dispatchable_alarm_factory.cpp'
 --- tests/unit-tests/dispatch/test_dispatchable_alarm_factory.cpp	1970-01-01 00:00:00 +0000
 +++ tests/unit-tests/dispatch/test_dispatchable_alarm_factory.cpp	2016-03-30 14:25:37 +0000
@@ -0,0 +1,438 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 3 as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
++ */
++
++#include "mir/dispatch/alarm_factory.h"
++#include "mir/time/timer_fd.h"
++#include "mir/time/clock.h"
++
++#include "mir/test/fake_shared.h"
++#include "mir/test/signal.h"
++#include "mir/test/barrier.h"
++#include "mir/test/auto_unblock_thread.h"
++#include "mir/test/doubles/advanceable_clock.h"
++#include "mir/test/doubles/mock_lockable_callback.h"
++#include <gtest/gtest.h>
++#include <gmock/gmock.h>
++
++using namespace testing;
++using namespace std::chrono_literals;
++
++namespace md = mir::dispatch;
++namespace mt = mir::test;
++namespace mtd = mt::doubles;
++
++namespace
++{
++
++struct MockTimerFd : mir::time::TimerFd
++{
++
++    mir::Fd timer_fd{mir::IntOwnedFd{3}};
++    MockTimerFd()
++    {
++        ON_CALL(*this, create_timer()).WillByDefault(Return(timer_fd));
++    }
++    MOCK_METHOD0(create_timer, mir::Fd());
++    MOCK_METHOD2(schedule_for, void(mir::Fd&, mir::time::Timestamp));
++    MOCK_METHOD1(cancel, void(mir::Fd&));
++};
++
++struct DispatchableAlarmFactory : public Test
++{
++    std::shared_ptr<NiceMock<MockTimerFd>> mock_timer_fd = std::make_shared<NiceMock<MockTimerFd>>();
++    std::shared_ptr<mtd::AdvanceableClock> fake_clock = std::make_shared<mtd::AdvanceableClock>();
++    md::AlarmFactory fac{fake_clock, mock_timer_fd};
++};
++
++}
++
++TEST_F(DispatchableAlarmFactory, alarm_starts_in_cancelled_state)
++{
++    auto alarm = fac.create_alarm([](){});
++    EXPECT_THAT(alarm->state(), Eq(mir::time::Alarm::cancelled));
++}
++
++TEST_F(DispatchableAlarmFactory, yields_timer_fd)
++{
++    auto alarm = fac.create_alarm([](){});
++    EXPECT_THAT(fac.watch_fd(), Eq(mock_timer_fd->timer_fd));
++}
++
++TEST_F(DispatchableAlarmFactory, alarm_scheduling_updates_timer_fd)
++{
++    auto alarm = fac.create_alarm([]{});
++
++    const auto scheduled_time = fake_clock->now() + 2s;
++
++    EXPECT_CALL(*mock_timer_fd, schedule_for(_, scheduled_time));
++
++    alarm->reschedule_for(scheduled_time);
++}
++
++TEST_F(DispatchableAlarmFactory, timeout_after_scheduled_alarm_leaves_timer_fd_untouched)
++{
++    auto alarm = fac.create_alarm([](){});
++    auto second_alarm = fac.create_alarm([&](){});
++
++    const auto scheduled_time = fake_clock->now() + 2s;
++    const auto time_after_alarm = scheduled_time + 1s;
++
++    EXPECT_CALL(*mock_timer_fd, schedule_for(_, scheduled_time)).Times(1);
++    EXPECT_CALL(*mock_timer_fd, schedule_for(_, time_after_alarm)).Times(0);
++
++    alarm->reschedule_for(scheduled_time);
++    second_alarm->reschedule_for(time_after_alarm);
++}
++
++TEST_F(DispatchableAlarmFactory, timeout_before_scheduled_alarm_updates_timer_fd)
++{
++    auto alarm = fac.create_alarm([&](){});
++    auto second_alarm = fac.create_alarm([&](){});
++
++    const mir::time::Timestamp scheduled_time = fake_clock->now() + 4s;
++    const mir::time::Timestamp time_before_alarm = scheduled_time - 2s;
++
++    EXPECT_CALL(*mock_timer_fd, schedule_for(_, scheduled_time)).Times(1);
++    EXPECT_CALL(*mock_timer_fd, schedule_for(_, time_before_alarm)).Times(1);
++
++    alarm->reschedule_for(scheduled_time);
++    second_alarm->reschedule_for(time_before_alarm);
++}
++
++TEST_F(DispatchableAlarmFactory, reschedule_of_first_alarm_updates_timer_fd)
++{
++    auto alarm = fac.create_alarm([&](){});
++    auto second_alarm = fac.create_alarm([&](){});
++
++    const auto scheduled_time = fake_clock->now() + 4s;
++    const auto time_before_alarm = scheduled_time - 2s;
++
++    EXPECT_CALL(*mock_timer_fd, schedule_for(_, scheduled_time)).Times(1);
++    EXPECT_CALL(*mock_timer_fd, schedule_for(_, time_before_alarm)).Times(1);
++    EXPECT_CALL(*mock_timer_fd, schedule_for(_, time_before_alarm - 1s)).Times(1);
++
++    alarm->reschedule_for(scheduled_time);
++    second_alarm->reschedule_for(time_before_alarm);
++    alarm->reschedule_for(time_before_alarm - 1s);
++}
++
++TEST_F(DispatchableAlarmFactory, cancelling_sole_alarm_cancels_timer_fd)
++{
++    auto alarm = fac.create_alarm([&](){});
++
++    const auto sometime_later = fake_clock->now() + 5s;
++    alarm->reschedule_for(sometime_later);
++
++    EXPECT_CALL(*mock_timer_fd, cancel(_)).Times(1);
++    alarm->cancel();
++    Mock::VerifyAndClearExpectations(mock_timer_fd.get());
++}
++
++TEST_F(DispatchableAlarmFactory, cancelling_last_alarm_cancels_timer_fd)
++{
++    auto alarm = fac.create_alarm([&](){});
++    auto second_alarm = fac.create_alarm([&](){});
++
++    const auto sometime_later = fake_clock->now() + 5s;
++
++    EXPECT_CALL(*mock_timer_fd, schedule_for(_, sometime_later)).Times(1);
++    EXPECT_CALL(*mock_timer_fd, cancel(_)).Times(1);
++
++    alarm->reschedule_for(sometime_later);
++    second_alarm->reschedule_for(sometime_later);
++    alarm->cancel();
++    second_alarm->cancel();
++
++    Mock::VerifyAndClearExpectations(mock_timer_fd.get());
++}
++
++TEST_F(DispatchableAlarmFactory, alarm_fires_with_correct_delay)
++{
++    int times_called = 0;
++    auto alarm = fac.create_alarm([&](){++times_called;});
++
++    const auto sometime_later = fake_clock->now() + 5s;
++    alarm->reschedule_for(sometime_later);
++
++    EXPECT_THAT(alarm->state(), Eq(mir::time::Alarm::pending));
++
++    fake_clock->advance_by(5s);
++    fac.dispatch(md::FdEvent::readable);
++
++    EXPECT_THAT(alarm->state(), Eq(mir::time::Alarm::triggered));
++    EXPECT_THAT(times_called, Eq(1));
++}
++
++TEST_F(DispatchableAlarmFactory, no_alarm_fires_before_timepoint)
++{
++    int times_called = 0;
++    auto alarm = fac.create_alarm([&](){++times_called;});
++
++    const auto sometime_later = fake_clock->now() + 3s;
++    alarm->reschedule_for(sometime_later);
++    EXPECT_THAT(alarm->state(), Eq(mir::time::Alarm::pending));
++    fake_clock->advance_by(2s);
++    fac.dispatch(md::FdEvent::readable);
++    EXPECT_THAT(times_called, Eq(0));
++}
++
++TEST_F(DispatchableAlarmFactory, cancelled_alarms_do_not_fire)
++{
++    int times_called = 0;
++    auto alarm = fac.create_alarm([&](){++times_called;});
++
++    const auto sometime_later = fake_clock->now() + 2s;
++    alarm->reschedule_for(sometime_later);
++    alarm->cancel();
++    fake_clock->advance_by(5s);
++    fac.dispatch(md::FdEvent::readable);
++    EXPECT_THAT(times_called, Eq(0));
++}
++
++TEST_F(DispatchableAlarmFactory, alarm_falling_out_scope_cancels)
++{
++    int times_called = 0;
++
++    {
++        auto alarm = fac.create_alarm([&](){++times_called;});
++        const auto sometime_later = fake_clock->now() + 2s;
++        alarm->reschedule_for(sometime_later);
++    }
++
++    fake_clock->advance_by(5s);
++    fac.dispatch(md::FdEvent::readable);
++    EXPECT_THAT(times_called, Eq(0));
++}
++
++
++TEST_F(DispatchableAlarmFactory, alarms_can_be_rescheduled_after_firing)
++{
++    int times_called = 0;
++    auto alarm = fac.create_alarm([&](){++times_called;});
++    const auto sometime_later = fake_clock->now() + 2s;
++    alarm->reschedule_for(sometime_later);
++    fake_clock->advance_by(2s);
++    fac.dispatch(md::FdEvent::readable);
++
++    const auto even_later = fake_clock->now() + 4s;
++    alarm->reschedule_for(even_later);
++    fake_clock->advance_by(4s);
++    fac.dispatch(md::FdEvent::readable);
++    EXPECT_THAT(times_called, Eq(2));
++}
++
++TEST_F(DispatchableAlarmFactory, alarms_can_be_rescheduled_after_cancelling)
++{
++    int times_called = 0;
++    auto alarm = fac.create_alarm([&](){++times_called;});
++    const auto sometime_later = fake_clock->now() + 2s;
++    alarm->reschedule_for(sometime_later);
++    alarm->cancel();
++    fake_clock->advance_by(2s);
++    fac.dispatch(md::FdEvent::readable);
++
++    const auto even_later = fake_clock->now() + 4s;
++    alarm->reschedule_for(even_later);
++    fake_clock->advance_by(4s);
++    fac.dispatch(md::FdEvent::readable);
++    EXPECT_THAT(times_called, Eq(1));
++}
++
++
++TEST_F(DispatchableAlarmFactory, can_reschedule_alarm_from_within_alarm_callback)
++{
++    int num_triggers = 0;
++    int const expected_triggers = 3;
++
++    std::shared_ptr<mir::time::Alarm> alarm = fac.create_alarm(
++        [&]
++        {
++            if (++num_triggers != expected_triggers)
++                alarm->reschedule_in(0ms);
++        });
++
++    alarm->reschedule_in(0ms);
++
++    fac.dispatch(md::FdEvent::readable);
++    fac.dispatch(md::FdEvent::readable);
++    fac.dispatch(md::FdEvent::readable);
++
++    EXPECT_THAT(num_triggers, Eq(expected_triggers));
++}
++
++TEST_F(DispatchableAlarmFactory, alarm_callback_preserves_lock_ordering)
++{
++    mtd::MockLockableCallback handler;
++    {
++        InSequence s;
++        EXPECT_CALL(handler, lock());
++        EXPECT_CALL(handler, functor());
++        EXPECT_CALL(handler, unlock());
++    }
++
++    auto alarm = fac.create_alarm(mt::fake_shared(handler));
++
++    alarm->reschedule_in(10ms);
++    fake_clock->advance_by(11ms);
++    fac.dispatch(md::FdEvent::readable);
++}
++
++TEST_F(DispatchableAlarmFactory, rescheduling_alarm_from_within_alarm_callback_doesnt_deadlock_with_external_reschedule)
++{
++    mt::Signal in_alarm;
++    mt::Signal alarm_rescheduled;
++
++    std::shared_ptr<mir::time::Alarm> alarm = fac.create_alarm(
++        [&]
++        {
++            // Ensure that the external thread reschedules us while we're
++            // in the callback.
++            in_alarm.raise();
++            ASSERT_TRUE(alarm_rescheduled.wait_for(5s));
++
++            alarm->reschedule_in(0ms);
++        });
++
++    alarm->reschedule_in(0ms);
++
++    mt::AutoJoinThread rescheduler{
++        [alarm, &in_alarm, &alarm_rescheduled]()
++        {
++            ASSERT_TRUE(in_alarm.wait_for(5s));
++            alarm->reschedule_in(0ms);
++            alarm_rescheduled.raise();
++        }};
++
++    fac.dispatch(md::FdEvent::readable);
++}
++
++TEST_F(DispatchableAlarmFactory, cancel_blocks_until_definitely_cancelled)
++{
++    auto waiting_in_lock = std::make_shared<mt::Barrier>(2);
++    auto has_been_called = std::make_shared<mt::Signal>();
++
++    std::shared_ptr<mir::time::Alarm> alarm = fac.create_alarm(
++        [waiting_in_lock, has_been_called]()
++        {
++            waiting_in_lock->ready();
++            std::this_thread::sleep_for(500ms);
++            has_been_called->raise();
++        });
++
++    alarm->reschedule_in(0ms);
++
++    mt::AutoJoinThread canceller{
++        [waiting_in_lock, has_been_called, alarm, this]()
++        {
++            waiting_in_lock->ready();
++            alarm->cancel();
++            EXPECT_TRUE(has_been_called->raised());
++        }
++    };
++
++    fac.dispatch(md::FdEvent::readable);
++}
++
++TEST_F(DispatchableAlarmFactory, can_cancel_from_callback)
++{
++    mir::time::Alarm* raw_alarm;
++    auto cancel_didnt_deadlock = std::make_shared<mt::Signal>();
++    auto alarm = fac.create_alarm(
++        [&raw_alarm, cancel_didnt_deadlock]()
++        {
++            raw_alarm->cancel();
++            cancel_didnt_deadlock->raise();
++        });
++
++    raw_alarm = alarm.get();
++
++    alarm->reschedule_in(0ms);
++    mt::AutoJoinThread(
++        [&]()
++        {
++            fac.dispatch(md::FdEvent::readable);
++        });
++
++    EXPECT_TRUE(cancel_didnt_deadlock->wait_for(10s));
++    if (!cancel_didnt_deadlock->raised())
++    {
++        // Deadlocking is no fun. There's nothing we can sensibly do,
++        // so die rather than wait for the build to timeout.
++        std::terminate();
++    }
++}
++
++TEST_F(DispatchableAlarmFactory, can_destroy_alarm_from_callback)
++{
++    mir::time::Alarm* raw_alarm;
++    auto cancel_didnt_deadlock = std::make_shared<mt::Signal>();
++    auto alarm = fac.create_alarm(
++        [&raw_alarm, cancel_didnt_deadlock]()
++        {
++            delete raw_alarm;
++            cancel_didnt_deadlock->raise();
++        });
++
++    alarm->reschedule_in(0ms);
++    raw_alarm = alarm.release();
++
++    mt::AutoJoinThread(
++        [&]()
++        {
++            fac.dispatch(md::FdEvent::readable);
++        });
++
++    EXPECT_TRUE(cancel_didnt_deadlock->wait_for(10s));
++    if (!cancel_didnt_deadlock->raised())
++    {
++        // Deadlocking is no fun. There's nothing we can sensibly do,
++        // so die rather than wait for the build to timeout.
++        std::terminate();
++    }
++}
++
++TEST_F(DispatchableAlarmFactory, cancelling_a_triggered_alarm_has_no_effect)
++{
++    auto alarm = fac.create_alarm([](){});
++
++    alarm->reschedule_in(0ms);
++
++    fac.dispatch(md::FdEvent::readable);
++
++    EXPECT_THAT(alarm->state(), Eq(mir::time::Alarm::State::triggered));
++    EXPECT_FALSE(alarm->cancel());
++    EXPECT_THAT(alarm->state(), Eq(mir::time::Alarm::State::triggered));
++}
++
++TEST_F(DispatchableAlarmFactory, reschedule_returns_true_when_it_resets_a_previous_schedule)
++{
++    auto alarm = fac.create_alarm([](){});
++
++    alarm->reschedule_in(10min);
++    EXPECT_TRUE(alarm->reschedule_in(5s));
++}
++
++TEST_F(DispatchableAlarmFactory, reschedule_returns_false_when_it_didnt_reset_a_previous_schedule)
++{
++    auto alarm = fac.create_alarm([](){});
++
++    alarm->reschedule_in(1min);
++    fake_clock->advance_by(2min);
++    fac.dispatch(md::FdEvent::readable);
++    EXPECT_FALSE(alarm->reschedule_in(10s));
++}
 === modified file 'tests/unit-tests/test_glib_main_loop.cpp'
 --- tests/unit-tests/test_glib_main_loop.cpp	2016-01-29 08:18:22 +0000
 +++ tests/unit-tests/test_glib_main_loop.cpp	2016-03-30 14:25:37 +0000
@@ -928,7 +928,7 @@
      EXPECT_FALSE(timer_fired->wait_for(std::chrono::milliseconds{10}));
+ }
--TEST_F(GLibMainLoopAlarmTest, alarm_starts_in_pending_state)
++TEST_F(GLibMainLoopAlarmTest, alarm_starts_in_cancelled_state)
+ {
      auto alarm = ml.create_alarm([]{});