Merge lp:~afrantzis/mir/glib-main-loop-spike-wip into lp:mir

[Alexandros Frantzis]

Please don't spend time code reviewing this branch, it's only meant to
communicate the general approach taken for the GLib version of the main
loop. However, please do take a look and let me know if you feel this is
less/more clear/straightforward than our asio version and whether you
like the general direction or not. See [1] for the way glib sources
work, which should aid your understanding.

Some integration tests are failing/hanging with this branch and the
culprit is the signalfd based signal source. The problem turns out to be
that in order for signalfd to catch a signal, the signal needs to be
blocked in *all* threads. Usually that translates to blocking the
signals in main() so all threads will inherit the signal mask.
Unfortunately, this doesn't work for us since we are a library and can't
enforce a signal mask in the general case.

Next steps:

1. Replace signalfd with something else (probably just signal handlers
   + self-pipe to notify main loop), or (less likely) find a way to
   enforce a global signal mask.

2. Start proposing the changes in cleaned-up, small steps:
   * Infrastructure changes (e.g. ThreadSafeList, Clock)
   * GLibMainLoop basic start/stop + tests
   * GLibMainLoop signal handing + tests
   * GLibMainLoop fd handing + tests
   * GLibMainLoop timers + tests
   * GLibMainLoop queued events (ServerAction) + tests
   * GLibMainLoop as a proper MainLoop extension, and
     a mechanism to select it instead of AsioMainLoop

[1] https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#GSourceFuncs

[lp:~afrantzis/mir/glib-main-loop-spike-wip]

2015. By Alexandros Frantzis on 2014-10-31

Use built-in glib signal source

Unmerged revisions

2015. By Alexandros Frantzis on 2014-10-31

Use built-in glib signal source

2014. By Alexandros Frantzis on 2014-10-30

GLibMainLoop WIP spike hack-o-rama

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-10-21 16:21:14 +0000
+++ CMakeLists.txt	2014-10-31 11:59:50 +0000
@@ -154,6 +154,7 @@
 find_package(XKBCOMMON REQUIRED)
 find_package(LTTngUST REQUIRED)
 pkg_check_modules(UDEV REQUIRED libudev)
+pkg_check_modules(GLIB REQUIRED glib-2.0)
 
 include_directories (${GLESv2_INCLUDE_DIRS})
 include_directories (${EGL_INCLUDE_DIRS})

=== modified file 'debian/control'
--- debian/control	2014-10-30 18:37:11 +0000
+++ debian/control	2014-10-31 11:59:50 +0000
@@ -39,6 +39,7 @@
                libudev-dev,
                google-mock (>= 1.6.0+svn437),
                valgrind [!arm64],
+               libglib2.0-dev,
 Standards-Version: 3.9.4
 Homepage: https://launchpad.net/mir
 # If you aren't a member of ~mir-team but need to upload packaging changes,

=== modified file 'include/common/mir/time/clock.h'
--- include/common/mir/time/clock.h	2014-10-01 06:25:56 +0000
+++ include/common/mir/time/clock.h	2014-10-31 11:59:50 +0000
@@ -35,6 +35,7 @@
     virtual ~Clock() = default;
 
     virtual Timestamp sample() const = 0;
+    virtual Duration timeout_until(Timestamp) const { return Duration{0}; }
 
 protected:
     Clock() = default;

=== modified file 'src/common/time/high_resolution_clock.cpp'
--- src/common/time/high_resolution_clock.cpp	2014-10-01 06:25:56 +0000
+++ src/common/time/high_resolution_clock.cpp	2014-10-31 11:59:50 +0000
@@ -22,3 +22,12 @@
 {
     return clock.now();
 }
+
+mir::time::Duration mir::time::HighResolutionClock::timeout_until(Timestamp t) const
+{
+    auto const now = clock.now();
+    if (t <= now)
+        return Duration{0};
+    else
+        return t - now;
+}

=== modified file 'src/include/common/mir/basic_observers.h'
--- src/include/common/mir/basic_observers.h	2014-10-21 16:21:14 +0000
+++ src/include/common/mir/basic_observers.h	2014-10-31 11:59:50 +0000
@@ -19,108 +19,15 @@
 #ifndef MIR_BASIC_OBSERVERS_H_
 #define MIR_BASIC_OBSERVERS_H_
 
-#include "mir/recursive_read_write_mutex.h"
-
-#include <atomic>
+#include "mir/thread_safe_list.h"
 #include <memory>
 
 namespace mir
 {
 template<class Observer>
-class BasicObservers
+class BasicObservers : protected ThreadSafeList<std::shared_ptr<Observer>>
 {
-protected:
-    void add(std::shared_ptr<Observer> const& observer);
-    void remove(std::shared_ptr<Observer> const& observer);
-    void for_each(std::function<void(std::shared_ptr<Observer> const& observer)> const& f);
-
-private:
-    struct ListItem
-    {
-        ListItem() {}
-        RecursiveReadWriteMutex mutex;
-        std::shared_ptr<Observer> observer;
-        std::atomic<ListItem*> next{nullptr};
-
-        ~ListItem() { delete next.load(); }
-    } head;
 };
-
-template<class Observer>
-void BasicObservers<Observer>::for_each(
-    std::function<void(std::shared_ptr<Observer> const& observer)> const& f)
-{
-    ListItem* current_item = &head;
-
-    while (current_item)
-    {
-        RecursiveReadLock lock{current_item->mutex};
-
-        // We need to take a copy in case we recursively remove during call
-        if (auto const copy_of_observer = current_item->observer) f(copy_of_observer);
-
-        current_item = current_item->next;
-    }
-}
-
-template<class Observer>
-void BasicObservers<Observer>::add(std::shared_ptr<Observer> const& observer)
-{
-    ListItem* current_item = &head;
-
-    do
-    {
-        // Note: we release the read lock to avoid two threads calling add at
-        // the same time mutually blocking the other's upgrade to write lock.
-        {
-            RecursiveReadLock lock{current_item->mutex};
-            if (current_item->observer) continue;
-        }
-
-        RecursiveWriteLock lock{current_item->mutex};
-
-        if (!current_item->observer)
-        {
-            current_item->observer = observer;
-            return;
-        }
-    }
-    while (current_item->next && (current_item = current_item->next));
-
-    // No empty Items so append a new one
-    auto new_item = new ListItem;
-    new_item->observer = observer;
-
-    for (ListItem* expected{nullptr};
-        !current_item->next.compare_exchange_weak(expected, new_item);
-        expected = nullptr)
-    {
-        if (expected) current_item = expected;
-    }
-}
-
-template<class Observer>
-void BasicObservers<Observer>::remove(std::shared_ptr<Observer> const& observer)
-{
-    ListItem* current_item = &head;
-
-    do
-    {
-        {
-            RecursiveReadLock lock{current_item->mutex};
-            if (current_item->observer != observer) continue;
-        }
-
-        RecursiveWriteLock lock{current_item->mutex};
-
-        if (current_item->observer == observer)
-        {
-            current_item->observer.reset();
-            return;
-        }
-    }
-    while ((current_item = current_item->next));
-}
 }
 
 #endif /* MIR_BASIC_OBSERVERS_H_ */

=== added file 'src/include/common/mir/thread_safe_list.h'
--- src/include/common/mir/thread_safe_list.h	1970-01-01 00:00:00 +0000
+++ src/include/common/mir/thread_safe_list.h	2014-10-31 11:59:50 +0000
@@ -0,0 +1,186 @@
+/*
+ * Copyright © 2014 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: Alan Griffiths <[e-mail]>
+                Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_THREAD_SAFE_LIST_H_
+#define MIR_THREAD_SAFE_LIST_H_
+
+#include "mir/recursive_read_write_mutex.h"
+
+#include <atomic>
+
+namespace mir
+{
+
+/*
+ * Requirements for type 'Element'
+ *  - for_each():
+ *    - copy-assignable
+ *  - add()
+ *    - copy-assignable
+ *    - operator bool: returns whether this is a valid element
+ *  - remove(), remove_all():
+ *    - copy-assignable
+ *    - Element{}: default construction should create an invalid element
+ *    - bool operator==: equality between two elements
+ *    - bool operator!=: inequality between two elements
+ *  - clear():
+ *    - copy-assignable
+ *    - Element{}: default construction should create an invalid element
+ */
+
+template<class Element>
+class ThreadSafeList
+{
+public:
+    void add(Element const& element);
+    void remove(Element const& element);
+    unsigned int remove_all(Element const& element);
+    void clear();
+    void for_each(std::function<void(Element const& element)> const& f);
+
+private:
+    struct ListItem
+    {
+        ListItem() {}
+        RecursiveReadWriteMutex mutex;
+        Element element;
+        std::atomic<ListItem*> next{nullptr};
+
+        ~ListItem() { delete next.load(); }
+    } head;
+};
+
+template<class Element>
+void ThreadSafeList<Element>::for_each(
+    std::function<void(Element const& element)> const& f)
+{
+    ListItem* current_item = &head;
+
+    while (current_item)
+    {
+        RecursiveReadLock lock{current_item->mutex};
+
+        // We need to take a copy in case we recursively remove during call
+        if (auto const copy_of_element = current_item->element) f(copy_of_element);
+
+        current_item = current_item->next;
+    }
+}
+
+template<class Element>
+void ThreadSafeList<Element>::add(Element const& element)
+{
+    ListItem* current_item = &head;
+
+    do
+    {
+        // Note: we release the read lock to avoid two threads calling add at
+        // the same time mutually blocking the other's upgrade to write lock.
+        {
+            RecursiveReadLock lock{current_item->mutex};
+            if (current_item->element) continue;
+        }
+
+        RecursiveWriteLock lock{current_item->mutex};
+
+        if (!current_item->element)
+        {
+            current_item->element = element;
+            return;
+        }
+    }
+    while (current_item->next && (current_item = current_item->next));
+
+    // No empty Items so append a new one
+    auto new_item = new ListItem;
+    new_item->element = element;
+
+    for (ListItem* expected{nullptr};
+        !current_item->next.compare_exchange_weak(expected, new_item);
+        expected = nullptr)
+    {
+        if (expected) current_item = expected;
+    }
+}
+
+template<class Element>
+void ThreadSafeList<Element>::remove(Element const& element)
+{
+    ListItem* current_item = &head;
+
+    do
+    {
+        {
+            RecursiveReadLock lock{current_item->mutex};
+            if (current_item->element != element) continue;
+        }
+
+        RecursiveWriteLock lock{current_item->mutex};
+
+        if (current_item->element == element)
+        {
+            current_item->element = Element{};
+            return;
+        }
+    }
+    while ((current_item = current_item->next));
+}
+
+template<class Element>
+unsigned int ThreadSafeList<Element>::remove_all(Element const& element)
+{
+    ListItem* current_item = &head;
+    auto removed = 0u;
+
+    do
+    {
+        {
+            RecursiveReadLock lock{current_item->mutex};
+            if (current_item->element != element) continue;
+        }
+
+        RecursiveWriteLock lock{current_item->mutex};
+
+        if (current_item->element == element)
+        {
+            current_item->element = Element{};
+            ++removed;
+        }
+    }
+    while ((current_item = current_item->next));
+
+    return removed;
+}
+
+template<class Element>
+void ThreadSafeList<Element>::clear()
+{
+    ListItem* current_item = &head;
+
+    do
+    {
+        RecursiveWriteLock lock{current_item->mutex};
+        current_item->element = Element{};
+    }
+    while ((current_item = current_item->next));
+}
+
+}
+
+#endif /* MIR_THREAD_SAFE_LIST_H_ */

=== modified file 'src/include/common/mir/time/high_resolution_clock.h'
--- src/include/common/mir/time/high_resolution_clock.h	2014-10-01 06:25:56 +0000
+++ src/include/common/mir/time/high_resolution_clock.h	2014-10-31 11:59:50 +0000
@@ -29,7 +29,8 @@
 class HighResolutionClock : public Clock
 {
 public:
-    virtual Timestamp sample() const override;
+    Timestamp sample() const override;
+    Duration timeout_until(Timestamp t) const override;
 
 private:
     std::chrono::high_resolution_clock clock;

=== added file 'src/include/server/mir/glib_main_loop.h'
--- src/include/server/mir/glib_main_loop.h	1970-01-01 00:00:00 +0000
+++ src/include/server/mir/glib_main_loop.h	2014-10-31 11:59:50 +0000
@@ -0,0 +1,84 @@
+#ifndef MIR_GLIB_MAIN_LOOP_H_
+#define MIR_GLIB_MAIN_LOOP_H_
+
+#include "mir/main_loop.h"
+
+#include <glib.h>
+#include <memory>
+#include <thread>
+#include <vector>
+#include <atomic>
+#include <mutex>
+#include <unordered_set>
+
+namespace mir
+{
+namespace time
+{
+class Clock;
+}
+namespace detail
+{
+class SignalDispatch;
+struct FdGSource;
+struct TimerGSource;
+struct ServerActionGSource;
+}
+
+class GLibMainLoop : public MainLoop
+{
+public:
+    explicit GLibMainLoop(std::shared_ptr<time::Clock> const& clock);
+    ~GLibMainLoop();
+
+    void run() override;
+    void stop() override;
+
+    void register_signal_handler(
+        std::initializer_list<int> signals,
+        std::function<void(int)> const& handler) override;
+
+    void register_fd_handler(
+        std::initializer_list<int> fds,
+        void const* owner,
+        std::function<void(int)> const& handler) override;
+
+    void unregister_fd_handler(
+        void const* owner) override;
+
+    std::unique_ptr<mir::time::Alarm> notify_in(
+        std::chrono::milliseconds delay,
+        std::function<void()> callback) override;
+
+    std::unique_ptr<mir::time::Alarm> notify_at(
+        mir::time::Timestamp t,
+        std::function<void()> callback) override;
+
+    std::unique_ptr<time::Alarm> create_alarm(std::function<void()> callback) override;
+
+    void enqueue(void const* owner, ServerAction const& action) override;
+    void pause_processing_for(void const* owner) override;
+    void resume_processing_for(void const* owner) override;
+
+    void flush();
+
+private:
+    std::shared_ptr<time::Clock> const clock;
+    std::shared_ptr<GMainContext> main_context;
+    std::atomic<bool> running;
+
+    std::mutex fd_gsources_mutex;
+    std::vector<std::shared_ptr<detail::FdGSource>> fd_gsources;
+
+    std::unique_ptr<detail::SignalDispatch> signal_dispatch;
+
+    std::mutex before_next_iteration_mutex;
+    std::function<void()> before_next_iteration;
+
+    std::mutex server_actions_mutex;
+    std::unordered_set<void const*> do_not_process;
+};
+        
+}
+
+#endif

=== modified file 'src/server/CMakeLists.txt'
--- src/server/CMakeLists.txt	2014-10-21 16:21:14 +0000
+++ src/server/CMakeLists.txt	2014-10-31 11:59:50 +0000
@@ -3,6 +3,7 @@
   ${PROJECT_SOURCE_DIR}/src/include/platform
   ${PROJECT_SOURCE_DIR}/include/server
   ${PROJECT_SOURCE_DIR}/src/include/server
+  ${GLIB_INCLUDE_DIRS}
 )
 
 add_subdirectory(compositor/)
@@ -31,6 +32,7 @@
   display_server.cpp
   default_server_configuration.cpp
   asio_main_loop.cpp
+  glib_main_loop.cpp
   default_emergency_cleanup.cpp
   server.cpp
 )
@@ -59,6 +61,7 @@
   ${EGL_LDFLAGS} ${EGL_LIBRARIES}
   ${GLESv2_LDFLAGS} ${GLESv2_LIBRARIES}
   ${UDEV_LDFLAGS} ${UDEV_LIBRARIES}
+  ${GLIB_LDFLAGS} ${GLIB_LIBRARIES}
 )
 
 set(MIR_SERVER_OBJECTS ${MIR_SERVER_OBJECTS} PARENT_SCOPE)
@@ -79,6 +82,7 @@
   ${EGL_LDFLAGS} ${EGL_LIBRARIES}
   ${GLESv2_LDFLAGS} ${GLESv2_LIBRARIES}
   ${UDEV_LDFLAGS} ${UDEV_LIBRARIES}
+  ${GLIB_LDFLAGS} ${GLIB_LIBRARIES}
 )
 
 install(TARGETS mirserver

=== modified file 'src/server/default_server_configuration.cpp'
--- src/server/default_server_configuration.cpp	2014-10-01 06:25:56 +0000
+++ src/server/default_server_configuration.cpp	2014-10-31 11:59:50 +0000
@@ -21,6 +21,7 @@
 #include "mir/options/default_configuration.h"
 #include "mir/abnormal_exit.h"
 #include "mir/asio_main_loop.h"
+#include "mir/glib_main_loop.h"
 #include "mir/default_server_status_listener.h"
 #include "mir/emergency_cleanup.h"
 #include "mir/default_configuration.h"
@@ -166,7 +167,7 @@
     return main_loop(
         [this]()
         {
-            return std::make_shared<mir::AsioMainLoop>(the_clock());
+            return std::make_shared<mir::GLibMainLoop>(the_clock());
         });
 }
 

=== modified file 'src/server/display_server.cpp'
--- src/server/display_server.cpp	2014-10-21 16:21:14 +0000
+++ src/server/display_server.cpp	2014-10-31 11:59:50 +0000
@@ -32,6 +32,7 @@
 #include "mir/input/input_dispatcher.h"
 
 #include <stdexcept>
+#include <signal.h>
 
 namespace mc = mir::compositor;
 namespace mf = mir::frontend;

=== added file 'src/server/glib_main_loop.cpp'
--- src/server/glib_main_loop.cpp	1970-01-01 00:00:00 +0000
+++ src/server/glib_main_loop.cpp	2014-10-31 11:59:50 +0000
@@ -0,0 +1,726 @@
+#include "mir/glib_main_loop.h"
+#include "mir/fd.h"
+
+#include <sys/signalfd.h>
+#include <unistd.h>
+#include <boost/throw_exception.hpp>
+#include <iostream>
+#include <algorithm>
+#include <atomic>
+#include <future>
+#include "mir/thread_safe_list.h"
+#include <glib-unix.h>
+
+#define ALFDEBUG if (false)
+
+namespace
+{
+
+template<typename T> using Handlers = mir::ThreadSafeList<T>;
+
+class MainLoopSource
+{
+public:
+    MainLoopSource(GSource* gsource) : gsource{gsource} {}
+
+    virtual ~MainLoopSource() = default;
+
+    virtual gboolean prepare(gint* timeout) = 0;
+    virtual gboolean check() = 0;
+    virtual gboolean dispatch() = 0;
+
+protected:
+    GSource* gsource;
+};
+
+class FdMainLoopSource : public MainLoopSource
+{
+public:
+    FdMainLoopSource(GSource* source, int fd)
+        : MainLoopSource{source}, fd_{fd},
+          fd_tag{g_source_add_unix_fd(source, fd, G_IO_IN)}
+    {
+        if (fd_tag == nullptr)
+            BOOST_THROW_EXCEPTION(std::runtime_error("g source fd failed"));
+    }
+
+    void add_handler(std::function<void(int)> const& handler, void const* owner)
+    {
+        handlers.add({handler, owner});
+        ++num_handlers;
+    }
+
+    void remove_handlers_of(void const* owner)
+    {
+        num_handlers -= handlers.remove_all({{}, owner});
+    }
+
+    bool has_handlers() const
+    {
+        return num_handlers > 0;
+    }
+
+    int fd() const
+    {
+        return fd_;
+    }
+
+    gboolean prepare(gint* timeout) override
+    {
+        *timeout = -1;
+        return (g_source_query_unix_fd(gsource, fd_tag) == G_IO_IN);
+    }
+
+    gboolean check() override
+    {
+        return (g_source_query_unix_fd(gsource, fd_tag) == G_IO_IN);
+    }
+
+    gboolean dispatch() override
+    {
+        if (g_source_query_unix_fd(gsource, fd_tag) == G_IO_IN)
+        {
+            handlers.for_each(
+                [&] (HandlerElement const& element)
+                {
+                    element.handler(fd_);
+                });
+        }
+
+        return TRUE;
+    }
+
+private:
+    struct HandlerElement
+    {
+        HandlerElement() : owner{nullptr} {}
+        HandlerElement(std::function<void(int)> const& handler,
+                       void const* owner) : handler{handler}, owner{owner} {}
+
+        operator bool() const { return owner != nullptr; }
+        bool operator==(HandlerElement const& other) const { return other.owner == owner; }
+        bool operator!=(HandlerElement const& other) const { return other.owner != owner; }
+
+        std::function<void(int)> handler;
+        void const* owner;
+    };
+
+    Handlers<HandlerElement> handlers;
+    std::atomic<int> num_handlers{0};
+    int const fd_;
+    gpointer fd_tag;
+};
+
+class TimerMainLoopSource : public MainLoopSource
+{
+public:
+    TimerMainLoopSource(GSource* source,
+                        std::shared_ptr<mir::time::Clock> const& clock,
+                        mir::time::Timestamp target)
+        : MainLoopSource{source}, clock{clock},
+          target{target}
+    {
+        ALFDEBUG std::cerr << this << " TimeSource create " << std::endl;
+    }
+
+    void add_handler(std::function<void()> const& handler)
+    {
+        handlers.add({handler});
+    }
+
+    void clear_handlers()
+    {
+        handlers.clear();
+    }
+
+    gboolean prepare(gint* timeout) override
+    {
+        auto const now = clock->sample();
+        bool const ready = (now >= target);
+        if (ready)
+            *timeout = -1;
+        else
+            *timeout = std::chrono::duration_cast<std::chrono::milliseconds>(
+                clock->timeout_until(target)).count();
+
+        ALFDEBUG std::cerr << this << " TimeSource prepare: " << ready << " " << *timeout << std::endl;
+        return ready;
+    }
+
+    gboolean check() override
+    {
+        auto const now = clock->sample();
+        bool const ready = (now >= target);
+        ALFDEBUG std::cerr << this << " TimeSource check: " << ready << std::endl;
+        return ready;
+    }
+
+    gboolean dispatch() override
+    {
+        ALFDEBUG std::cerr << this << " TimeSource dispatch: " << std::endl;
+        handlers.for_each(
+            [&] (HandlerElement const& element)
+            {
+                element.handler();
+            });
+
+        return FALSE;
+    }
+
+private:
+    struct HandlerElement
+    {
+        HandlerElement() = default;
+        HandlerElement(std::function<void(void)> const& handler) : handler{handler} {}
+        operator bool() const { return !!handler; }
+        std::function<void(void)> handler;
+    };
+
+    Handlers<HandlerElement> handlers;
+    std::shared_ptr<mir::time::Clock> const clock;
+    mir::time::Timestamp const target;
+};
+
+class ServerActionMainLoopSource : public MainLoopSource
+{
+public:
+    ServerActionMainLoopSource(
+        GSource* gsource, void const* owner, mir::ServerAction const& action,
+        std::function<bool(void const*)> const& should_dispatch)
+        : MainLoopSource{gsource}, owner{owner}, action{action},
+          should_dispatch{should_dispatch}
+    {
+        ALFDEBUG std::cerr << this << " TimeSource create " << std::endl;
+    }
+
+    gboolean prepare(gint* timeout) override
+    {
+        ALFDEBUG std::cerr << this << " ServerAction prepare: " << std::endl;
+        *timeout = -1;
+        return should_dispatch(owner);
+    }
+
+    gboolean check() override
+    {
+        ALFDEBUG std::cerr << this << " ServerAction check: " << std::endl;
+        return should_dispatch(owner);
+    }
+
+    gboolean dispatch() override
+    {
+        ALFDEBUG std::cerr << this << " ServerAction dispatch: " << std::endl;
+        action();
+        return FALSE;
+    }
+
+private:
+    void const* const owner;
+    mir::ServerAction const action;
+    std::function<bool(void const*)> const should_dispatch;
+};
+
+
+
+struct MainLoopGSource
+{
+    GSource gsource;
+    MainLoopSource* source;
+
+    void attach(GMainContext* main_context)
+    {
+        g_source_attach(&gsource, main_context);
+    }
+};
+
+gboolean ml_prepare(GSource* source, gint *timeout)
+{
+    ALFDEBUG std::cerr << "ml_prepare" << std::endl;
+    auto ml_source = reinterpret_cast<MainLoopGSource*>(source);
+    if (!g_source_is_destroyed(source))
+        return ml_source->source->prepare(timeout);
+    return FALSE;
+}
+
+gboolean ml_check(GSource* source)
+{
+    ALFDEBUG std::cerr << "ml_check" << std::endl;
+    auto ml_source = reinterpret_cast<MainLoopGSource*>(source);
+    if (!g_source_is_destroyed(source))
+    return ml_source->source->check();
+    return FALSE;
+}
+
+gboolean ml_dispatch(GSource* source, GSourceFunc, gpointer)
+{
+    ALFDEBUG std::cerr << "ml_dispatch" << std::endl;
+    auto ml_source = reinterpret_cast<MainLoopGSource*>(source);
+    if (!g_source_is_destroyed(source))
+        return ml_source->source->dispatch();
+    return FALSE;
+}
+
+void ml_finalize(GSource* source)
+{
+    ALFDEBUG std::cerr << "ml_finalize" << std::endl;
+    auto ml_source = reinterpret_cast<MainLoopGSource*>(source);
+    delete ml_source->source;
+}
+
+GSourceFuncs gsource_funcs {
+    ml_prepare,
+    ml_check,
+    ml_dispatch,
+    ml_finalize,
+    nullptr,
+    nullptr
+};
+
+}
+
+class mir::detail::SignalDispatch
+{
+public:
+    SignalDispatch(GMainContext* main_context)
+        : main_context{main_context}
+    {
+    }
+
+    void add_handler(std::vector<int> const& sigs, std::function<void(int)> const& handler)
+    {
+        for (auto sig : sigs)
+            ensure_handle_signal(sig);
+        handlers.add({sigs, handler});
+    }
+
+    void ensure_handle_signal(int sig)
+    {
+        std::lock_guard<std::mutex> lock{handled_signals_mutex};
+
+        if (handled_signals.find(sig) != handled_signals.end())
+            return;
+
+        auto const gsource = g_unix_signal_source_new(sig);
+        auto sc = new SignalContext{this, sig};
+        g_source_set_callback(
+            gsource,
+            reinterpret_cast<GSourceFunc>(static_dispatch), sc,
+            reinterpret_cast<GDestroyNotify>(destroy_sc));
+        g_source_attach(gsource, main_context);
+        g_source_unref(gsource);
+    }
+
+    void dispatch(int sig)
+    {
+        handlers.for_each(
+            [&] (HandlerElement const& element)
+            {
+                ALFDEBUG std::cerr << this << " SignalDispatch calling handler sig " << sig << std::endl;
+                if (std::find(element.sigs.begin(), element.sigs.end(), sig) != element.sigs.end())
+                    element.handler(sig);
+            });
+    }
+
+private:
+    struct SignalContext
+    {
+        mir::detail::SignalDispatch* sd;
+        int sig;
+    };
+
+    static void destroy_sc(SignalContext* d) { delete d; }
+
+    struct HandlerElement
+    {
+        operator bool() const { return !!handler; }
+        std::vector<int> sigs;
+        std::function<void(int)> handler;
+    };
+
+    static gboolean static_dispatch(SignalContext* sc)
+    {
+        sc->sd->dispatch(sc->sig);
+        return TRUE;
+    }
+
+
+    GMainContext* const main_context;
+    Handlers<HandlerElement> handlers;
+    std::mutex handled_signals_mutex;
+    std::unordered_set<int> handled_signals;
+};
+
+struct mir::detail::FdGSource : MainLoopGSource
+{
+    FdMainLoopSource* fd_source()
+    {
+        return static_cast<FdMainLoopSource*>(source);
+    }
+};
+
+std::shared_ptr<mir::detail::FdGSource> make_fd_gsource(int fd)
+{
+    auto const gsource = g_source_new(&gsource_funcs, sizeof(mir::detail::FdGSource));
+    auto const fd_gsource = reinterpret_cast<mir::detail::FdGSource*>(gsource);
+
+    fd_gsource->source = new FdMainLoopSource{gsource, fd};
+
+    return {
+        fd_gsource,
+        [] (mir::detail::FdGSource* s)
+        { 
+            auto const gsource = reinterpret_cast<GSource*>(s);
+            g_source_destroy(gsource);
+            g_source_unref(gsource);
+        }};
+}
+
+struct mir::detail::TimerGSource : MainLoopGSource
+{
+    TimerMainLoopSource* timer_source()
+    {
+        return static_cast<TimerMainLoopSource*>(source);
+    }
+};
+
+std::shared_ptr<mir::detail::TimerGSource> make_timer_gsource(
+    std::shared_ptr<mir::time::Clock> const& clock,
+    mir::time::Timestamp target)
+{
+    auto const gsource = g_source_new(&gsource_funcs, sizeof(mir::detail::TimerGSource));
+    auto const timer_gsource = reinterpret_cast<mir::detail::TimerGSource*>(gsource);
+
+    timer_gsource->source = new TimerMainLoopSource{gsource, clock, target};
+
+    return {
+        timer_gsource,
+        [] (mir::detail::TimerGSource* s)
+        { 
+            // Clear handlers to ensure that no handlers will be called after this object
+            // has been destroyed (in case we are destroying while the source is being 
+            // dispatched).
+            s->timer_source()->clear_handlers();
+            auto const gsource = reinterpret_cast<GSource*>(s);
+            g_source_destroy(gsource);
+            g_source_unref(gsource);
+        }};
+}
+
+struct mir::detail::ServerActionGSource : MainLoopGSource
+{
+};
+
+std::shared_ptr<mir::detail::ServerActionGSource> make_server_action_gsource(
+    void const* owner, mir::ServerAction const& action,
+    std::function<bool(void const*)> const& should_dispatch)
+{
+    auto const gsource = g_source_new(&gsource_funcs, sizeof(mir::detail::ServerActionGSource));
+    auto const server_action_gsource = reinterpret_cast<mir::detail::ServerActionGSource*>(gsource);
+
+    server_action_gsource->source =
+        new ServerActionMainLoopSource{gsource, owner, action, should_dispatch};
+
+    return {
+        server_action_gsource,
+        [] (mir::detail::ServerActionGSource* s)
+        { 
+            auto const gsource = reinterpret_cast<GSource*>(s);
+            // NB: we shouldn't destroy the gsource
+            //g_source_destroy(gsource);
+            g_source_unref(gsource);
+        }};
+}
+
+class AlarmImpl : public mir::time::Alarm
+{
+public:
+    AlarmImpl(
+        GMainContext* main_context,
+        std::shared_ptr<mir::time::Clock> const& clock,
+        std::function<void()> const& callback)
+        : clock{clock},
+          callback{callback},
+          state_{State::cancelled},
+          main_context{main_context}
+    {
+    }
+
+    bool cancel() override
+    {
+        std::lock_guard<std::mutex> lock{alarm_mutex};
+
+        source.reset();
+        state_ = State::cancelled;
+        return true;
+    }
+
+    State state() const override
+    {
+        std::lock_guard<std::mutex> lock{alarm_mutex};
+
+        return state_;
+    }
+
+    bool reschedule_in(std::chrono::milliseconds delay) override
+    {
+        return reschedule_for(clock->sample() + delay);
+    }
+
+    bool reschedule_for(mir::time::Timestamp time_point) override
+    {
+        std::lock_guard<std::mutex> lock{alarm_mutex};
+
+        state_ = State::pending;
+        source = make_timer_gsource(clock, time_point);
+        source->timer_source()->add_handler(
+            [&] { state_ = State::triggered; callback(); } );
+        source->attach(main_context);
+        return true;
+    }
+
+private:
+    mutable std::mutex alarm_mutex;
+    std::shared_ptr<mir::time::Clock> const clock;
+    std::function<void()> const callback;
+    State state_;
+    std::shared_ptr<mir::detail::TimerGSource> source;
+    GMainContext* main_context;
+};
+
+
+
+mir::GLibMainLoop::GLibMainLoop(
+    std::shared_ptr<time::Clock> const& clock)
+    : clock{clock},
+      main_context{g_main_context_new(),
+            [] (GMainContext* ctx)
+            { 
+                if (ctx) g_main_context_unref(ctx);
+            }},
+      signal_dispatch{new detail::SignalDispatch{main_context.get()}},
+      before_next_iteration{[]{}}
+{
+}
+
+mir::GLibMainLoop::~GLibMainLoop()
+{
+    stop();
+}
+
+void mir::GLibMainLoop::run()
+{
+    running = true;
+    ALFDEBUG std::cerr << "run start" << std::endl;
+    while (running)
+    {
+        ALFDEBUG std::cerr << "run iter start " << running << std::endl;
+        {
+        std::lock_guard<std::mutex> lock{before_next_iteration_mutex};
+        before_next_iteration();
+        }
+        ALFDEBUG std::cerr << "run iter 2 " << running << std::endl;
+        g_main_context_iteration(main_context.get(), TRUE);
+        ALFDEBUG std::cerr << "run iter end " << running << std::endl;
+    }
+    ALFDEBUG std::cerr << "run end" << std::endl;
+}
+
+struct StopContext
+{
+    std::atomic<bool>* running;
+    GMainContext* main_context;
+};
+
+gboolean stop_func(gpointer data)
+{
+    auto stop_context = static_cast<StopContext*>(data);
+
+    *stop_context->running = false;
+    g_main_context_wakeup(stop_context->main_context);
+    return FALSE;
+}
+
+
+void delete_stop_context(StopContext* ctx)
+{
+    delete ctx;
+}
+
+void mir::GLibMainLoop::stop()
+{
+    ALFDEBUG std::cerr << "stop() " << running << std::endl;
+    int const very_high_priority = -1000;
+    auto source = g_idle_source_new();
+
+    g_source_set_priority(source, very_high_priority);
+    g_source_set_callback(
+        source, stop_func,
+        new StopContext{&running, main_context.get()},
+        reinterpret_cast<GDestroyNotify>(delete_stop_context));
+    g_source_attach(source, main_context.get());
+    g_source_unref(source);
+}
+
+void mir::GLibMainLoop::register_signal_handler(
+    std::initializer_list<int> signals,
+    std::function<void(int)> const& handler)
+{
+    signal_dispatch->add_handler(signals, handler);
+}
+
+void mir::GLibMainLoop::register_fd_handler(
+    std::initializer_list<int> fds,
+    void const* owner,
+    std::function<void(int)> const& handler)
+{
+    std::lock_guard<std::mutex> lock{fd_gsources_mutex};
+
+    for (auto fd : fds)
+    {
+        std::shared_ptr<detail::FdGSource> gsource;
+        bool new_gsource{false};
+
+        auto iter = std::find_if(
+            fd_gsources.begin(),
+            fd_gsources.end(),
+            [&] (std::shared_ptr<detail::FdGSource> const& f)
+            { 
+                return f->fd_source()->fd() == fd;
+            });
+
+        if (iter == fd_gsources.end())
+        {
+            gsource = make_fd_gsource(fd);
+            new_gsource = true;
+            fd_gsources.push_back(gsource);
+        }
+        else
+        {
+            gsource = *iter;
+        }
+
+        gsource->fd_source()->add_handler(handler, owner);
+        if (new_gsource)
+            gsource->attach(main_context.get());
+    }
+}
+
+void mir::GLibMainLoop::unregister_fd_handler(
+    void const* owner)
+{
+    std::lock_guard<std::mutex> lock{fd_gsources_mutex};
+
+    ALFDEBUG std::cerr << "unregister_fd_handler " << owner << std::endl;
+
+    auto it = fd_gsources.rbegin();
+
+    while (it != fd_gsources.rend())
+    {
+        auto const gsource = *it;
+        gsource->fd_source()->remove_handlers_of(owner);
+
+        ALFDEBUG std::cerr << "removed handler" << std::endl;
+        if (!gsource->fd_source()->has_handlers())
+        {
+            ALFDEBUG std::cerr << "no handler left " << std::endl;
+            it = decltype(fd_gsources)::reverse_iterator(
+                    fd_gsources.erase(std::prev(it.base())));
+        }
+        else
+        {
+            ++it;
+        }
+    }
+}
+
+std::unique_ptr<mir::time::Alarm> mir::GLibMainLoop::notify_in(
+    std::chrono::milliseconds delay,
+    std::function<void()> callback)
+{
+    auto alarm = std::unique_ptr<mir::time::Alarm>{
+        new AlarmImpl{main_context.get(), clock, callback}};
+    
+    alarm->reschedule_in(delay);
+
+    return alarm;
+}
+
+std::unique_ptr<mir::time::Alarm> mir::GLibMainLoop::notify_at(
+    mir::time::Timestamp t,
+    std::function<void()> callback)
+{
+    auto alarm = std::unique_ptr<mir::time::Alarm>{
+        new AlarmImpl{main_context.get(), clock, callback}};
+    
+    alarm->reschedule_for(t);
+
+    return alarm;
+}
+
+std::unique_ptr<mir::time::Alarm> mir::GLibMainLoop::create_alarm(
+    std::function<void()> callback)
+{
+    return std::unique_ptr<mir::time::Alarm>{
+        new AlarmImpl{main_context.get(), clock, callback}};
+}
+
+void mir::GLibMainLoop::enqueue(void const* owner, ServerAction const& action)
+{
+    auto gsource = make_server_action_gsource(owner, action,
+        [&] (void const* owner)
+        {
+            std::lock_guard<std::mutex> lock{server_actions_mutex};
+            return (do_not_process.find(owner) == do_not_process.end());
+        });
+    gsource->attach(main_context.get());
+}
+
+void mir::GLibMainLoop::pause_processing_for(void const* owner)
+{
+    std::lock_guard<std::mutex> lock{server_actions_mutex};
+    do_not_process.insert(owner);
+}
+
+void mir::GLibMainLoop::resume_processing_for(void const* owner)
+{
+    std::lock_guard<std::mutex> lock{server_actions_mutex};
+    do_not_process.erase(owner);
+
+    g_main_context_wakeup(main_context.get());
+}
+
+gboolean flush_func(gpointer data)
+{
+    ALFDEBUG std::cerr << "Flush!" << std::endl;
+    auto to_flush = static_cast<std::promise<void>*>(data);
+    to_flush->set_value();
+
+    return FALSE;
+}
+
+void mir::GLibMainLoop::flush()
+{
+    std::promise<void> to_flush;
+    auto flushed = to_flush.get_future();
+
+    {
+        std::lock_guard<std::mutex> lock{before_next_iteration_mutex};
+        before_next_iteration = [&] {
+            ALFDEBUG std::cerr << "g_idle_add_full" << std::endl;
+
+            auto source = g_idle_source_new();
+            g_source_set_priority(source, G_PRIORITY_LOW);
+            g_source_set_callback(source, flush_func, &to_flush, nullptr);
+            g_source_attach(source, main_context.get());
+            g_source_unref(source);
+
+            before_next_iteration = []{};
+        };
+    }
+
+    g_main_context_wakeup(main_context.get());
+
+    ALFDEBUG std::cerr << "Waiting for before_next_iteration done" << std::endl;
+
+    flushed.get();
+    ALFDEBUG std::cerr << "flush finished" << std::endl;
+}

=== modified file 'tests/integration-tests/CMakeLists.txt'
--- tests/integration-tests/CMakeLists.txt	2014-10-28 13:59:51 +0000
+++ tests/integration-tests/CMakeLists.txt	2014-10-31 11:59:50 +0000
@@ -7,6 +7,7 @@
   ${PROJECT_SOURCE_DIR}/src/include/platform
   ${PROJECT_SOURCE_DIR}/src/include/server
   ${PROJECT_SOURCE_DIR}/src/include/client
+  ${GLIB_INCLUDE_DIRS}
 )
 
 protobuf_generate_cpp(
@@ -99,6 +100,7 @@
   ${CMAKE_THREAD_LIBS_INIT} # Link in pthread.
   ${DRM_LDFLAGS} ${DRM_LIBRARIES}
   ${GBM_LDFLAGS} ${GBM_LIBRARIES}
+  ${GLIB_LDFLAGS} ${GLIB_LIBRARIES}
   ${MIR_PLATFORM_REFERENCES}
   ${MIR_COMMON_REFERENCES}
   ${MIR_SERVER_REFERENCES}

=== modified file 'tests/unit-tests/CMakeLists.txt'
--- tests/unit-tests/CMakeLists.txt	2014-10-27 18:00:20 +0000
+++ tests/unit-tests/CMakeLists.txt	2014-10-31 11:59:50 +0000
@@ -25,6 +25,7 @@
   test_gmock_fixes.cpp
   test_recursive_read_write_mutex.cpp
   test_asio_main_loop.cpp
+  test_glib_main_loop.cpp
   shared_library_test.cpp
   test_raii.cpp
   test_udev_wrapper.cpp
@@ -32,6 +33,7 @@
   test_thread_name.cpp
   test_default_emergency_cleanup.cpp
   test_basic_observers.cpp
+  test_thread_safe_list.cpp
   test_fatal.cpp
   test_fd.cpp
   test_shared_library_prober.cpp

=== modified file 'tests/unit-tests/client/test_periodic_perf_report.cpp'
--- tests/unit-tests/client/test_periodic_perf_report.cpp	2014-09-05 08:00:44 +0000
+++ tests/unit-tests/client/test_periodic_perf_report.cpp	2014-10-31 11:59:50 +0000
@@ -37,6 +37,10 @@
     {
         return now;
     }
+    time::Duration timeout_until(time::Timestamp) const override
+    {
+        return time::Duration{0};
+    }
 private:
     time::Timestamp now;
 };

=== modified file 'tests/unit-tests/graphics/mesa/test_display.cpp'
--- tests/unit-tests/graphics/mesa/test_display.cpp	2014-10-01 06:25:56 +0000
+++ tests/unit-tests/graphics/mesa/test_display.cpp	2014-10-31 11:59:50 +0000
@@ -25,6 +25,7 @@
 #include "src/server/graphics/default_display_configuration_policy.h"
 #include "mir/time/high_resolution_clock.h"
 #include "mir/asio_main_loop.h"
+#include "mir/glib_main_loop.h"
 
 #include "mir_test_doubles/mock_egl.h"
 #include "mir_test_doubles/mock_gl.h"
@@ -717,7 +718,7 @@
 
     auto display = create_display(create_platform());
 
-    mir::AsioMainLoop ml{std::make_shared<mir::time::HighResolutionClock>()};
+    mir::GLibMainLoop ml{std::make_shared<mir::time::HighResolutionClock>()};
     std::condition_variable done;
 
     int const device_add_count{1};

=== modified file 'tests/unit-tests/logging/message_processor_report.cpp'
--- tests/unit-tests/logging/message_processor_report.cpp	2014-03-06 06:05:17 +0000
+++ tests/unit-tests/logging/message_processor_report.cpp	2014-10-31 11:59:50 +0000
@@ -32,6 +32,10 @@
 {
 public:
     MOCK_CONST_METHOD0(sample, mir::time::Timestamp());
+    mir::time::Duration timeout_until(mir::time::Timestamp) const override
+    { 
+        return mir::time::Duration{0};
+    }
 
     ~MockClock() noexcept(true) {}
 };

=== modified file 'tests/unit-tests/test_asio_main_loop.cpp'
--- tests/unit-tests/test_asio_main_loop.cpp	2014-10-21 16:21:14 +0000
+++ tests/unit-tests/test_asio_main_loop.cpp	2014-10-31 11:59:50 +0000
@@ -56,6 +56,10 @@
         std::lock_guard<std::mutex> lock(time_mutex);
         return current_time;
     }
+    mir::time::Duration timeout_until(mir::time::Timestamp) const override
+    {
+        return mir::time::Duration{0};
+    }
     void advance_by(std::chrono::milliseconds const step, mir::AsioMainLoop & ml)
     {
         bool done = false;

=== added file 'tests/unit-tests/test_glib_main_loop.cpp'
--- tests/unit-tests/test_glib_main_loop.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/test_glib_main_loop.cpp	2014-10-31 11:59:50 +0000
@@ -0,0 +1,901 @@
+/*
+ * 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 <[e-mail]>
+ */
+
+#include "mir/glib_main_loop.h"
+#include "mir/time/high_resolution_clock.h"
+
+#include "mir_test/pipe.h"
+#include "mir_test/signal.h"
+#include "mir_test/auto_unblock_thread.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <atomic>
+#include <mutex>
+#include <condition_variable>
+
+namespace mt = mir::test;
+
+class Counter
+{
+public:
+    int operator++()
+    {
+        std::lock_guard<decltype(mutex)> lock(mutex);
+        cv.notify_one();
+        return ++counter;
+    }
+
+    bool wait_for(std::chrono::milliseconds const& delay, int expected)
+    {
+        std::unique_lock<decltype(mutex)> lock(mutex);
+        return cv.wait_for(lock, delay, [&]{ return counter == expected;});
+    }
+
+    operator int() const
+    {
+        std::lock_guard<decltype(mutex)> lock(mutex);
+        return counter;
+    }
+
+private:
+    std::mutex mutable mutex;
+    std::condition_variable cv;
+    int counter{0};
+};
+
+struct UnblockMainLoop : mt::AutoUnblockThread
+{
+    UnblockMainLoop(mir::GLibMainLoop& loop)
+        : mt::AutoUnblockThread([&loop]() {loop.stop();},
+                                [&loop]() {loop.run();})
+    {}
+};
+
+
+class AdvanceableClock : public mir::time::Clock
+{
+public:
+    mir::time::Timestamp sample() const override
+    {
+        std::lock_guard<std::mutex> lock(time_mutex);
+        return current_time;
+    }
+
+    mir::time::Duration timeout_until(mir::time::Timestamp) const override
+    {
+        std::lock_guard<std::mutex> lock(time_mutex);
+        return mir::time::Duration{0};
+    }
+
+    void advance_by(std::chrono::milliseconds const step, mir::GLibMainLoop& ml)
+    {
+        {
+            std::lock_guard<std::mutex> lock(time_mutex);
+            current_time += step;
+        }
+        ml.flush();
+        //std::cerr << "Advance by finish" << std::endl;
+    }
+
+private:
+    mutable std::mutex time_mutex;
+    mir::time::Timestamp current_time{
+        []
+        {
+           mir::time::HighResolutionClock clock;
+           return clock.sample();
+        }()
+        };
+};
+
+struct GLibMainLoopTest : ::testing::Test
+{
+    mir::GLibMainLoop ml{std::make_shared<mir::time::HighResolutionClock>()};
+};
+
+TEST_F(GLibMainLoopTest, signal_handled)
+{
+    int const signum{SIGUSR1};
+    int handled_signum{0};
+
+    ml.register_signal_handler(
+        {signum},
+        [&handled_signum, this](int sig)
+        {
+           handled_signum = sig;
+           ml.stop();
+        });
+
+    kill(getpid(), signum);
+
+    ml.run();
+
+    ASSERT_EQ(signum, handled_signum);
+}
+
+TEST_F(GLibMainLoopTest, multiple_signals_handled)
+{
+    std::vector<int> const signals{SIGUSR1, SIGUSR2};
+    size_t const num_signals_to_send{10};
+    std::vector<int> handled_signals;
+    std::atomic<unsigned int> num_handled_signals{0};
+
+    ml.register_signal_handler(
+        {signals[0], signals[1]},
+        [&handled_signals, &num_handled_signals](int sig)
+        {
+           handled_signals.push_back(sig);
+           ++num_handled_signals;
+        });
+
+
+    std::thread signal_sending_thread(
+        [this, num_signals_to_send, &signals, &num_handled_signals]
+        {
+            for (size_t i = 0; i < num_signals_to_send; i++)
+            {
+                kill(getpid(), signals[i % signals.size()]);
+                while (num_handled_signals <= i) std::this_thread::yield();
+            }
+            ml.stop();
+        });
+
+    ml.run();
+
+    signal_sending_thread.join();
+
+    ASSERT_EQ(num_signals_to_send, handled_signals.size());
+
+    for (size_t i = 0; i < num_signals_to_send; i++)
+        ASSERT_EQ(signals[i % signals.size()], handled_signals[i]) << " index " << i;
+}
+
+TEST_F(GLibMainLoopTest, all_registered_handlers_are_called)
+{
+    int const signum{SIGUSR1};
+    std::vector<int> handled_signum{0,0,0};
+
+    ml.register_signal_handler(
+        {signum},
+        [&handled_signum, this](int sig)
+        {
+            handled_signum[0] = sig;
+            if (handled_signum[0] != 0 &&
+                handled_signum[1] != 0 &&
+                handled_signum[2] != 0)
+            {
+                ml.stop();
+            }
+        });
+
+    ml.register_signal_handler(
+        {signum},
+        [&handled_signum, this](int sig)
+        {
+            handled_signum[1] = sig;
+            if (handled_signum[0] != 0 &&
+                handled_signum[1] != 0 &&
+                handled_signum[2] != 0)
+            {
+                ml.stop();
+            }
+        });
+
+    ml.register_signal_handler(
+        {signum},
+        [&handled_signum, this](int sig)
+        {
+            handled_signum[2] = sig;
+            if (handled_signum[0] != 0 &&
+                handled_signum[1] != 0 &&
+                handled_signum[2] != 0)
+            {
+                ml.stop();
+            }
+        });
+
+    kill(getpid(), signum);
+
+    ml.run();
+
+    ASSERT_EQ(signum, handled_signum[0]);
+    ASSERT_EQ(signum, handled_signum[1]);
+    ASSERT_EQ(signum, handled_signum[2]);
+}
+
+TEST_F(GLibMainLoopTest, fd_data_handled)
+{
+    mt::Pipe p;
+    char const data_to_write{'a'};
+    int handled_fd{0};
+    char data_read{0};
+
+    ml.register_fd_handler(
+        {p.read_fd()},
+        this,
+        [&handled_fd, &data_read, this](int fd)
+        {
+            handled_fd = fd;
+            EXPECT_EQ(1, read(fd, &data_read, 1));
+            ml.stop();
+        });
+
+    EXPECT_EQ(1, write(p.write_fd(), &data_to_write, 1));
+
+    ml.run();
+
+    EXPECT_EQ(data_to_write, data_read);
+}
+
+TEST_F(GLibMainLoopTest, multiple_fds_with_single_handler_handled)
+{
+    std::vector<mt::Pipe> const pipes(2);
+    size_t const num_elems_to_send{10};
+    std::vector<int> handled_fds;
+    std::vector<size_t> elems_read;
+    std::atomic<unsigned int> num_handled_fds{0};
+
+    ml.register_fd_handler(
+        {pipes[0].read_fd(), pipes[1].read_fd()},
+        this,
+        [&handled_fds, &elems_read, &num_handled_fds](int fd)
+        {
+            handled_fds.push_back(fd);
+
+            size_t i;
+            EXPECT_EQ(static_cast<ssize_t>(sizeof(i)),
+                      read(fd, &i, sizeof(i)));
+            elems_read.push_back(i);
+
+            ++num_handled_fds;
+        });
+
+    std::thread fd_writing_thread{
+        [this, num_elems_to_send, &pipes, &num_handled_fds]
+        {
+            for (size_t i = 0; i < num_elems_to_send; i++)
+            {
+                EXPECT_EQ(static_cast<ssize_t>(sizeof(i)),
+                          write(pipes[i % pipes.size()].write_fd(), &i, sizeof(i)));
+                while (num_handled_fds <= i) std::this_thread::yield();
+            }
+            ml.stop();
+        }};
+
+    ml.run();
+
+    fd_writing_thread.join();
+
+    ASSERT_EQ(num_elems_to_send, handled_fds.size());
+    ASSERT_EQ(num_elems_to_send, elems_read.size());
+
+    for (size_t i = 0; i < num_elems_to_send; i++)
+    {
+        EXPECT_EQ(pipes[i % pipes.size()].read_fd(), handled_fds[i]) << " index " << i;
+        EXPECT_EQ(i, elems_read[i]) << " index " << i;
+    }
+}
+
+TEST_F(GLibMainLoopTest, multiple_fd_handlers_are_called)
+{
+    std::vector<mt::Pipe> const pipes(3);
+    std::vector<int> const elems_to_send{10,11,12};
+    std::vector<int> handled_fds{0,0,0};
+    std::vector<int> elems_read{0,0,0};
+
+    ml.register_fd_handler(
+        {pipes[0].read_fd()},
+        this,
+        [&handled_fds, &elems_read, this](int fd)
+        {
+            EXPECT_EQ(static_cast<ssize_t>(sizeof(elems_read[0])),
+                      read(fd, &elems_read[0], sizeof(elems_read[0])));
+            handled_fds[0] = fd;
+            if (handled_fds[0] != 0 &&
+                handled_fds[1] != 0 &&
+                handled_fds[2] != 0)
+            {
+                ml.stop();
+            }
+        });
+
+    ml.register_fd_handler(
+        {pipes[1].read_fd()},
+        this,
+        [&handled_fds, &elems_read, this](int fd)
+        {
+            EXPECT_EQ(static_cast<ssize_t>(sizeof(elems_read[1])),
+                      read(fd, &elems_read[1], sizeof(elems_read[1])));
+            handled_fds[1] = fd;
+            if (handled_fds[0] != 0 &&
+                handled_fds[1] != 0 &&
+                handled_fds[2] != 0)
+            {
+                ml.stop();
+            }
+        });
+
+    ml.register_fd_handler(
+        {pipes[2].read_fd()},
+        this,
+        [&handled_fds, &elems_read, this](int fd)
+        {
+            EXPECT_EQ(static_cast<ssize_t>(sizeof(elems_read[2])),
+                      read(fd, &elems_read[2], sizeof(elems_read[2])));
+            handled_fds[2] = fd;
+            if (handled_fds[0] != 0 &&
+                handled_fds[1] != 0 &&
+                handled_fds[2] != 0)
+            {
+                ml.stop();
+            }
+        });
+
+    EXPECT_EQ(static_cast<ssize_t>(sizeof(elems_to_send[0])),
+              write(pipes[0].write_fd(), &elems_to_send[0], sizeof(elems_to_send[0])));
+    EXPECT_EQ(static_cast<ssize_t>(sizeof(elems_to_send[1])),
+              write(pipes[1].write_fd(), &elems_to_send[1], sizeof(elems_to_send[1])));
+    EXPECT_EQ(static_cast<ssize_t>(sizeof(elems_to_send[2])),
+              write(pipes[2].write_fd(), &elems_to_send[2], sizeof(elems_to_send[2])));
+
+    ml.run();
+
+    EXPECT_EQ(pipes[0].read_fd(), handled_fds[0]);
+    EXPECT_EQ(pipes[1].read_fd(), handled_fds[1]);
+    EXPECT_EQ(pipes[2].read_fd(), handled_fds[2]);
+
+    EXPECT_EQ(elems_to_send[0], elems_read[0]);
+    EXPECT_EQ(elems_to_send[1], elems_read[1]);
+    EXPECT_EQ(elems_to_send[2], elems_read[2]);
+}
+
+TEST_F(GLibMainLoopTest,
+       unregister_prevents_callback_and_does_not_harm_other_callbacks)
+{
+    mt::Pipe p1, p2;
+    char const data_to_write{'a'};
+    int p2_handler_executes{-1};
+    char data_read{0};
+
+    ml.register_fd_handler(
+        {p1.read_fd()},
+        this,
+        [this](int)
+        {
+            FAIL() << "unregistered handler called";
+            ml.stop();
+        });
+
+    ml.register_fd_handler(
+        {p2.read_fd()},
+        this+2,
+        [&p2_handler_executes,&data_read,this](int fd)
+        {
+            p2_handler_executes = fd;
+            EXPECT_EQ(1, read(fd, &data_read, 1));
+            ml.stop();
+        });
+
+    ml.unregister_fd_handler(this);
+
+    EXPECT_EQ(1, write(p1.write_fd(), &data_to_write, 1));
+    EXPECT_EQ(1, write(p2.write_fd(), &data_to_write, 1));
+
+    ml.run();
+
+    EXPECT_EQ(data_to_write, data_read);
+    EXPECT_EQ(p2.read_fd(), p2_handler_executes);
+}
+
+TEST_F(GLibMainLoopTest, unregister_does_not_close_fds)
+{
+    mt::Pipe p1, p2;
+    char const data_to_write{'b'};
+    char data_read{0};
+
+    ml.register_fd_handler(
+        {p1.read_fd()},
+        this,
+        [this](int)
+        {
+            FAIL() << "unregistered handler called";
+            ml.stop();
+        });
+
+    ml.unregister_fd_handler(this);
+
+    ml.register_fd_handler(
+        {p1.read_fd()},
+        this,
+        [this,&data_read](int fd)
+        {
+            EXPECT_EQ(1, read(fd, &data_read, 1));
+            ml.stop();
+        });
+
+    EXPECT_EQ(1, write(p1.write_fd(), &data_to_write, 1));
+
+    ml.run();
+
+    EXPECT_EQ(data_to_write, data_read);
+}
+
+struct GLibMainLoopAlarmTest : ::testing::Test
+{
+    std::shared_ptr<AdvanceableClock> clock = std::make_shared<AdvanceableClock>();
+    mir::GLibMainLoop ml{clock};
+    std::chrono::milliseconds delay{50};
+};
+
+TEST_F(GLibMainLoopAlarmTest, main_loop_runs_until_stop_called)
+{
+    auto mainloop_started = std::make_shared<mt::Signal>();
+
+    auto fire_on_mainloop_start = ml.notify_in(std::chrono::milliseconds{0},
+                                               [mainloop_started]()
+    {
+        mainloop_started->raise();
+    });
+
+    UnblockMainLoop unblocker(ml);
+
+    ASSERT_TRUE(mainloop_started->wait_for(std::chrono::milliseconds{100}));
+
+    auto timer_fired = std::make_shared<mt::Signal>();
+    auto alarm = ml.notify_in(std::chrono::milliseconds{10}, [timer_fired]
+    {
+        timer_fired->raise();
+    });
+
+    //std::cerr << "Advance by 10 " << std::endl;
+    clock->advance_by(std::chrono::milliseconds{10}, ml);
+    //std::cerr << "after Advance by 10 " << std::endl;
+    EXPECT_TRUE(timer_fired->wait_for(std::chrono::milliseconds{500}));
+    //std::cerr << "after waitfor by500 " << std::endl;
+
+    ml.stop();
+    //std::cerr << "after stop " << std::endl;
+    // Main loop should be stopped now
+
+    timer_fired = std::make_shared<mt::Signal>();
+    auto should_not_fire =  ml.notify_in(std::chrono::milliseconds{0},
+                                         [timer_fired]()
+    {
+        timer_fired->raise();
+    });
+
+    EXPECT_FALSE(timer_fired->wait_for(std::chrono::milliseconds{10}));
+}
+
+TEST_F(GLibMainLoopAlarmTest, alarm_starts_in_pending_state)
+{
+    auto alarm = ml.notify_in(delay, [this]() {});
+
+    UnblockMainLoop unblocker(ml);
+
+    EXPECT_EQ(mir::time::Alarm::pending, alarm->state());
+}
+
+TEST_F(GLibMainLoopAlarmTest, alarm_fires_with_correct_delay)
+{
+    UnblockMainLoop unblocker(ml);
+
+    auto alarm = ml.notify_in(delay, [](){});
+
+    clock->advance_by(delay - std::chrono::milliseconds{1}, ml);
+    EXPECT_EQ(mir::time::Alarm::pending, alarm->state());
+
+    clock->advance_by(delay, ml);
+    EXPECT_EQ(mir::time::Alarm::triggered, alarm->state());
+}
+
+TEST_F(GLibMainLoopAlarmTest, multiple_alarms_fire)
+{
+    using namespace testing;
+
+    int const alarm_count{10};
+    Counter call_count;
+    std::array<std::unique_ptr<mir::time::Alarm>, alarm_count> alarms;
+
+    for (auto& alarm : alarms)
+        alarm = ml.notify_in(delay, [&call_count](){++call_count;});
+
+    UnblockMainLoop unblocker(ml);
+    clock->advance_by(delay, ml);
+
+    call_count.wait_for(delay, alarm_count);
+    EXPECT_THAT(call_count, Eq(alarm_count));
+
+    for (auto const& alarm : alarms)
+        EXPECT_EQ(mir::time::Alarm::triggered, alarm->state());
+}
+
+TEST_F(GLibMainLoopAlarmTest, alarm_changes_to_triggered_state)
+{
+    auto alarm_fired = std::make_shared<mt::Signal>();
+    auto alarm = ml.notify_in(std::chrono::milliseconds{5}, [alarm_fired]()
+    {
+        alarm_fired->raise();
+    });
+
+    UnblockMainLoop unblocker(ml);
+
+    clock->advance_by(delay, ml);
+    ASSERT_TRUE(alarm_fired->wait_for(std::chrono::milliseconds{100}));
+
+    EXPECT_EQ(mir::time::Alarm::triggered, alarm->state());
+}
+
+TEST_F(GLibMainLoopAlarmTest, cancelled_alarm_doesnt_fire)
+{
+    UnblockMainLoop unblocker(ml);
+    auto alarm = ml.notify_in(std::chrono::milliseconds{100},
+                              [](){ FAIL() << "Alarm handler of canceld alarm called";});
+
+    EXPECT_TRUE(alarm->cancel());
+
+    EXPECT_EQ(mir::time::Alarm::cancelled, alarm->state());
+
+    clock->advance_by(std::chrono::milliseconds{100}, ml);
+
+    EXPECT_EQ(mir::time::Alarm::cancelled, alarm->state());
+}
+
+TEST_F(GLibMainLoopAlarmTest, destroyed_alarm_doesnt_fire)
+{
+    auto alarm = ml.notify_in(std::chrono::milliseconds{200},
+                              [](){ FAIL() << "Alarm handler of destroyed alarm called"; });
+
+    UnblockMainLoop unblocker(ml);
+
+    alarm.reset(nullptr);
+    clock->advance_by(std::chrono::milliseconds{200}, ml);
+}
+
+TEST_F(GLibMainLoopAlarmTest, rescheduled_alarm_fires_again)
+{
+    std::atomic<int> call_count{0};
+
+    auto alarm = ml.notify_in(std::chrono::milliseconds{0}, [&call_count]()
+    {
+        if (call_count++ > 1)
+            FAIL() << "Alarm called too many times";
+    });
+
+    UnblockMainLoop unblocker(ml);
+
+    clock->advance_by(std::chrono::milliseconds{0}, ml);
+    ASSERT_EQ(mir::time::Alarm::triggered, alarm->state());
+
+    alarm->reschedule_in(std::chrono::milliseconds{100});
+    EXPECT_EQ(mir::time::Alarm::pending, alarm->state());
+
+    clock->advance_by(std::chrono::milliseconds{100}, ml);
+    EXPECT_EQ(mir::time::Alarm::triggered, alarm->state());
+}
+
+TEST_F(GLibMainLoopAlarmTest, rescheduled_alarm_cancels_previous_scheduling)
+{
+    std::atomic<int> call_count{0};
+
+    auto alarm = ml.notify_in(std::chrono::milliseconds{100}, [&call_count]()
+    {
+        call_count++;
+    });
+
+    UnblockMainLoop unblocker(ml);
+    clock->advance_by(std::chrono::milliseconds{90}, ml);
+
+    EXPECT_EQ(mir::time::Alarm::pending, alarm->state());
+    EXPECT_EQ(0, call_count);
+    EXPECT_TRUE(alarm->reschedule_in(std::chrono::milliseconds{100}));
+    EXPECT_EQ(mir::time::Alarm::pending, alarm->state());
+
+    clock->advance_by(std::chrono::milliseconds{110}, ml);
+
+    EXPECT_EQ(mir::time::Alarm::triggered, alarm->state());
+    EXPECT_EQ(1, call_count);
+}
+
+TEST_F(GLibMainLoopAlarmTest, alarm_callback_cannot_deadlock)
+{   // Regression test for deadlock bug LP: #1339700
+    std::timed_mutex m;
+    std::atomic_bool failed(false);
+    int i = 0;
+    int const loops = 5;
+
+    auto alarm = ml.notify_in(std::chrono::milliseconds{0}, [&]()
+    {
+        // From this angle, ensure we can lock m (alarm should be unlocked)
+        failed = !m.try_lock_for(std::chrono::seconds{5});
+        ASSERT_FALSE(failed);
+        ++i;
+        m.unlock();
+    });
+
+    std::thread t([&]()
+        {
+            m.lock();
+            while (i < loops && !failed)
+            {
+                // From this angle, ensure we can lock alarm while holding m
+                (void)alarm->state();
+                m.unlock();
+                std::this_thread::yield();
+                m.lock();
+            }
+            m.unlock();
+        });
+
+    UnblockMainLoop unblocker(ml);
+    for (int j = 0; j < loops; ++j)
+    {
+        clock->advance_by(std::chrono::milliseconds{11}, ml);
+        alarm->reschedule_in(std::chrono::milliseconds{10});
+    }
+
+    t.join();
+}
+
+TEST_F(GLibMainLoopAlarmTest, alarm_fires_at_correct_time_point)
+{
+    mir::time::Timestamp real_soon = clock->sample() + std::chrono::milliseconds{120};
+
+    auto alarm = ml.notify_at(real_soon, []{});
+
+    UnblockMainLoop unblocker(ml);
+
+    clock->advance_by(std::chrono::milliseconds{119}, ml);
+    EXPECT_EQ(mir::time::Alarm::pending, alarm->state());
+
+    clock->advance_by(std::chrono::milliseconds{1}, ml);
+    EXPECT_EQ(mir::time::Alarm::triggered, alarm->state());
+}
+
+
+// More targeted regression test for LP: #1381925
+TEST_F(GLibMainLoopTest, stress_emits_alarm_notification_with_zero_timeout)
+{
+    using namespace ::testing;
+
+    UnblockMainLoop unblocker{ml};
+
+    for (int i = 0; i < 1000; ++i)
+    {
+        mt::Signal notification_called;
+
+        auto alarm = ml.notify_in(
+                std::chrono::milliseconds{0},
+                [&] { notification_called.raise(); });
+
+        EXPECT_TRUE(notification_called.wait_for(std::chrono::seconds{5}));
+    }
+}
+
+TEST_F(GLibMainLoopTest, dispatches_action)
+{
+    using namespace testing;
+
+    int num_actions{0};
+    int const owner{0};
+
+    ml.enqueue(
+        &owner,
+        [&]
+        {
+            ++num_actions;
+            ml.stop();
+        });
+
+    ml.run();
+
+    EXPECT_THAT(num_actions, Eq(1));
+}
+
+TEST_F(GLibMainLoopTest, dispatches_multiple_actions_in_order)
+{
+    using namespace testing;
+
+    int const num_actions{5};
+    std::vector<int> actions;
+    int const owner{0};
+
+    for (int i = 0; i < num_actions; ++i)
+    {
+        ml.enqueue(
+            &owner,
+            [&,i]
+            {
+                actions.push_back(i);
+                if (i == num_actions - 1)
+                    ml.stop();
+            });
+    }
+
+    ml.run();
+
+    ASSERT_THAT(actions.size(), Eq(num_actions));
+    for (int i = 0; i < num_actions; ++i)
+        EXPECT_THAT(actions[i], Eq(i)) << "i = " << i;
+}
+
+TEST_F(GLibMainLoopTest, does_not_dispatch_paused_actions)
+{
+    using namespace testing;
+
+    std::vector<int> actions;
+    int const owner1{0};
+    int const owner2{0};
+
+    ml.enqueue(
+        &owner1,
+
+        [&]
+        {
+            int const id = 0;
+            actions.push_back(id);
+        });
+
+    ml.enqueue(
+        &owner2,
+        [&]
+        {
+            int const id = 1;
+            actions.push_back(id);
+        });
+
+    ml.enqueue(
+        &owner1,
+        [&]
+        {
+            int const id = 2;
+            actions.push_back(id);
+        });
+
+    ml.enqueue(
+        &owner2,
+        [&]
+        {
+            int const id = 3;
+            actions.push_back(id);
+            ml.stop();
+        });
+
+    ml.pause_processing_for(&owner1);
+
+    ml.run();
+
+    ASSERT_THAT(actions.size(), Eq(2));
+    EXPECT_THAT(actions[0], Eq(1));
+    EXPECT_THAT(actions[1], Eq(3));
+}
+
+TEST_F(GLibMainLoopTest, dispatches_actions_resumed_from_within_another_action)
+{
+    using namespace testing;
+
+    std::vector<int> actions;
+    void const* const owner1_ptr{&actions};
+    int const owner2{0};
+
+    ml.enqueue(
+        owner1_ptr,
+        [&]
+        {
+            int const id = 0;
+            actions.push_back(id);
+            ml.stop();
+        });
+
+    ml.enqueue(
+        &owner2,
+        [&]
+        {
+            int const id = 1;
+            actions.push_back(id);
+            ml.resume_processing_for(owner1_ptr);
+        });
+
+    ml.pause_processing_for(owner1_ptr);
+
+    ml.run();
+
+    ASSERT_THAT(actions.size(), Eq(2));
+    EXPECT_THAT(actions[0], Eq(1));
+    EXPECT_THAT(actions[1], Eq(0));
+}
+
+TEST_F(GLibMainLoopTest, handles_enqueue_from_within_action)
+{
+    using namespace testing;
+
+    std::vector<int> actions;
+    int const num_actions{10};
+    void const* const owner{&num_actions};
+
+    ml.enqueue(
+        owner,
+        [&]
+        {
+            int const id = 0;
+            actions.push_back(id);
+            
+            for (int i = 1; i < num_actions; ++i)
+            {
+                ml.enqueue(
+                    owner,
+                    [&,i]
+                    {
+                        actions.push_back(i);
+                        if (i == num_actions - 1)
+                            ml.stop();
+                    });
+            }
+        });
+
+    ml.run();
+
+    ASSERT_THAT(actions.size(), Eq(num_actions));
+    for (int i = 0; i < num_actions; ++i)
+        EXPECT_THAT(actions[i], Eq(i)) << "i = " << i;
+}
+
+TEST_F(GLibMainLoopTest, dispatches_actions_resumed_externally)
+{
+    using namespace testing;
+
+    std::vector<int> actions;
+    void const* const owner1_ptr{&actions};
+    int const owner2{0};
+
+    ml.enqueue(
+        owner1_ptr,
+        [&]
+        {
+            int const id = 0;
+            actions.push_back(id);
+            ml.stop();
+        });
+
+    ml.enqueue(
+        &owner2,
+        [&]
+        {
+            int const id = 1;
+            actions.push_back(id);
+        });
+
+    ml.pause_processing_for(owner1_ptr);
+
+    std::thread t{
+        [&] 
+        { 
+            std::this_thread::sleep_for(std::chrono::milliseconds{10});
+            ml.resume_processing_for(owner1_ptr);
+        }};
+
+    ml.run();
+
+    t.join();
+
+    ASSERT_THAT(actions.size(), Eq(2));
+    EXPECT_THAT(actions[0], Eq(1));
+    EXPECT_THAT(actions[1], Eq(0));
+}

=== added file 'tests/unit-tests/test_thread_safe_list.cpp'
--- tests/unit-tests/test_thread_safe_list.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/test_thread_safe_list.cpp	2014-10-31 11:59:50 +0000
@@ -0,0 +1,159 @@
+/*
+ * 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 <[e-mail]>
+ */
+
+#include "mir/thread_safe_list.h"
+#include "mir_test/wait_condition.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+namespace
+{
+
+struct Dummy {};
+using Element = std::shared_ptr<Dummy>;
+using SharedPtrList = mir::ThreadSafeList<Element>;
+
+struct ThreadSafeListTest : testing::Test
+{
+    SharedPtrList list;
+
+    Element const element1 = std::make_shared<Dummy>();
+    Element const element2 = std::make_shared<Dummy>();
+};
+
+}
+
+TEST_F(ThreadSafeListTest, can_remove_element_while_iterating_same_element)
+{
+    using namespace testing;
+
+    list.add(element1);
+
+    list.for_each(
+        [&] (Element const& element)
+        {
+            list.remove(element);
+        });
+
+    int elements_seen = 0;
+
+    list.for_each(
+        [&] (Element const&)
+        {
+            ++elements_seen;
+        });
+
+    EXPECT_THAT(elements_seen, Eq(0));
+}
+
+TEST_F(ThreadSafeListTest, can_remove_unused_element_while_iterating_different_element)
+{
+    using namespace testing;
+
+    list.add(element1);
+    list.add(element2);
+
+    int elements_seen = 0;
+
+    list.for_each(
+        [&] (Element const&)
+        {
+            list.remove(element2);
+            ++elements_seen;
+        });
+
+    EXPECT_THAT(elements_seen, Eq(1));
+}
+
+TEST_F(ThreadSafeListTest,
+       can_remove_unused_element_while_different_element_is_used_in_different_thread)
+{
+    using namespace testing;
+
+    list.add(element1);
+    list.add(element2);
+
+    mir::test::WaitCondition first_element_in_use;
+    mir::test::WaitCondition second_element_removed;
+
+    int elements_seen = 0;
+
+    std::thread t{
+        [&]
+        {
+            list.for_each(
+                [&] (Element const&)
+                {
+                    first_element_in_use.wake_up_everyone();
+                    second_element_removed.wait_for_at_most_seconds(3);
+                    EXPECT_TRUE(second_element_removed.woken());
+                    ++elements_seen;
+                });
+        }};
+
+    first_element_in_use.wait_for_at_most_seconds(3);
+    list.remove(element2);
+    second_element_removed.wake_up_everyone();
+
+    t.join();
+
+    EXPECT_THAT(elements_seen, Eq(1));
+}
+
+TEST_F(ThreadSafeListTest, removes_all_matching_elements)
+{
+    using namespace testing;
+
+    std::vector<Element> elements_seen;
+
+    list.add(element1);
+    list.add(element2);
+    list.add(element1);
+
+    list.remove_all(element1);
+
+    list.for_each(
+        [&] (Element const& element)
+        {
+            elements_seen.push_back(element);
+        });
+
+    EXPECT_THAT(elements_seen, ElementsAre(element2));
+}
+
+TEST_F(ThreadSafeListTest, clears_all_elements)
+{
+    using namespace testing;
+
+    int elements_seen = 0;
+
+    list.add(element1);
+    list.add(element2);
+    list.add(element1);
+
+    list.clear();
+
+    list.for_each(
+        [&] (Element const&)
+        {
+            ++elements_seen;
+        });
+
+    EXPECT_THAT(elements_seen, Eq(0));
+}