Merge lp:~alan-griffiths/miral/add-indirection-to-stabilize-WindowManagerTools-ABI into lp:miral

[Alan Griffiths]

Rework WindowManagerTools to a form better suited to ABI stability.

Rework WindowManagerTools to a form better suited to ABI stability.

Not accessing a vtable from client code means that we don't have to keep it stable.

Also, BasicWindowManager no longer inherits from a public MirAL interface, which is one step towards being able to backport it into Mir proper.

[Gerry Boland (gerboland)]

-)
+ window_manager_tools_implementation.h)
indent a bit wonky?

Rest looks fine. I really hope your IDE helped with it :)

[lp:~alan-griffiths/miral/add-indirection-to-stabilize-WindowManagerTools-ABI]

243. By Alan Griffiths on 2016-07-28

merge lp:miral

244. By Alan Griffiths on 2016-07-28

Tidy CMakeLists

245. By Alan Griffiths on 2016-07-28

Fix miral-qt

[Gerry Boland (gerboland)]

Looks good, thanks!

review: Approve

=== modified file 'include/miral/canonical_window_manager.h'
--- include/miral/canonical_window_manager.h	2016-07-22 16:46:38 +0000
+++ include/miral/canonical_window_manager.h	2016-07-28 08:41:50 +0000
@@ -20,6 +20,7 @@
 #define MIRAL_CANONICAL_WINDOW_MANAGER_H_
 
 #include <miral/window_management_policy.h>
+#include <miral/window_manager_tools.h>
 
 namespace miral
 {
@@ -27,7 +28,7 @@
 {
 public:
 
-    explicit CanonicalWindowManagerPolicy(WindowManagerTools* const tools);
+    explicit CanonicalWindowManagerPolicy(WindowManagerTools const& tools);
 
     auto place_new_surface(
         ApplicationInfo const& app_info,
@@ -41,7 +42,7 @@
     void advise_focus_gained(WindowInfo const& info) override;
 
 protected:
-    miral::WindowManagerTools* const tools;
+    WindowManagerTools tools;
 };
 }
 

=== modified file 'include/miral/set_window_managment_policy.h'
--- include/miral/set_window_managment_policy.h	2016-06-06 18:44:28 +0000
+++ include/miral/set_window_managment_policy.h	2016-07-28 08:41:50 +0000
@@ -34,19 +34,19 @@
 class SetWindowManagmentPolicy
 {
 public:
-    SetWindowManagmentPolicy(std::function<std::unique_ptr<WindowManagementPolicy>(WindowManagerTools* tools)> const& builder);
+    SetWindowManagmentPolicy(std::function<std::unique_ptr<WindowManagementPolicy>(WindowManagerTools const& tools)> const& builder);
     ~SetWindowManagmentPolicy();
 
     void operator()(mir::Server& server) const;
 
 private:
-    std::function<std::unique_ptr<WindowManagementPolicy>(WindowManagerTools* tools)> builder;
+    std::function<std::unique_ptr<WindowManagementPolicy>(WindowManagerTools const& tools)> builder;
 };
 
 template<typename Policy, typename ...Args>
 auto set_window_managment_policy(Args& ... args) -> SetWindowManagmentPolicy
 {
-    return SetWindowManagmentPolicy{[&args...](WindowManagerTools* tools) -> std::unique_ptr<WindowManagementPolicy>
+    return SetWindowManagmentPolicy{[&args...](WindowManagerTools const& tools) -> std::unique_ptr<WindowManagementPolicy>
         { return std::make_unique<Policy>(tools, args...); }};
 }
 }

=== modified file 'include/miral/window_management_options.h'
--- include/miral/window_management_options.h	2016-05-17 13:56:40 +0000
+++ include/miral/window_management_options.h	2016-07-28 08:41:50 +0000
@@ -35,7 +35,7 @@
 class WindowManagementPolicy;
 
 using WindowManagementPolicyBuilder =
-    std::function<std::unique_ptr<miral::WindowManagementPolicy>(miral::WindowManagerTools* tools)>;
+    std::function<std::unique_ptr<miral::WindowManagementPolicy>(WindowManagerTools const& tools)>;
 
 struct WindowManagerOption
 {
@@ -46,7 +46,7 @@
 template<typename Policy, typename ...Args>
 inline auto add_window_manager_policy(std::string const& name, Args&... args) -> WindowManagerOption
 {
-    return {name, [&args...](miral::WindowManagerTools* tools) -> std::unique_ptr<miral::WindowManagementPolicy>
+    return {name, [&args...](WindowManagerTools const& tools) -> std::unique_ptr<miral::WindowManagementPolicy>
         { return std::make_unique<Policy>(tools, args...); }};
 }
 

=== modified file 'include/miral/window_manager_tools.h'
--- include/miral/window_manager_tools.h	2016-06-29 13:17:33 +0000
+++ include/miral/window_manager_tools.h	2016-07-28 08:41:50 +0000
@@ -32,7 +32,6 @@
 namespace scene { class Surface; }
 }
 
-
 namespace miral
 {
 class Window;
@@ -40,34 +39,40 @@
 struct ApplicationInfo;
 class WindowSpecification;
 
-/// The interface through which the policy instructs the controller.
+class WindowManagerToolsImplementation;
+
 class WindowManagerTools
 {
 public:
+    explicit WindowManagerTools(WindowManagerToolsImplementation* tools);
+    WindowManagerTools(WindowManagerTools const&);
+    WindowManagerTools& operator=(WindowManagerTools const&);
+    ~WindowManagerTools();
+
 /** @name Update Model
  *  These functions assume that the BasicWindowManager data structures can be accessed freely.
  *  I.e. they should only be used by a thread that has called the WindowManagementPolicy methods
  *  (where any necessary locks are held) or via a invoke_under_lock() callback.
  *  @{ */
-    virtual auto count_applications() const -> unsigned int = 0;
-    virtual void for_each_application(std::function<void(ApplicationInfo& info)> const& functor) = 0;
-    virtual auto find_application(std::function<bool(ApplicationInfo const& info)> const& predicate)
-    -> Application = 0;
-    virtual auto info_for(std::weak_ptr<mir::scene::Session> const& session) const -> ApplicationInfo& = 0;
-    virtual auto info_for(std::weak_ptr<mir::scene::Surface> const& surface) const -> WindowInfo& = 0;
-    virtual auto info_for(Window const& window) const -> WindowInfo& = 0;
-    virtual void kill_active_application(int sig) = 0;
-    virtual auto active_window() const -> Window = 0;
-    virtual auto select_active_window(Window const& hint) -> Window = 0;
-    virtual void drag_active_window(mir::geometry::Displacement movement) = 0;
-    virtual void focus_next_application() = 0;
-    virtual void focus_next_within_application() = 0;
-    virtual auto window_at(mir::geometry::Point cursor) const -> Window = 0;
-    virtual auto active_display() -> mir::geometry::Rectangle const = 0;
-    virtual void raise_tree(Window const& root) = 0;
-    virtual void modify_window(WindowInfo& window_info, WindowSpecification const& modifications) = 0;
-    virtual void place_and_size(WindowInfo& window_info, Point const& new_pos, Size const& new_size) = 0;
-    virtual void set_state(WindowInfo& window_info, MirSurfaceState value) = 0;
+    auto count_applications() const -> unsigned int;
+    void for_each_application(std::function<void(ApplicationInfo& info)> const& functor);
+    auto find_application(std::function<bool(ApplicationInfo const& info)> const& predicate)
+    -> Application;
+    auto info_for(std::weak_ptr<mir::scene::Session> const& session) const -> ApplicationInfo&;
+    auto info_for(std::weak_ptr<mir::scene::Surface> const& surface) const -> WindowInfo&;
+    auto info_for(Window const& window) const -> WindowInfo&;
+    void kill_active_application(int sig);
+    auto active_window() const -> Window;
+    auto select_active_window(Window const& hint) -> Window;
+    void drag_active_window(mir::geometry::Displacement movement);
+    void focus_next_application();
+    void focus_next_within_application();
+    auto window_at(mir::geometry::Point cursor) const -> Window;
+    auto active_display() -> mir::geometry::Rectangle const;
+    void raise_tree(Window const& root);
+    void modify_window(WindowInfo& window_info, WindowSpecification const& modifications);
+    void place_and_size(WindowInfo& window_info, Point const& new_pos, Size const& new_size);
+    void set_state(WindowInfo& window_info, MirSurfaceState value);
 /** @} */
 
 /** @name Multi-thread support
@@ -76,13 +81,11 @@
  *  This should NOT be used by a thread that has called the WindowManagementPolicy methods (and
  *  already holds the lock).
  *  @{ */
-    virtual void invoke_under_lock(std::function<void()> const& callback) = 0;
+    void invoke_under_lock(std::function<void()> const& callback);
 /** @} */
 
-    virtual ~WindowManagerTools() = default;
-    WindowManagerTools() = default;
-    WindowManagerTools(WindowManagerTools const&) = delete;
-    WindowManagerTools& operator=(WindowManagerTools const&) = delete;
+private:
+    WindowManagerToolsImplementation* tools;
 };
 }
 

=== modified file 'miral-kiosk/kiosk_window_manager.cpp'
--- miral-kiosk/kiosk_window_manager.cpp	2016-07-25 15:42:29 +0000
+++ miral-kiosk/kiosk_window_manager.cpp	2016-07-28 08:41:50 +0000
@@ -27,7 +27,7 @@
 namespace ms = mir::scene;
 using namespace miral;
 
-KioskWindowManagerPolicy::KioskWindowManagerPolicy(WindowManagerTools* const tools, SwSplash const& splash) :
+KioskWindowManagerPolicy::KioskWindowManagerPolicy(WindowManagerTools const& tools, SwSplash const& splash) :
     CanonicalWindowManagerPolicy{tools},
     splash{splash}
 {
@@ -43,7 +43,7 @@
             modifiers == mir_input_event_modifier_alt &&
             scan_code == KEY_TAB)
     {
-        tools->focus_next_application();
+        tools.focus_next_application();
 
         return true;
     }
@@ -51,7 +51,7 @@
             modifiers == mir_input_event_modifier_alt &&
             scan_code == KEY_GRAVE)
     {
-        tools->focus_next_within_application();
+        tools.focus_next_within_application();
 
         return true;
     }
@@ -60,7 +60,7 @@
         switch (modifiers & modifier_mask)
         {
         case mir_input_event_modifier_alt:
-            if (auto const window = tools->active_window())
+            if (auto const window = tools.active_window())
                 window.request_client_surface_close();
 
             return true;
@@ -88,7 +88,7 @@
 
     Point const cursor{total_x/count, total_y/count};
 
-    tools->select_active_window(tools->window_at(cursor));
+    tools.select_active_window(tools.window_at(cursor));
 
     return false;
 }
@@ -103,7 +103,7 @@
 
     if (action == mir_pointer_action_button_down)
     {
-        tools->select_active_window(tools->window_at(cursor));
+        tools.select_active_window(tools.window_at(cursor));
     }
 
     return false;
@@ -115,9 +115,9 @@
 
     if (auto session = splash.session().lock())
     {
-        auto const& app_info = tools->info_for(session);
+        auto const& app_info = tools.info_for(session);
 
         for (auto const& s : app_info.windows())
-            tools->raise_tree(s);
+            tools.raise_tree(s);
     }
 }

=== modified file 'miral-kiosk/kiosk_window_manager.h'
--- miral-kiosk/kiosk_window_manager.h	2016-07-25 15:42:29 +0000
+++ miral-kiosk/kiosk_window_manager.h	2016-07-28 08:41:50 +0000
@@ -28,7 +28,7 @@
 class KioskWindowManagerPolicy : public miral::CanonicalWindowManagerPolicy
 {
 public:
-    KioskWindowManagerPolicy(miral::WindowManagerTools* const tools, SwSplash const&);
+    KioskWindowManagerPolicy(miral::WindowManagerTools const& tools, SwSplash const&);
 
     void advise_focus_gained(miral::WindowInfo const& info) override;
 

=== modified file 'miral-qt/src/platforms/mirserver/windowmanagementpolicy.cpp'
--- miral-qt/src/platforms/mirserver/windowmanagementpolicy.cpp	2016-07-27 12:04:05 +0000
+++ miral-qt/src/platforms/mirserver/windowmanagementpolicy.cpp	2016-07-28 08:41:50 +0000
@@ -24,7 +24,7 @@
 #include "mir/scene/surface.h"
 #include <QDebug>
 
-WindowManagementPolicy::WindowManagementPolicy(miral::WindowManagerTools * const tools,
+WindowManagementPolicy::WindowManagementPolicy(const miral::WindowManagerTools &tools,
                                                qtmir::WindowModel &windowModel,
                                                const QSharedPointer<ScreensModel> screensModel)
     : CanonicalWindowManagerPolicy(tools)
@@ -47,7 +47,7 @@
 void WindowManagementPolicy::handle_window_ready(miral::WindowInfo &windowInfo)
 {
     qDebug("Window ready");
-    m_tools->select_active_window(windowInfo.window());
+    m_tools.select_active_window(windowInfo.window());
 }
 
 void WindowManagementPolicy::handle_modify_window(
@@ -55,13 +55,13 @@
     const miral::WindowSpecification &modifications)
 {
     qDebug("Window Modified!");
-    m_tools->modify_window(windowInfo, modifications);
+    m_tools.modify_window(windowInfo, modifications);
 }
 
 void WindowManagementPolicy::handle_raise_window(miral::WindowInfo &windowInfo)
 {
     qDebug("Window Raise");
-    m_tools->select_active_window(windowInfo.window());
+    m_tools.select_active_window(windowInfo.window());
 }
 
 /* Handle input events - here just inject them into Qt event loop for later processing */
@@ -155,9 +155,9 @@
 void WindowManagementPolicy::deliver_keyboard_event(const MirKeyboardEvent *event,
                                                     const std::shared_ptr<mir::scene::Surface> &surface)
 {
-    m_tools->invoke_under_lock([&surface, this]() {
-        auto windowInfo = m_tools->info_for(surface);
-        m_tools->select_active_window(windowInfo.window());
+    m_tools.invoke_under_lock([&surface, this]() {
+        auto windowInfo = m_tools.info_for(surface);
+        m_tools.select_active_window(windowInfo.window());
     });
     auto e = reinterpret_cast<MirEvent const*>(event); // naughty
     surface->consume(e);
@@ -166,9 +166,9 @@
 void WindowManagementPolicy::deliver_touch_event(const MirTouchEvent *event,
                                                  const std::shared_ptr<mir::scene::Surface> &surface)
 {
-    m_tools->invoke_under_lock([&surface, this]() {
-        auto windowInfo = m_tools->info_for(surface);
-        m_tools->select_active_window(windowInfo.window());
+    m_tools.invoke_under_lock([&surface, this]() {
+        auto windowInfo = m_tools.info_for(surface);
+        m_tools.select_active_window(windowInfo.window());
     });
     auto e = reinterpret_cast<MirEvent const*>(event); // naughty
     surface->consume(e);
@@ -177,9 +177,9 @@
 void WindowManagementPolicy::deliver_pointer_event(const MirPointerEvent *event,
                                                    const std::shared_ptr<mir::scene::Surface> &surface)
 {
-    m_tools->invoke_under_lock([&surface, this]() {
-        auto windowInfo = m_tools->info_for(surface);
-        m_tools->select_active_window(windowInfo.window());
+    m_tools.invoke_under_lock([&surface, this]() {
+        auto windowInfo = m_tools.info_for(surface);
+        m_tools.select_active_window(windowInfo.window());
     });
     auto e = reinterpret_cast<MirEvent const*>(event); // naughty
     surface->consume(e);
@@ -188,15 +188,15 @@
 /* Methods to allow Shell to request changes to the window stack */
 void WindowManagementPolicy::focus(const miral::Window window)
 {
-    m_tools->select_active_window(window);
+    m_tools.select_active_window(window);
 }
 
 void WindowManagementPolicy::resize(const miral::Window window, const Size &size)
 {
-    m_tools->place_and_size(m_tools->info_for(window), window.top_left(), size);
+    m_tools.place_and_size(m_tools.info_for(window), window.top_left(), size);
 }
 
 void WindowManagementPolicy::move(const miral::Window window, const Point &top_left)
 {
-    m_tools->place_and_size(m_tools->info_for(window), top_left, window.size() );
+    m_tools.place_and_size(m_tools.info_for(window), top_left, window.size() );
 }

=== modified file 'miral-qt/src/platforms/mirserver/windowmanagementpolicy.h'
--- miral-qt/src/platforms/mirserver/windowmanagementpolicy.h	2016-07-27 12:04:05 +0000
+++ miral-qt/src/platforms/mirserver/windowmanagementpolicy.h	2016-07-28 08:41:50 +0000
@@ -33,7 +33,7 @@
 class WindowManagementPolicy : public QObject, public miral::CanonicalWindowManagerPolicy
 {
 public:
-    WindowManagementPolicy(miral::WindowManagerTools * const tools,
+    WindowManagementPolicy(const miral::WindowManagerTools &tools,
                            qtmir::WindowModel &windowModel,
                            const QSharedPointer<ScreensModel> screensModel);
 
@@ -81,7 +81,7 @@
 Q_SIGNALS:
 
 private:
-    miral::WindowManagerTools * const m_tools;
+    miral::WindowManagerTools m_tools;
     qtmir::WindowModel &m_windowModel;
     const QScopedPointer<QtEventFeeder> m_eventFeeder;
 };

=== modified file 'miral-shell/tiling_window_manager.cpp'
--- miral-shell/tiling_window_manager.cpp	2016-07-25 10:18:21 +0000
+++ miral-shell/tiling_window_manager.cpp	2016-07-28 08:41:50 +0000
@@ -49,8 +49,8 @@
 
 // Demonstrate implementing a simple tiling algorithm
 
-TilingWindowManagerPolicy::TilingWindowManagerPolicy(WindowManagerTools* const tools, SpinnerSplash const& spinner,
-                                                     miral::InternalClientLauncher const& launcher) :
+TilingWindowManagerPolicy::TilingWindowManagerPolicy(WindowManagerTools const& tools, SpinnerSplash const& spinner,
+                                                     InternalClientLauncher const& launcher) :
     tools{tools},
     spinner{spinner},
     launcher{launcher}
@@ -59,8 +59,8 @@
 
 void TilingWindowManagerPolicy::click(Point cursor)
 {
-    auto const window = tools->window_at(cursor);
-    tools->select_active_window(window);
+    auto const window = tools.window_at(cursor);
+    tools.select_active_window(window);
 }
 
 void TilingWindowManagerPolicy::advise_displays_updated(Rectangles const& displays)
@@ -75,9 +75,9 @@
     {
         if (application == application_under(old_cursor))
         {
-            if (auto const window = tools->select_active_window(tools->window_at(old_cursor)))
+            if (auto const window = tools.select_active_window(tools.window_at(old_cursor)))
             {
-                resize(window, cursor, old_cursor, tile_for(tools->info_for(application)));
+                resize(window, cursor, old_cursor, tile_for(tools.info_for(application)));
             }
         }
     }
@@ -104,7 +104,7 @@
             else
             {
                 auto top_level_windows = count_if(begin(app_info.windows()), end(app_info.windows()), [this]
-                    (Window const& window){ return !tools->info_for(window).parent(); });
+                    (Window const& window){ return !tools.info_for(window).parent(); });
 
                 parameters.top_left() = tile.top_left + top_level_windows*Displacement{15, 15};
             }
@@ -124,7 +124,7 @@
 
 void TilingWindowManagerPolicy::handle_window_ready(WindowInfo& window_info)
 {
-    tools->select_active_window(window_info.window());
+    tools.select_active_window(window_info.window());
 }
 
 namespace
@@ -162,7 +162,7 @@
         window_info.window().set_state(state);
     }
 
-    tools->modify_window(window_info, mods);
+    tools.modify_window(window_info, mods);
 }
 
 auto TilingWindowManagerPolicy::transform_set_state(WindowInfo& window_info, MirSurfaceState value)
@@ -215,7 +215,7 @@
         return window_info.state();
     }
 
-    auto const& tile = tile_for(tools->info_for(window_info.window().application()));
+    auto const& tile = tile_for(tools.info_for(window_info.window().application()));
 
     switch (value)
     {
@@ -253,9 +253,9 @@
     {
         window_info.window().show();
     }
-    else if (window_info.window() == tools->active_window())
+    else if (window_info.window() == tools.active_window())
     {
-        tools->select_active_window(window_info.parent());
+        tools.select_active_window(window_info.parent());
     }
 
     return value;
@@ -267,9 +267,9 @@
     {
         if (application == application_under(old_cursor))
         {
-            if (auto const window = tools->select_active_window(tools->window_at(old_cursor)))
+            if (auto const window = tools.select_active_window(tools.window_at(old_cursor)))
             {
-                drag(tools->info_for(window), cursor, old_cursor, tile_for(tools->info_for(application)));
+                drag(tools.info_for(window), cursor, old_cursor, tile_for(tools.info_for(application)));
             }
         }
     }
@@ -277,7 +277,7 @@
 
 void TilingWindowManagerPolicy::handle_raise_window(WindowInfo& window_info)
 {
-    tools-> select_active_window(window_info.window());
+    tools. select_active_window(window_info.window());
 }
 
 bool TilingWindowManagerPolicy::handle_keyboard_event(MirKeyboardEvent const* event)
@@ -318,11 +318,11 @@
         switch (modifiers & modifier_mask)
         {
         case mir_input_event_modifier_alt|mir_input_event_modifier_shift:
-            tools->kill_active_application(SIGTERM);
+            tools.kill_active_application(SIGTERM);
             return true;
 
         case mir_input_event_modifier_alt:
-            if (auto const window = tools->active_window())
+            if (auto const window = tools.active_window())
                 window.request_client_surface_close();
 
             return true;
@@ -335,7 +335,7 @@
             modifiers == mir_input_event_modifier_alt &&
             scan_code == KEY_TAB)
     {
-        tools->focus_next_application();
+        tools.focus_next_application();
 
         return true;
     }
@@ -343,7 +343,7 @@
             modifiers == mir_input_event_modifier_alt &&
             scan_code == KEY_GRAVE)
     {
-        tools->focus_next_within_application();
+        tools.focus_next_within_application();
 
         return true;
     }
@@ -400,8 +400,8 @@
     }
     else
     {
-        if (auto const& window = tools->window_at(cursor))
-            tools->select_active_window(window);
+        if (auto const& window = tools.window_at(cursor))
+            tools.select_active_window(window);
     }
 
     old_cursor = cursor;
@@ -443,9 +443,9 @@
 
 void TilingWindowManagerPolicy::toggle(MirSurfaceState state)
 {
-    if (auto window = tools->active_window())
+    if (auto window = tools.active_window())
     {
-        auto& window_info = tools->info_for(window);
+        auto& window_info = tools.info_for(window);
 
         if (window_info.state() == state)
             state = mir_surface_state_restored;
@@ -458,13 +458,13 @@
 auto TilingWindowManagerPolicy::application_under(Point position)
 -> Application
 {
-    return tools->find_application([&, this](ApplicationInfo const& info)
+    return tools.find_application([&, this](ApplicationInfo const& info)
         { return spinner.session() != info.application() && tile_for(info).contains(position);});
 }
 
 void TilingWindowManagerPolicy::update_tiles(Rectangles const& displays)
 {
-    auto applications = tools->count_applications();
+    auto applications = tools.count_applications();
 
     if (spinner.session()) --applications;
 
@@ -477,7 +477,7 @@
 
     auto index = 0;
 
-    tools->for_each_application([&](ApplicationInfo& info)
+    tools.for_each_application([&](ApplicationInfo& info)
         {
             if (spinner.session() == info.application())
                 return;
@@ -504,7 +504,7 @@
     {
         if (window)
         {
-            auto& window_info = tools->info_for(window);
+            auto& window_info = tools.info_for(window);
 
             if (!window_info.parent())
             {
@@ -519,7 +519,7 @@
                 auto width  = std::min(new_tile.size.width.as_int()  - offset.dx.as_int(), scaled_width.as_int());
                 auto height = std::min(new_tile.size.height.as_int() - offset.dy.as_int(), scaled_height.as_int());
 
-                tools->place_and_size(window_info, new_pos, {width, height});
+                tools.place_and_size(window_info, new_pos, {width, height});
             }
         }
     }
@@ -608,14 +608,14 @@
 
 void TilingWindowManagerPolicy::advise_focus_gained(WindowInfo const& info)
 {
-    tools->raise_tree(info.window());
+    tools.raise_tree(info.window());
 
     if (auto const spinner_session = spinner.session())
     {
-        auto const& spinner_info = tools->info_for(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.raise_tree(spinner_info.windows()[0]);
     }
 }
 

=== modified file 'miral-shell/tiling_window_manager.h'
--- miral-shell/tiling_window_manager.h	2016-07-11 13:45:44 +0000
+++ miral-shell/tiling_window_manager.h	2016-07-28 08:41:50 +0000
@@ -23,6 +23,7 @@
 
 #include <miral/application.h>
 #include <miral/window_management_policy.h>
+#include <miral/window_manager_tools.h>
 
 #include <mir/geometry/displacement.h>
 #include <miral/internal_client.h>
@@ -42,7 +43,7 @@
 class TilingWindowManagerPolicy : public miral::WindowManagementPolicy
 {
 public:
-    explicit TilingWindowManagerPolicy(miral::WindowManagerTools* const tools, SpinnerSplash const& spinner,
+    explicit TilingWindowManagerPolicy(miral::WindowManagerTools const& tools, SpinnerSplash const& spinner,
                                        miral::InternalClientLauncher const& launcher);
 
     auto place_new_surface(
@@ -89,7 +90,7 @@
     static void resize(miral::Window window, Point cursor, Point old_cursor, Rectangle bounds);
     static void constrained_move(miral::Window window, Displacement& movement, Rectangle const& bounds);
 
-    miral::WindowManagerTools* const tools;
+    miral::WindowManagerTools tools;
     SpinnerSplash spinner;
     miral::InternalClientLauncher const launcher;
     Point old_cursor{};

=== modified file 'miral-shell/titlebar_provider.cpp'
--- miral-shell/titlebar_provider.cpp	2016-07-14 16:19:53 +0000
+++ miral-shell/titlebar_provider.cpp	2016-07-28 08:41:50 +0000
@@ -58,7 +58,7 @@
 using namespace miral::toolkit;
 using namespace mir::geometry;
 
-TitlebarProvider::TitlebarProvider(miral::WindowManagerTools* const tools) : tools{tools}
+TitlebarProvider::TitlebarProvider(miral::WindowManagerTools const& tools) : tools{tools}
 {
 
 }
@@ -179,7 +179,7 @@
         {
             auto window = window_info.window();
             element.second.window = window;
-            auto& parent_info = tools->info_for(scene_surface);
+            auto& parent_info = tools.info_for(scene_surface);
             parent_info.add_child(window);
             window_info.parent(parent_info.window());
             window.move_to(parent_info.window().top_left() - Displacement{0, title_bar_height});

=== modified file 'miral-shell/titlebar_provider.h'
--- miral-shell/titlebar_provider.h	2016-07-11 15:11:07 +0000
+++ miral-shell/titlebar_provider.h	2016-07-28 08:41:50 +0000
@@ -57,7 +57,7 @@
 class TitlebarProvider : Worker
 {
 public:
-    TitlebarProvider(miral::WindowManagerTools* const tools);
+    TitlebarProvider(miral::WindowManagerTools const& tools);
     ~TitlebarProvider();
 
     void operator()(miral::toolkit::Connection connection);
@@ -86,7 +86,7 @@
 
     using SurfaceMap = std::map<std::weak_ptr<mir::scene::Surface>, Data, std::owner_less<std::weak_ptr<mir::scene::Surface>>>;
 
-    miral::WindowManagerTools* const tools;
+    miral::WindowManagerTools tools;
     std::mutex mutable mutex;
     miral::toolkit::Connection connection;
     std::weak_ptr<mir::scene::Session> weak_session;

=== modified file 'miral-shell/titlebar_window_manager.cpp'
--- miral-shell/titlebar_window_manager.cpp	2016-07-25 15:42:29 +0000
+++ miral-shell/titlebar_window_manager.cpp	2016-07-28 08:41:50 +0000
@@ -35,7 +35,7 @@
 }
 
 TitlebarWindowManagerPolicy::TitlebarWindowManagerPolicy(
-    WindowManagerTools* const tools,
+    WindowManagerTools const& tools,
     SpinnerSplash const& spinner,
     miral::InternalClientLauncher const& launcher) :
     CanonicalWindowManagerPolicy(tools),
@@ -60,18 +60,18 @@
 
     if (action == mir_pointer_action_button_down)
     {
-        if (auto const window = tools->window_at(cursor))
-            tools->select_active_window(window);
+        if (auto const window = tools.window_at(cursor))
+            tools.select_active_window(window);
     }
     else if (action == mir_pointer_action_motion &&
              modifiers == mir_input_event_modifier_alt)
     {
         if (mir_pointer_event_button_state(event, mir_pointer_button_primary))
         {
-            if (auto const target = tools->window_at(old_cursor))
+            if (auto const target = tools.window_at(old_cursor))
             {
-                tools->select_active_window(target);
-                tools->drag_active_window(cursor - old_cursor);
+                tools.select_active_window(target);
+                tools.drag_active_window(cursor - old_cursor);
             }
             consumes_event = true;
         }
@@ -79,8 +79,8 @@
         if (mir_pointer_event_button_state(event, mir_pointer_button_tertiary))
         {
             if (!resizing)
-                tools->select_active_window(tools->window_at(old_cursor));
-            is_resize_event = resize(tools->active_window(), cursor, old_cursor);
+                tools.select_active_window(tools.window_at(old_cursor));
+            is_resize_event = resize(tools.active_window(), cursor, old_cursor);
             consumes_event = true;
         }
     }
@@ -89,13 +89,13 @@
     {
         if (mir_pointer_event_button_state(event, mir_pointer_button_primary))
         {
-            if (auto const possible_titlebar = tools->window_at(old_cursor))
+            if (auto const possible_titlebar = tools.window_at(old_cursor))
             {
                 if (possible_titlebar.application() == titlebar_provider->session())
                 {
-                    auto const& info = tools->info_for(possible_titlebar);
-                    tools->select_active_window(info.parent());
-                    tools->drag_active_window(cursor - old_cursor);
+                    auto const& info = tools.info_for(possible_titlebar);
+                    tools.select_active_window(info.parent());
+                    tools.drag_active_window(cursor - old_cursor);
                     consumes_event = true;
                 }
             }
@@ -176,7 +176,7 @@
     {
         if (count == 3)
         {
-            if (auto window = tools->active_window())
+            if (auto window = tools.active_window())
             {
                 auto const old_size = window.size();
                 auto const delta_width = DeltaX{touch_pinch_width - old_touch_pinch_width};
@@ -189,15 +189,15 @@
                 auto const new_height = std::max(old_size.height + delta_height, Height{5});
                 auto const new_pos = window.top_left() + delta_x + delta_y;
 
-                tools->place_and_size(tools->info_for(window), new_pos, {new_width, new_height});
+                tools.place_and_size(tools.info_for(window), new_pos, {new_width, new_height});
             }
             consumes_event = true;
         }
     }
     else
     {
-        if (auto const& window = tools->window_at(cursor))
-            tools->select_active_window(window);
+        if (auto const& window = tools.window_at(cursor))
+            tools.select_active_window(window);
     }
 
     old_cursor = cursor;
@@ -217,7 +217,7 @@
     if (application == titlebar_provider->session())
     {
         titlebar_provider->advise_new_titlebar(window_info);
-        tools->raise_tree(window_info.parent());
+        tools.raise_tree(window_info.parent());
         return;
     }
 
@@ -243,10 +243,10 @@
     // Frig to force the spinner to the top
     if (auto const spinner_session = spinner.session())
     {
-        auto const& spinner_info = tools->info_for(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.raise_tree(spinner_info.windows()[0]);
     }
 }
 
@@ -302,11 +302,11 @@
         switch (modifiers & modifier_mask)
         {
         case mir_input_event_modifier_alt|mir_input_event_modifier_shift:
-            tools->kill_active_application(SIGTERM);
+            tools.kill_active_application(SIGTERM);
             return true;
 
         case mir_input_event_modifier_alt:
-            if (auto const window = tools->active_window())
+            if (auto const window = tools.active_window())
                 window.request_client_surface_close();
 
             return true;
@@ -319,7 +319,7 @@
              modifiers == mir_input_event_modifier_alt &&
              scan_code == KEY_TAB)
     {
-        tools->focus_next_application();
+        tools.focus_next_application();
 
         return true;
     }
@@ -327,7 +327,7 @@
              modifiers == mir_input_event_modifier_alt &&
              scan_code == KEY_GRAVE)
     {
-        tools->focus_next_within_application();
+        tools.focus_next_within_application();
 
         return true;
     }
@@ -345,14 +345,14 @@
 
 void TitlebarWindowManagerPolicy::toggle(MirSurfaceState state)
 {
-    if (auto const window = tools->active_window())
+    if (auto const window = tools.active_window())
     {
-        auto& info = tools->info_for(window);
+        auto& info = tools.info_for(window);
 
         if (info.state() == state)
             state = mir_surface_state_restored;
 
-        tools->set_state(info, state);
+        tools.set_state(info, state);
     }
 }
 
@@ -361,7 +361,7 @@
     if (!window)
         return false;
 
-    auto& window_info = tools->info_for(window);
+    auto& window_info = tools.info_for(window);
 
     auto const top_left = window.top_left();
     Rectangle const old_pos{top_left, window.size()};
@@ -415,7 +415,7 @@
     Point new_pos = top_left + left_resize*delta.dx + top_resize*delta.dy;
 
     window_info.constrain_resize(new_pos, new_size);
-    tools->place_and_size(window_info, new_pos, new_size);
+    tools.place_and_size(window_info, new_pos, new_size);
 
     return true;
 }

=== modified file 'miral-shell/titlebar_window_manager.h'
--- miral-shell/titlebar_window_manager.h	2016-07-25 15:42:29 +0000
+++ miral-shell/titlebar_window_manager.h	2016-07-28 08:41:50 +0000
@@ -32,7 +32,7 @@
 class TitlebarWindowManagerPolicy : public miral::CanonicalWindowManagerPolicy
 {
 public:
-    TitlebarWindowManagerPolicy(miral::WindowManagerTools* const tools, SpinnerSplash const& spinner, miral::InternalClientLauncher const& launcher);
+    TitlebarWindowManagerPolicy(miral::WindowManagerTools const& tools, SpinnerSplash const& spinner, miral::InternalClientLauncher const& launcher);
     ~TitlebarWindowManagerPolicy();
 
     virtual miral::WindowSpecification place_new_surface(

=== modified file 'miral/CMakeLists.txt'
--- miral/CMakeLists.txt	2016-07-22 11:14:14 +0000
+++ miral/CMakeLists.txt	2016-07-28 08:41:50 +0000
@@ -19,9 +19,9 @@
     internal_client.cpp                 ${CMAKE_SOURCE_DIR}/include/miral/internal_client.h
     mru_window_list.cpp                 mru_window_list.h
     set_window_managment_policy.cpp     ${CMAKE_SOURCE_DIR}/include/miral/set_window_managment_policy.h
-    basic_window_manager.cpp            basic_window_manager.h
+    basic_window_manager.cpp            basic_window_manager.h window_manager_tools_implementation.h
     window_management_policy.cpp        ${CMAKE_SOURCE_DIR}/include/miral/window_management_policy.h
-                                        ${CMAKE_SOURCE_DIR}/include/miral/window_manager_tools.h
+    window_manager_tools.cpp            ${CMAKE_SOURCE_DIR}/include/miral/window_manager_tools.h
                                         ${CMAKE_SOURCE_DIR}/include/miral/stream_specification.h
                                         ${CMAKE_SOURCE_DIR}/include/miral/toolkit/surface_spec.h
                                         ${CMAKE_SOURCE_DIR}/include/miral/toolkit/connection.h

=== modified file 'miral/basic_window_manager.cpp'
--- miral/basic_window_manager.cpp	2016-07-26 11:22:49 +0000
+++ miral/basic_window_manager.cpp	2016-07-28 08:41:50 +0000
@@ -17,6 +17,7 @@
  */
 
 #include "basic_window_manager.h"
+#include "miral/window_manager_tools.h"
 
 #include <mir/scene/session.h>
 #include <mir/scene/surface.h>
@@ -60,7 +61,7 @@
     WindowManagementPolicyBuilder const& build) :
     focus_controller(focus_controller),
     display_layout(display_layout),
-    policy(build(this)),
+    policy(build(WindowManagerTools{this})),
     surface_builder([](std::shared_ptr<scene::Session> const&, WindowSpecification const&) -> Window
         { throw std::logic_error{"Can't create a window yet"};})
 {

=== modified file 'miral/basic_window_manager.h'
--- miral/basic_window_manager.h	2016-07-25 11:49:06 +0000
+++ miral/basic_window_manager.h	2016-07-28 08:41:50 +0000
@@ -20,7 +20,7 @@
 #define MIR_ABSTRACTION_BASIC_WINDOW_MANAGER_H_
 
 #include "miral/window_management_policy.h"
-#include "miral/window_manager_tools.h"
+#include "window_manager_tools_implementation.h"
 #include "miral/window_info.h"
 #include "miral/application.h"
 #include "miral/application_info.h"
@@ -42,12 +42,12 @@
 {
 using mir::shell::SurfaceSet;
 using WindowManagementPolicyBuilder =
-    std::function<std::unique_ptr<miral::WindowManagementPolicy>(miral::WindowManagerTools* tools)>;
+    std::function<std::unique_ptr<miral::WindowManagementPolicy>(miral::WindowManagerTools const& tools)>;
 
 /// A policy based window manager.
 /// This takes care of the management of any meta implementation held for the sessions and windows.
 class BasicWindowManager : public virtual mir::shell::WindowManager,
-    protected WindowManagerTools
+    protected WindowManagerToolsImplementation
 {
 public:
     BasicWindowManager(

=== modified file 'miral/canonical_window_manager.cpp'
--- miral/canonical_window_manager.cpp	2016-07-22 16:33:35 +0000
+++ miral/canonical_window_manager.cpp	2016-07-28 08:41:50 +0000
@@ -25,7 +25,7 @@
 
 // Based on "Mir and Unity: Surfaces, input, and displays (v0.3)"
 
-miral::CanonicalWindowManagerPolicy::CanonicalWindowManagerPolicy(WindowManagerTools* const tools) :
+miral::CanonicalWindowManagerPolicy::CanonicalWindowManagerPolicy(WindowManagerTools const& tools) :
     tools{tools}
 {
 }
@@ -40,22 +40,22 @@
 
 void miral::CanonicalWindowManagerPolicy::handle_window_ready(WindowInfo& window_info)
 {
-    tools->select_active_window(window_info.window());
+    tools.select_active_window(window_info.window());
 }
 
 void miral::CanonicalWindowManagerPolicy::handle_modify_window(
     WindowInfo& window_info,
     WindowSpecification const& modifications)
 {
-    tools->modify_window(window_info, modifications);
+    tools.modify_window(window_info, modifications);
 }
 
 void miral::CanonicalWindowManagerPolicy::handle_raise_window(WindowInfo& window_info)
 {
-    tools->select_active_window(window_info.window());
+    tools.select_active_window(window_info.window());
 }
 
 void miral::CanonicalWindowManagerPolicy::advise_focus_gained(WindowInfo const& info)
 {
-    tools->raise_tree(info.window());
+    tools.raise_tree(info.window());
 }

=== added file 'miral/window_manager_tools.cpp'
--- miral/window_manager_tools.cpp	1970-01-01 00:00:00 +0000
+++ miral/window_manager_tools.cpp	2016-07-28 08:41:50 +0000
@@ -0,0 +1,87 @@
+/*
+ * 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/window_manager_tools.h"
+#include "window_manager_tools_implementation.h"
+
+miral::WindowManagerTools::WindowManagerTools(WindowManagerToolsImplementation* tools) :
+    tools{tools}
+{
+}
+
+miral::WindowManagerTools::WindowManagerTools(WindowManagerTools const&) = default;
+miral::WindowManagerTools& miral::WindowManagerTools::operator=(WindowManagerTools const&) = default;
+miral::WindowManagerTools::~WindowManagerTools() = default;
+
+auto miral::WindowManagerTools::count_applications() const -> unsigned int
+{ return tools->count_applications(); }
+
+void miral::WindowManagerTools::for_each_application(std::function<void(ApplicationInfo& info)> const& functor)
+{ tools->for_each_application(functor); }
+
+auto miral::WindowManagerTools::find_application(std::function<bool(ApplicationInfo const& info)> const& predicate)
+-> Application
+{ return tools->find_application(predicate); }
+
+auto miral::WindowManagerTools::info_for(std::weak_ptr<mir::scene::Session> const& session) const -> ApplicationInfo&
+{ return tools->info_for(session); }
+
+auto miral::WindowManagerTools::info_for(std::weak_ptr<mir::scene::Surface> const& surface) const -> WindowInfo&
+{ return tools->info_for(surface); }
+
+auto miral::WindowManagerTools::info_for(Window const& window) const -> WindowInfo&
+{ return tools->info_for(window); }
+
+void miral::WindowManagerTools::kill_active_application(int sig)
+{ tools->kill_active_application(sig); }
+
+auto miral::WindowManagerTools::active_window() const -> Window
+{ return tools->active_window(); }
+
+auto miral::WindowManagerTools::select_active_window(Window const& hint) -> Window
+{ return tools->select_active_window(hint); }
+
+void miral::WindowManagerTools::drag_active_window(mir::geometry::Displacement movement)
+{ tools->drag_active_window(movement); }
+
+void miral::WindowManagerTools::focus_next_application()
+{ tools->focus_next_application(); }
+
+void miral::WindowManagerTools::focus_next_within_application()
+{ tools->focus_next_within_application(); }
+
+auto miral::WindowManagerTools::window_at(mir::geometry::Point cursor) const -> Window
+{ return tools->window_at(cursor); }
+
+auto miral::WindowManagerTools::active_display() -> mir::geometry::Rectangle const
+{ return tools->active_display(); }
+
+void miral::WindowManagerTools::raise_tree(Window const& root)
+{ tools->raise_tree(root); }
+
+void miral::WindowManagerTools::modify_window(WindowInfo& window_info, WindowSpecification const& modifications)
+{ tools->modify_window(window_info,modifications); }
+
+void miral::WindowManagerTools::place_and_size(WindowInfo& window_info, Point const& new_pos, Size const& new_size)
+{ tools->place_and_size(window_info, new_pos, new_size); }
+
+void miral::WindowManagerTools::set_state(WindowInfo& window_info, MirSurfaceState value)
+{ tools->set_state(window_info, value); }
+
+void miral::WindowManagerTools::invoke_under_lock(std::function<void()> const& callback)
+{ tools->invoke_under_lock(callback); }

=== added file 'miral/window_manager_tools_implementation.h'
--- miral/window_manager_tools_implementation.h	1970-01-01 00:00:00 +0000
+++ miral/window_manager_tools_implementation.h	2016-07-28 08:41:50 +0000
@@ -0,0 +1,84 @@
+/*
+ * 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_WINDOW_MANAGER_TOOLS_IMPLEMENTATION_H
+#define MIRAL_WINDOW_MANAGER_TOOLS_IMPLEMENTATION_H
+
+#include "miral/application.h"
+
+#include <mir/geometry/displacement.h>
+
+#include <functional>
+#include <memory>
+
+namespace mir { namespace scene { class Surface; } }
+
+namespace miral
+{
+class Window;
+struct WindowInfo;
+struct ApplicationInfo;
+class WindowSpecification;
+
+// The interface through which the policy instructs the controller.
+class WindowManagerToolsImplementation
+{
+public:
+/** @name Update Model
+ *  These functions assume that the BasicWindowManager data structures can be accessed freely.
+ *  I.e. they should only be used by a thread that has called the WindowManagementPolicy methods
+ *  (where any necessary locks are held) or via a invoke_under_lock() callback.
+ *  @{ */
+    virtual auto count_applications() const -> unsigned int = 0;
+    virtual void for_each_application(std::function<void(ApplicationInfo& info)> const& functor) = 0;
+    virtual auto find_application(std::function<bool(ApplicationInfo const& info)> const& predicate)
+    -> Application = 0;
+    virtual auto info_for(std::weak_ptr<mir::scene::Session> const& session) const -> ApplicationInfo& = 0;
+    virtual auto info_for(std::weak_ptr<mir::scene::Surface> const& surface) const -> WindowInfo& = 0;
+    virtual auto info_for(Window const& window) const -> WindowInfo& = 0;
+    virtual void kill_active_application(int sig) = 0;
+    virtual auto active_window() const -> Window = 0;
+    virtual auto select_active_window(Window const& hint) -> Window = 0;
+    virtual void drag_active_window(mir::geometry::Displacement movement) = 0;
+    virtual void focus_next_application() = 0;
+    virtual void focus_next_within_application() = 0;
+    virtual auto window_at(mir::geometry::Point cursor) const -> Window = 0;
+    virtual auto active_display() -> mir::geometry::Rectangle const = 0;
+    virtual void raise_tree(Window const& root) = 0;
+    virtual void modify_window(WindowInfo& window_info, WindowSpecification const& modifications) = 0;
+    virtual void place_and_size(WindowInfo& window_info, Point const& new_pos, Size const& new_size) = 0;
+    virtual void set_state(WindowInfo& window_info, MirSurfaceState value) = 0;
+/** @} */
+
+/** @name Multi-thread support
+ *  Allows threads that don't hold a lock on the model to acquire one and call the "Update Model"
+ *  member functions.
+ *  This should NOT be used by a thread that has called the WindowManagementPolicy methods (and
+ *  already holds the lock).
+ *  @{ */
+    virtual void invoke_under_lock(std::function<void()> const& callback) = 0;
+/** @} */
+
+    virtual ~WindowManagerToolsImplementation() = default;
+    WindowManagerToolsImplementation() = default;
+    WindowManagerToolsImplementation(WindowManagerToolsImplementation const&) = delete;
+    WindowManagerToolsImplementation& operator=(WindowManagerToolsImplementation const&) = delete;
+};
+}
+
+#endif //MIRAL_WINDOW_MANAGER_TOOLS_IMPLEMENTATION_H