Merge lp:~alan-griffiths/miral/mru-list-of-active-windows into lp:miral

[Alan Griffiths]

Track the active window in an MRU list and use that to select the new active Window when the old one closes

Introduces the first unit test case to MirAL, and starts the rework of selecting the active Window.

The main behavioural difference here is that BasicWindowManager tracks the active window in an MRU list and uses that to select the new active Window when the old one closes.

There's still too much logic in the "policy" that needs moving to the BasicWindowManager, but that can come in a follow-up.

[lp:~alan-griffiths/miral/mru-list-of-active-windows]

174. By Daniel d'Andrada on 2016-05-20

Fix build failure

175. By Alan Griffiths on 2016-05-22

merge lp:~alan-griffiths/miral/mru-list-of-active-windows

176. By Alan Griffiths on 2016-05-22

std::rbegin()/rend() not available on vivid

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-04-25 11:59:43 +0000
+++ CMakeLists.txt	2016-05-22 15:01:57 +0000
@@ -14,7 +14,7 @@
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread -g -Werror -Wall -pedantic -Wextra -fPIC -fuse-ld=gold")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -g -std=c++14 -Werror -Wall -fno-strict-aliasing -pedantic -Wnon-virtual-dtor -Wextra -fPIC -fuse-ld=gold")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -g -std=c++14 -Werror -Wall -pedantic -Wnon-virtual-dtor -Wextra -fPIC -fuse-ld=gold")
 set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,defs -fuse-ld=gold")
 set (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,-z,defs -fuse-ld=gold")
 set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-z,defs -fuse-ld=gold")
@@ -34,3 +34,9 @@
 add_subdirectory(miral)
 add_subdirectory(miral-shell)
 add_subdirectory(miral-kiosk)
+
+# building the tests is disabled by default because the mirtest-dev package is broken on xenial (lp:1583536)
+option(MIRAL_ENABLE_TESTS "Build tests" OFF)
+if (MIRAL_ENABLE_TESTS)
+add_subdirectory(test)
+endif()

=== modified file 'building_and_using_miral.md'
--- building_and_using_miral.md	2016-04-13 13:46:35 +0000
+++ building_and_using_miral.md	2016-05-22 15:01:57 +0000
@@ -5,12 +5,15 @@
 earlier Ubuntu versions or other distributions.
 
 You’ll need a few development and utility packages installed, along with the
-Mir development packages (if you’re working on a phone or tablet use 
-mir-graphics-drivers-android in place of mir-graphics-drivers-desktop):
+Mir development packages:
 
     $ sudo apt-get install cmake g++ make bzr python-pil
-    $ sudo apt-get install mir-graphics-drivers-desktop libmirserver-dev libmirclient-dev
-    
+    $ sudo apt-get install libmirserver-dev libmirclient-dev mirtest-dev
+    $ sudo apt-get install mir-graphics-drivers-desktop
+
+(If you’re working on a phone or tablet use mir-graphics-drivers-android in
+place of mir-graphics-drivers-desktop.)
+
 With these installed you can checkout and build miral:
 
     $ bzr branch lp:miral

=== added file 'cmake/FindGtestGmock.cmake'
--- cmake/FindGtestGmock.cmake	1970-01-01 00:00:00 +0000
+++ cmake/FindGtestGmock.cmake	2016-05-22 15:01:57 +0000
@@ -0,0 +1,71 @@
+include(ExternalProject)
+include(FindPackageHandleStandardArgs)
+
+#gtest
+set(GTEST_INSTALL_DIR /usr/src/gmock/gtest/include)
+find_path(GTEST_INCLUDE_DIR gtest/gtest.h
+            HINTS ${GTEST_INSTALL_DIR})
+
+#gmock
+find_path(GMOCK_INSTALL_DIR gmock/CMakeLists.txt
+          HINTS /usr/src)
+if(${GMOCK_INSTALL_DIR} STREQUAL "GMOCK_INSTALL_DIR-NOTFOUND")
+    message(FATAL_ERROR "google-mock package not found")
+endif()
+
+set(GMOCK_INSTALL_DIR ${GMOCK_INSTALL_DIR}/gmock)
+find_path(GMOCK_INCLUDE_DIR gmock/gmock.h)
+
+set(GMOCK_PREFIX gmock)
+set(GMOCK_BINARY_DIR ${CMAKE_BINARY_DIR}/${GMOCK_PREFIX}/libs)
+set(GTEST_BINARY_DIR ${GMOCK_BINARY_DIR}/gtest)
+
+set(GTEST_CXX_FLAGS "-fPIC -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64")
+if (cmake_build_type_lower MATCHES "threadsanitizer")
+  set(GTEST_CXX_FLAGS "${GTEST_CXX_FLAGS} -fsanitize=thread")
+elseif (cmake_build_type_lower MATCHES "ubsanitizer")
+  set(GTEST_CXX_FLAGS "${GTEST_CXX_FLAGS} -fsanitize=undefined")
+endif()
+
+set(GTEST_CMAKE_ARGS "-DCMAKE_CXX_FLAGS=${GTEST_CXX_FLAGS}")
+list(APPEND GTEST_CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER})
+list(APPEND GTEST_CMAKE_ARGS -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER})
+if (cmake_build_type_lower MATCHES "threadsanitizer")
+  #Skip compiler check, since if GCC is the compiler, we need to link against -ltsan
+  #explicitly; specifying additional linker flags doesn't seem possible for external projects
+  list(APPEND GTEST_CMAKE_ARGS -DCMAKE_CXX_COMPILER_WORKS=1)
+endif()
+if (${CMAKE_CROSSCOMPILING})
+  if(DEFINED MIR_NDK_PATH)
+    list(APPEND GTEST_CMAKE_ARGS -DCMAKE_TOOLCHAIN_FILE=${CMAKE_MODULE_PATH}/LinuxCrossCompile.cmake)
+  else()
+    list(APPEND GTEST_CMAKE_ARGS -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER})
+    list(APPEND GTEST_CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER})
+  endif()
+endif()
+
+ExternalProject_Add(
+    GMock
+    #where to build in source tree
+    PREFIX ${GMOCK_PREFIX}
+    #where the source is external to the project
+    SOURCE_DIR ${GMOCK_INSTALL_DIR}
+    #forward the compilers to the subproject so cross-arch builds work
+    CMAKE_ARGS ${GTEST_CMAKE_ARGS}
+    BINARY_DIR ${GMOCK_BINARY_DIR}
+
+    #we don't need to install, so skip
+    INSTALL_COMMAND ""
+)
+
+set(GMOCK_LIBRARY ${GMOCK_BINARY_DIR}/libgmock.a)
+set(GMOCK_MAIN_LIBRARY ${GMOCK_BINARY_DIR}/libgmock_main.a)
+set(GMOCK_BOTH_LIBRARIES ${GMOCK_LIBRARY} ${GMOCK_MAIN_LIBRARY})
+set(GTEST_LIBRARY ${GTEST_BINARY_DIR}/libgtest.a)
+set(GTEST_MAIN_LIBRARY ${GTEST_BINARY_DIR}/libgtest_main.a)
+set(GTEST_BOTH_LIBRARIES ${GTEST_LIBRARY} ${GTEST_MAIN_LIBRARY})
+set(GTEST_ALL_LIBRARIES ${GTEST_BOTH_LIBRARIES} ${GMOCK_BOTH_LIBRARIES})
+
+find_package_handle_standard_args(GTest  DEFAULT_MSG
+                                    GMOCK_INCLUDE_DIR
+                                    GTEST_INCLUDE_DIR)

=== added file 'include/miral/mru_window_list.h'
--- include/miral/mru_window_list.h	1970-01-01 00:00:00 +0000
+++ include/miral/mru_window_list.h	2016-05-22 15:01:57 +0000
@@ -0,0 +1,46 @@
+/*
+ * 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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIRAL_MRU_WINDOW_LIST_H
+#define MIRAL_MRU_WINDOW_LIST_H
+
+#include <miral/window.h>
+
+#include <functional>
+#include <vector>
+
+namespace miral
+{
+class MRUWindowList
+{
+public:
+
+    void push(Window const& window);
+    void erase(Window const& window);
+    auto top() const -> Window;
+
+    using Enumerator = std::function<bool(Window& window)>;
+
+    void enumerate(Enumerator const& enumerator) const;
+
+private:
+    std::vector<Window> surfaces;
+};
+}
+
+#endif //MIRAL_MRU_WINDOW_LIST_H

=== modified file 'miral-kiosk/kiosk_window_manager.cpp'
--- miral-kiosk/kiosk_window_manager.cpp	2016-05-18 11:49:26 +0000
+++ miral-kiosk/kiosk_window_manager.cpp	2016-05-22 15:01:57 +0000
@@ -161,7 +161,6 @@
             scan_code == KEY_TAB)
     {
         tools->focus_next_application();
-        select_active_window(tools->focused_window());
 
         return true;
     }

=== modified file 'miral-shell/canonical_window_manager.cpp'
--- miral-shell/canonical_window_manager.cpp	2016-05-20 21:08:57 +0000
+++ miral-shell/canonical_window_manager.cpp	2016-05-22 15:01:57 +0000
@@ -20,9 +20,9 @@
 #include "titlebar/canonical_window_management_policy_data.h"
 #include "spinner/splash.h"
 
-#include "miral/application_info.h"
-#include "miral/window_info.h"
-#include "miral/window_manager_tools.h"
+#include <miral/application_info.h>
+#include <miral/window_info.h>
+#include <miral/window_manager_tools.h>
 
 #include <linux/input.h>
 #include <algorithm>
@@ -565,8 +565,6 @@
             scan_code == KEY_TAB)
     {
         tools->focus_next_application();
-        if (auto const window = tools->focused_window())
-            select_active_window(window);
 
         return true;
     }
@@ -717,69 +715,70 @@
 
 auto CanonicalWindowManagerPolicy::select_active_window(Window const& hint) -> miral::Window
 {
-    if (hint == active_window_)
-        return hint ;
+    auto const prev_window = active_window();
+
+    if (hint == prev_window)
+        return hint;
 
     if (!hint)
     {
-        if (auto const active_surface = active_window_)
+        if (prev_window)
         {
-            auto& info = tools->info_for(active_surface);
-            if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(info.userdata()))
-            {
-                titlebar->paint_titlebar(0x3F);
-            }
-        }
-
-        if (active_window_)
             tools->set_focus_to({});
+            handle_focus_lost(tools->info_for(prev_window));
+        }
 
-        active_window_.reset();
         return hint;
     }
 
-    auto const& info_for = tools->info_for(hint);
+    auto const& info_for_hint = tools->info_for(hint);
 
-    if (info_for.can_be_active())
+    if (info_for_hint.can_be_active())
     {
-        if (auto const active_surface = active_window_)
-        {
-            auto& info = tools->info_for(active_surface);
-            if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(info.userdata()))
-            {
-                titlebar->paint_titlebar(0x3F);
-            }
-        }
-        auto& info = tools->info_for(hint);
-        if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(info.userdata()))
-        {
-            titlebar->paint_titlebar(0xFF);
-        }
-        tools->set_focus_to(info_for.window());
-        tools->raise_tree(info_for.window());
-        active_window_ = info_for.window();
-
-        // Frig to force the spinner to the top
-        if (auto const spinner_session = spinner.session())
-        {
-            auto const& spinner_info = tools->info_for(spinner_session);
-
-            if (spinner_info.windows().size() > 0)
-                tools->raise_tree(spinner_info.windows()[0]);
-        }
-
+        tools->set_focus_to(hint);
+        tools->raise_tree(hint);
+
+        if (prev_window)
+            handle_focus_lost(tools->info_for(prev_window));
+
+        handle_focus_gained(info_for_hint);
         return hint;
     }
     else
     {
         // Cannot have input focus - try the parent
-        if (auto const parent = info_for.parent())
+        if (auto const parent = info_for_hint.parent())
             return select_active_window(parent);
     }
 
     return {};
 }
 
+void CanonicalWindowManagerPolicy::handle_focus_gained(WindowInfo const& info)
+{
+    if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(info.userdata()))
+        titlebar->paint_titlebar(0xFF);
+
+    active_window_ = info.window();
+
+    // Frig to force the spinner to the top
+    if (auto const spinner_session = spinner.session())
+    {
+        auto const& spinner_info = tools->info_for(spinner_session);
+
+        if (spinner_info.windows().size() > 0)
+            tools->raise_tree(spinner_info.windows()[0]);
+    }
+}
+
+void CanonicalWindowManagerPolicy::handle_focus_lost(WindowInfo const& info)
+{
+    if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(info.userdata()))
+        titlebar->paint_titlebar(0x3F);
+
+    active_window_.reset();
+}
+
 auto CanonicalWindowManagerPolicy::active_window() const
 -> Window
 {

=== modified file 'miral-shell/canonical_window_manager.h'
--- miral-shell/canonical_window_manager.h	2016-05-06 14:38:26 +0000
+++ miral-shell/canonical_window_manager.h	2016-05-22 15:01:57 +0000
@@ -21,8 +21,8 @@
 
 #include "spinner/splash.h"
 
-#include "miral/window.h"
-#include "miral/window_management_policy.h"
+#include <miral/window.h>
+#include <miral/window_management_policy.h>
 
 #include <mir/geometry/displacement.h>
 
@@ -90,6 +90,8 @@
     void toggle(MirSurfaceState state);
 
     auto active_window() const -> miral::Window;
+    void handle_focus_lost(miral::WindowInfo const& info);
+    void handle_focus_gained(miral::WindowInfo const& info);
 
     bool resize(miral::Window const& window, Point cursor, Point old_cursor);
     bool drag(miral::Window window, Point to, Point from, Rectangle bounds);

=== modified file 'miral-shell/spinner/CMakeLists.txt'
--- miral-shell/spinner/CMakeLists.txt	2016-04-15 17:16:53 +0000
+++ miral-shell/spinner/CMakeLists.txt	2016-05-22 15:01:57 +0000
@@ -47,8 +47,6 @@
   ${CMAKE_CURRENT_BINARY_DIR}
 )
 
-link_directories(${MIRCLIENT_LIBRARY_DIRS})
-
 add_library(miral-spinner STATIC
   eglapp.cpp
   eglapp.h

=== modified file 'miral-shell/tiling_window_manager.cpp'
--- miral-shell/tiling_window_manager.cpp	2016-05-18 11:51:27 +0000
+++ miral-shell/tiling_window_manager.cpp	2016-05-22 15:01:57 +0000
@@ -304,7 +304,6 @@
             scan_code == KEY_TAB)
     {
         tools->focus_next_application();
-        select_active_window(tools->focused_window());
 
         return true;
     }

=== modified file 'miral/CMakeLists.txt'
--- miral/CMakeLists.txt	2016-05-18 11:49:26 +0000
+++ miral/CMakeLists.txt	2016-05-22 15:01:57 +0000
@@ -13,6 +13,7 @@
     window_management_options.cpp     ${CMAKE_SOURCE_DIR}/include/miral/window_management_options.h
     window_specification.cpp          ${CMAKE_SOURCE_DIR}/include/miral/window_specification.h
     startup_internal_client.cpp       ${CMAKE_SOURCE_DIR}/include/miral/startup_internal_client.h
+    mru_window_list.cpp               ${CMAKE_SOURCE_DIR}/include/miral/mru_window_list.h
     basic_window_manager.cpp          basic_window_manager.h
     ${CMAKE_SOURCE_DIR}/include/miral/window_management_policy.h
     ${CMAKE_SOURCE_DIR}/include/miral/window_manager_tools.h

=== modified file 'miral/basic_window_manager.cpp'
--- miral/basic_window_manager.cpp	2016-05-18 11:49:26 +0000
+++ miral/basic_window_manager.cpp	2016-05-22 15:01:57 +0000
@@ -127,16 +127,17 @@
     std::weak_ptr<scene::Surface> const& surface)
 {
     std::lock_guard<decltype(mutex)> lock(mutex);
-    bool const is_active_window{surface.lock() == focus_controller->focused_surface()};
-
     auto& info = info_for(surface);
 
+    bool const is_active_window{mru_active_windows.top() == info.window()};
+
     if (auto const parent = info.parent())
         info_for(parent).remove_child(info.window());
 
     auto& session_info = info_for(session);
 
     session_info.remove_window(info.window());
+    mru_active_windows.erase(info.window());
 
     policy->handle_delete_window(info);
 
@@ -156,16 +157,39 @@
                 return;
         }
 
-        // Ought to find top window of same application, but we don't
-        // have the API (yet), so find any suitable top-level-window
-        for (auto const& tlw : session_info.windows())
-        {
-            if (policy->select_active_window(tlw))
-                return;
-        }
-
+        // TODO the policy for choosing a window is mixed with implementing the choice.
+        // I.e. select_active_window() calls set_focus_to() which updates mru_active_windows
+        // during the iteration. There must be a better way to sequence the logic.
+        // Until then we copy the list.
+        auto const copy_mru_windows = mru_active_windows;
+
+        // Try to activate to recently active window of same application
+        {
+            Window new_focus;
+
+            copy_mru_windows.enumerate([&](Window& window)
+                {
+                    return window.application() != session ||
+                        !(new_focus = policy->select_active_window(window));
+                });
+
+            if (new_focus) return;
+        }
+
+        // Try to activate to recently active window of any application
+        {
+            Window new_focus;
+
+            copy_mru_windows.enumerate([&](Window& window)
+            {
+                return !(new_focus = policy->select_active_window(window));
+            });
+
+            if (new_focus) return;
+        }
+
+        // Fallback to cycling through applications
         focus_next_application();
-        policy->select_active_window(focused_window());
     }
 }
 
@@ -307,10 +331,12 @@
 void miral::BasicWindowManager::focus_next_application()
 {
     focus_controller->focus_next_session();
+    policy->select_active_window(focused_window());
 }
 
 void miral::BasicWindowManager::set_focus_to(Window const& window)
 {
+    if (window) mru_active_windows.push(window);
     focus_controller->set_focus_to(window.application(), window);
 }
 

=== modified file 'miral/basic_window_manager.h'
--- miral/basic_window_manager.h	2016-05-06 16:34:33 +0000
+++ miral/basic_window_manager.h	2016-05-22 15:01:57 +0000
@@ -24,6 +24,7 @@
 #include "miral/window_info.h"
 #include "miral/application.h"
 #include "miral/application_info.h"
+#include "miral/mru_window_list.h"
 
 #include "mir/geometry/rectangles.h"
 #include "mir/shell/abstract_shell.h"
@@ -147,6 +148,7 @@
     mir::geometry::Rectangles displays;
     mir::geometry::Point cursor;
     uint64_t last_input_event_timestamp{0};
+    miral::MRUWindowList mru_active_windows;
 
     // Cache the builder functor for the convenience of policies - this should become unnecessary
     std::function<Window(std::shared_ptr<mir::scene::Session> const& session, WindowSpecification const& params)> surface_builder;

=== added file 'miral/mru_window_list.cpp'
--- miral/mru_window_list.cpp	1970-01-01 00:00:00 +0000
+++ miral/mru_window_list.cpp	2016-05-22 15:01:57 +0000
@@ -0,0 +1,44 @@
+/*
+ * 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: Alan Griffiths <[e-mail]>
+ */
+
+#include <miral/mru_window_list.h>
+
+#include <algorithm>
+
+void miral::MRUWindowList::push(Window const& window)
+{
+    surfaces.erase(remove(begin(surfaces), end(surfaces), window), end(surfaces));
+    surfaces.push_back(window);
+}
+
+void miral::MRUWindowList::erase(Window const& window)
+{
+    surfaces.erase(remove(begin(surfaces), end(surfaces), window), end(surfaces));
+}
+
+auto miral::MRUWindowList::top() const -> Window
+{
+    return (!surfaces.empty()) ? surfaces.back() : Window{};
+}
+
+void miral::MRUWindowList::enumerate(Enumerator const& enumerator) const
+{
+    for (auto i = surfaces.rbegin(); i != surfaces.rend(); ++i)
+        if (!enumerator(const_cast<Window&>(*i)))
+            break;
+}

=== added directory 'test'
=== added file 'test/CMakeLists.txt'
--- test/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ test/CMakeLists.txt	2016-05-22 15:01:57 +0000
@@ -0,0 +1,19 @@
+find_package(GtestGmock REQUIRED)
+pkg_check_modules(MIRTEST REQUIRED mirtest)
+include_directories(
+        ${MIRTEST_INCLUDE_DIRS}
+        ${GMOCK_INCLUDE_DIR}
+        ${GTEST_INCLUDE_DIR}
+)
+
+add_executable(miral-test
+    mru_window_list.cpp
+)
+
+target_link_libraries(miral-test
+    ${MIRTEST_LDFLAGS}
+    ${GTEST_BOTH_LIBRARIES}
+    ${GMOCK_LIBRARY}
+    ${GMOCK_MAIN_LIBRARY}
+    miral
+)

=== added file 'test/mru_window_list.cpp'
--- test/mru_window_list.cpp	1970-01-01 00:00:00 +0000
+++ test/mru_window_list.cpp	2016-05-22 15:01:57 +0000
@@ -0,0 +1,139 @@
+/*
+ * 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: Alan Griffiths <[e-mail]>
+ */
+
+#include <miral/mru_window_list.h>
+
+#include <mir/test/doubles/stub_surface.h>
+#include <mir/test/doubles/stub_session.h>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+using StubSurface = mir::test::doubles::StubSurface;
+using namespace testing;
+
+namespace
+{
+struct StubSession : mir::test::doubles::StubSession
+{
+    StubSession(int number_of_surfaces)
+    {
+        for (auto i = 0; i != number_of_surfaces; ++i)
+            surfaces.push_back(std::make_shared<mir::test::doubles::StubSurface>());
+    }
+
+    std::shared_ptr<mir::scene::Surface> surface(mir::frontend::SurfaceId surface) const override
+    {
+        return surfaces.at(surface.as_value());
+    }
+
+    std::vector<std::shared_ptr<StubSurface>> surfaces;
+};
+
+MATCHER(IsNullWindow, std::string("is not null"))
+{
+    return !arg;
+}
+}
+
+struct MRUWindowList : testing::Test
+{
+    miral::MRUWindowList mru_list;
+
+    std::shared_ptr<StubSession> const stub_session{std::make_shared<StubSession>(3)};
+    miral::Application app{stub_session};
+    miral::Window window_a{app, mir::frontend::SurfaceId{0}};
+    miral::Window window_b{app, mir::frontend::SurfaceId{1}};
+    miral::Window window_c{app, mir::frontend::SurfaceId{2}};
+};
+
+TEST_F(MRUWindowList, when_created_is_empty)
+{
+    EXPECT_THAT(mru_list.top(), IsNullWindow());
+}
+
+TEST_F(MRUWindowList, given_empty_list_when_a_window_pushed_that_window_is_top)
+{
+    mru_list.push(window_a);
+    EXPECT_THAT(mru_list.top(), Eq(window_a));
+}
+
+TEST_F(MRUWindowList, given_non_empty_list_when_a_window_pushed_that_window_is_top)
+{
+    mru_list.push(window_a);
+    mru_list.push(window_b);
+    mru_list.push(window_c);
+    EXPECT_THAT(mru_list.top(), Eq(window_c));
+}
+
+TEST_F(MRUWindowList, given_non_empty_list_when_top_window_is_erased_that_window_is_no_longer_on_top)
+{
+    mru_list.push(window_a);
+    mru_list.push(window_b);
+    mru_list.push(window_c);
+    mru_list.erase(window_c);
+    EXPECT_THAT(mru_list.top(), Ne(window_c));
+}
+
+TEST_F(MRUWindowList, a_window_pushed_twice_is_not_enumerated_twice)
+{
+    mru_list.push(window_a);
+    mru_list.push(window_b);
+    mru_list.push(window_a);
+
+    int count{0};
+
+    mru_list.enumerate([&](miral::Window& window)
+        { if (window == window_a) ++count; return true; });
+
+    EXPECT_THAT(count, Eq(1));
+}
+
+TEST_F(MRUWindowList, after_multiple_pushes_windows_are_enumerated_in_mru_order)
+{
+    mru_list.push(window_a);
+    mru_list.push(window_b);
+    mru_list.push(window_c);
+    mru_list.push(window_a);
+    mru_list.push(window_b);
+    mru_list.push(window_a);
+
+    mru_list.push(window_c);
+    mru_list.push(window_b);
+    mru_list.push(window_a);
+
+    std::vector<miral::Window> as_enumerated;
+
+    mru_list.enumerate([&](miral::Window& window)
+       { as_enumerated.push_back(window); return true; });
+
+    EXPECT_THAT(as_enumerated, ElementsAre(window_a, window_b, window_c));
+}
+
+TEST_F(MRUWindowList, when_enumerator_returns_false_enumeration_is_short_circuited)
+{
+    mru_list.push(window_a);
+    mru_list.push(window_b);
+    mru_list.push(window_c);
+
+    int count{0};
+
+    mru_list.enumerate([&](miral::Window&) { ++count; return false; });
+
+    EXPECT_THAT(count, Eq(1));
+}