Merge lp:~ci-train-bot/qtmir/qtmir-ubuntu-xenial-landing-064 into lp:qtmir

[Michał Sawicz]

=== modified file 'debian/changelog'
--- debian/changelog	2016-02-19 10:41:19 +0000
+++ debian/changelog	2016-03-11 11:36:44 +0000
@@ -1,3 +1,33 @@
+qtmir (0.4.7+16.04.20160310.1-0ubuntu1) xenial; urgency=medium
+
+  [ Alan Griffiths ]
+  * Copy the Window Management work-in-progress from Mir examples.
+
+  [ Alberto Aguirre ]
+  * Hook MirOpenGLContext::doneCurrent to Screen::doneCurrent
+
+  [ Daniel d'Andrada ]
+  * Ensure QmlEngine doesn't delete our MirSurfaces
+
+  [ Gerry Boland ]
+  * Allow Mir remove command line arguments it understands, before
+    letting Qt process them.
+  * Ensure ScreenWindow geometry correctly set and used after moving
+    Screen (LP: #1545286)
+  * Screen: only enable orientation sensor for internal display. (LP:
+    #1545286)
+
+  [ Michael Terry ]
+  * Fix some mocks to use more realistic code paths.
+
+  [ Michael Zanetti ]
+  * Add a dedicated property for the inputMethodSurface (LP: #1545286)
+
+  [ Michał Sawicz ]
+  * Drop dummy autopkgtest
+
+ -- Michał Sawicz <[e-mail]>  Thu, 10 Mar 2016 09:29:49 +0000
+
 qtmir (0.4.7+16.04.20160219-0ubuntu1) xenial; urgency=medium
 
   * Mir 0.20 Release

=== removed directory 'debian/tests'
=== removed file 'debian/tests/control'
--- debian/tests/control	2015-10-27 15:53:28 +0000
+++ debian/tests/control	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-Tests: run-tests
-Restrictions: build-needed
-Depends: qtdeclarative5-qtmir-plugin,
-         qtmir-desktop,
-         qtmir-tests,

=== removed file 'debian/tests/run-tests'
--- debian/tests/run-tests	2015-06-15 15:57:04 +0000
+++ debian/tests/run-tests	1970-01-01 00:00:00 +0000
@@ -1,10 +0,0 @@
-#!/bin/sh
-
-set -ex
-
-# Do nothing here. We don't need to run the tests multiple times, and they
-# are already being run during the build phase of the autopkgtest, as we
-# require a built tree to run them, and the tests are run as part of the
-# normal package build process. We do want to test that things install, though
-# and at least one test is actually required, for autopkgtest to work.
-

=== modified file 'src/modules/Unity/Application/mirsurface.cpp'
--- src/modules/Unity/Application/mirsurface.cpp	2016-02-11 11:58:16 +0000
+++ src/modules/Unity/Application/mirsurface.cpp	2016-03-11 11:36:44 +0000
@@ -32,6 +32,9 @@
 // mirserver
 #include <logging.h>
 
+// Qt
+#include <QQmlEngine>
+
 using namespace qtmir;
 
 #define DEBUG_MSG qCDebug(QTMIR_SURFACES).nospace() << "MirSurface[" << (void*)this << "," << appId() <<"]::" << __func__
@@ -223,6 +226,8 @@
     // in practice rarely happen.
     m_frameDropperTimer.setInterval(200);
     m_frameDropperTimer.setSingleShot(false);
+
+    QQmlEngine::setObjectOwnership(this, QQmlEngine::CppOwnership);
 }
 
 MirSurface::~MirSurface()

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.cpp'
--- src/modules/Unity/Application/mirsurfacemanager.cpp	2016-02-11 11:58:16 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.cpp	2016-03-11 11:36:44 +0000
@@ -114,6 +114,11 @@
     if (session)
         session->registerSurface(qmlSurface);
 
+    if (qmlSurface->type() == Mir::InputMethodType) {
+        m_inputMethodSurface = qmlSurface;
+        Q_EMIT inputMethodSurfaceChanged();
+    }
+
     // Only notify QML of surface creation once it has drawn its first frame.
     connect(qmlSurface, &MirSurfaceInterface::firstFrameDrawn, this, [=]() {
         tracepoint(qtmir, firstFrameDrawn);
@@ -155,8 +160,18 @@
         }
     }
 
+    if (qmlSurface->type() == Mir::InputMethodType) {
+        m_inputMethodSurface = nullptr;
+        Q_EMIT inputMethodSurfaceChanged();
+    }
+
     qmlSurface->setLive(false);
     Q_EMIT surfaceDestroyed(qmlSurface);
 }
 
+MirSurfaceInterface* MirSurfaceManager::inputMethodSurface() const
+{
+    return m_inputMethodSurface;
+}
+
 } // namespace qtmir

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.h'
--- src/modules/Unity/Application/mirsurfacemanager.h	2016-02-11 11:58:16 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.h	2016-03-11 11:36:44 +0000
@@ -54,7 +54,7 @@
 class MirSurfaceManager : public QObject
 {
     Q_OBJECT
-
+    Q_PROPERTY(MirSurfaceInterface* inputMethodSurface READ inputMethodSurface NOTIFY inputMethodSurfaceChanged)
 public:
     explicit MirSurfaceManager(
         const QSharedPointer<MirServer>& mirServer,
@@ -66,7 +66,10 @@
 
     static MirSurfaceManager* singleton();
 
+    MirSurfaceInterface* inputMethodSurface() const;
+
 Q_SIGNALS:
+    void inputMethodSurfaceChanged();
     void surfaceCreated(MirSurfaceInterface* surface);
     void surfaceDestroyed(MirSurfaceInterface* surface);
 
@@ -86,6 +89,7 @@
     mir::shell::Shell *const m_shell;
     SessionManager* m_sessionManager;
     static MirSurfaceManager *instance;
+    MirSurfaceInterface* m_inputMethodSurface = nullptr;
 };
 
 } // namespace qtmir

=== modified file 'src/platforms/mirserver/CMakeLists.txt'
--- src/platforms/mirserver/CMakeLists.txt	2016-02-11 11:58:16 +0000
+++ src/platforms/mirserver/CMakeLists.txt	2016-03-11 11:36:44 +0000
@@ -36,6 +36,8 @@
     ${APPLICATION_API_INCLUDE_DIRS}
 )
 
+add_subdirectory(wm-wip)
+
 # We have to remove -pedantic for tracepoints.c
 string (REPLACE " -pedantic " " " CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
 # Needed to compile tracepoints in C99 mode.

=== added file 'src/platforms/mirserver/argvHelper.h'
--- src/platforms/mirserver/argvHelper.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/argvHelper.h	2016-03-11 11:36:44 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2015 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 warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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/>.
+ */
+
+#ifndef ARGVHELPER_P_H
+#define ARGVHELPER_P_H
+
+#include <cassert>
+
+namespace qtmir {
+
+// Function to edit argv to strip out unmatched entries of targetArray, so both arrays have identical contents
+// Note: Mir parses out arguments that it understands, but it also removes argv[0] (bug pad.lv/1511509)
+// so need to ensure argv[0] is the binary name as usual.
+void editArgvToMatch(int &argcToEdit, char** argvToEdit, int targetCount, const char* const targetArray[])
+{
+    // Make copy of the argv array of pointers, as we will be editing the original
+    const size_t arraySize = (argcToEdit + 1) * sizeof(char*);
+    char** argvCopy = static_cast<char**>(malloc(arraySize));
+    memcpy(argvCopy, argvToEdit, arraySize);
+
+    int k=1; // index of argv we want to edit - note we'll leave argv[0] alone
+    for (int i=0; i<targetCount; i++) { // taking each argument Mir did not parse out
+        for (int j=1; j<argcToEdit; j++) { // find pointer to same argument in argvCopy (leave arg[0] out)
+            if (strcmp(targetArray[i], argvCopy[j]) == 0) {
+                argvToEdit[k] = const_cast<char*>(argvCopy[j]); // edit argv to position that argument to match argv2.
+                k++;
+                break;
+            }
+        }
+    }
+    assert(k == targetCount+1);
+    argvToEdit[k] = nullptr;
+    free(argvCopy);
+    argcToEdit = targetCount+1; // now argv and targetArray should have list the same strings.
+}
+
+} // namespace qtmir
+
+#endif // ARGVHELPER_P_H

=== modified file 'src/platforms/mirserver/miropenglcontext.cpp'
--- src/platforms/mirserver/miropenglcontext.cpp	2015-09-14 22:38:20 +0000
+++ src/platforms/mirserver/miropenglcontext.cpp	2016-03-11 11:36:44 +0000
@@ -36,8 +36,9 @@
 // (i.e. individual display output buffers) to use as a common base context.
 
 MirOpenGLContext::MirOpenGLContext(const QSharedPointer<MirServer> &server, const QSurfaceFormat &format)
+    : m_currentWindow(nullptr)
 #ifndef QT_NO_DEBUG
-    : m_logger(new QOpenGLDebugLogger(this))
+      , m_logger(new QOpenGLDebugLogger(this))
 #endif
 {
     auto display = server->the_display();
@@ -131,6 +132,7 @@
     // ultimately calls Mir's DisplayBuffer::make_current()
     ScreenWindow *screenWindow = static_cast<ScreenWindow*>(surface);
     if (screenWindow) {
+        m_currentWindow = screenWindow;
         screenWindow->makeCurrent();
 
 #ifndef QT_NO_DEBUG
@@ -148,7 +150,10 @@
 
 void MirOpenGLContext::doneCurrent()
 {
-    // FIXME: create a temporary GL context just to release? Would be better to get existing one.
+    if (m_currentWindow) {
+        m_currentWindow->doneCurrent();
+        m_currentWindow = nullptr;
+    }
 }
 
 QFunctionPointer MirOpenGLContext::getProcAddress(const QByteArray &procName)

=== modified file 'src/platforms/mirserver/miropenglcontext.h'
--- src/platforms/mirserver/miropenglcontext.h	2015-09-14 22:38:20 +0000
+++ src/platforms/mirserver/miropenglcontext.h	2016-03-11 11:36:44 +0000
@@ -25,6 +25,7 @@
 
 
 class MirServer;
+class ScreenWindow;
 
 class MirOpenGLContext : public QObject, public QPlatformOpenGLContext
 {
@@ -49,6 +50,7 @@
 
 private:
     QSurfaceFormat m_format;
+    ScreenWindow *m_currentWindow;
 #ifndef QT_NO_DEBUG
     QOpenGLDebugLogger *m_logger;
 #endif

=== modified file 'src/platforms/mirserver/mirserver.cpp'
--- src/platforms/mirserver/mirserver.cpp	2016-02-11 11:58:16 +0000
+++ src/platforms/mirserver/mirserver.cpp	2016-03-11 11:36:44 +0000
@@ -19,6 +19,7 @@
 #include "mirserver.h"
 
 // local
+#include "argvHelper.h"
 #include "mircursorimages.h"
 #include "mirwindowmanager.h"
 #include "mirglconfig.h"
@@ -47,22 +48,24 @@
 namespace msh = mir::shell;
 namespace ms = mir::scene;
 
-namespace
-{
-void ignore_unparsed_arguments(int /*argc*/, char const* const/*argv*/[])
-{
-}
-}
-
 Q_LOGGING_CATEGORY(QTMIR_MIR_MESSAGES, "qtmir.mir")
 
-MirServer::MirServer(int argc, char const* argv[],
+
+MirServer::MirServer(int &argc, char **argv,
                      const QSharedPointer<ScreenController> &screenController, QObject* parent)
     : QObject(parent)
     , m_screenController(screenController)
 {
-    set_command_line_handler(&ignore_unparsed_arguments);
-    set_command_line(argc, argv);
+    bool unknownArgsFound = false;
+    set_command_line_handler([&argc, &argv, &unknownArgsFound](int filteredCount, const char* const filteredArgv[]) {
+        unknownArgsFound = true;
+        // Want to edit argv to match that which Mir returns, as those are for to Qt alone to process. Edit existing
+        // argc as filteredArgv only defined in this scope.
+        qtmir::editArgvToMatch(argc, argv, filteredCount, filteredArgv);
+    });
+
+    // Casting char** to be a const char** safe as Mir won't change it, nor will we
+    set_command_line(argc, const_cast<const char **>(argv));
 
     override_the_session_listener([]
         {
@@ -130,7 +133,16 @@
         screenController->init(the_display(), the_compositor());
     });
 
-    apply_settings();
+    try {
+        apply_settings();
+    } catch (const std::exception &ex) {
+        qCritical() << ex.what();
+        exit(1);
+    }
+
+    if (!unknownArgsFound) { // mir parsed all the arguments, so edit argv to pretend to have just argv[0]
+        argc = 1;
+    }
 
     // We will draw our own cursor.
     // FIXME: Call override_the_cusor() instead once this method becomes available in a
@@ -142,6 +154,7 @@
     });
 
     qCDebug(QTMIR_MIR_MESSAGES) << "MirServer created";
+    qCDebug(QTMIR_MIR_MESSAGES) << "Command line arguments passed to Qt:" << QCoreApplication::arguments();
 }
 
 // Override default implementation to ensure we terminate the ScreenController first.

=== modified file 'src/platforms/mirserver/mirserver.h'
--- src/platforms/mirserver/mirserver.h	2016-02-11 11:54:59 +0000
+++ src/platforms/mirserver/mirserver.h	2016-03-11 11:36:44 +0000
@@ -41,7 +41,7 @@
     Q_PROPERTY(PromptSessionListener* promptSessionListener READ promptSessionListener CONSTANT)
 
 public:
-    MirServer(int argc, char const* argv[], const QSharedPointer<ScreenController> &, QObject* parent = 0);
+    MirServer(int &argc, char **argv, const QSharedPointer<ScreenController> &, QObject* parent = 0);
     ~MirServer() = default;
 
     /* mir specific */

=== modified file 'src/platforms/mirserver/mirserverintegration.cpp'
--- src/platforms/mirserver/mirserverintegration.cpp	2015-10-21 11:46:33 +0000
+++ src/platforms/mirserver/mirserverintegration.cpp	2016-03-11 11:36:44 +0000
@@ -51,11 +51,11 @@
 namespace mg = mir::graphics;
 using qtmir::Clipboard;
 
-MirServerIntegration::MirServerIntegration()
+MirServerIntegration::MirServerIntegration(int &argc, char **argv)
     : m_accessibility(new QPlatformAccessibility())
     , m_fontDb(new QGenericUnixFontDatabase())
     , m_services(new Services)
-    , m_mirServer(new QMirServer(QCoreApplication::arguments()))
+    , m_mirServer(new QMirServer(argc, argv))
     , m_nativeInterface(nullptr)
     , m_clipboard(new Clipboard)
 {

=== modified file 'src/platforms/mirserver/mirserverintegration.h'
--- src/platforms/mirserver/mirserverintegration.h	2015-08-20 10:16:54 +0000
+++ src/platforms/mirserver/mirserverintegration.h	2016-03-11 11:36:44 +0000
@@ -31,7 +31,7 @@
 class MirServerIntegration : public QPlatformIntegration
 {
 public:
-    MirServerIntegration();
+    MirServerIntegration(int &argc, char **argv);
     ~MirServerIntegration();
 
     bool hasCapability(QPlatformIntegration::Capability cap) const override;

=== modified file 'src/platforms/mirserver/plugin.cpp'
--- src/platforms/mirserver/plugin.cpp	2015-08-11 12:08:32 +0000
+++ src/platforms/mirserver/plugin.cpp	2016-03-11 11:36:44 +0000
@@ -17,14 +17,10 @@
 #include "plugin.h"
 #include "mirserverintegration.h"
 
-QStringList MirServerIntegrationPlugin::keys() const {
-    QStringList list;
-    list << "mirserver";
-    return list;
-}
-
-QPlatformIntegration* MirServerIntegrationPlugin::create(const QString &system, const QStringList &) {
+QPlatformIntegration *MirServerIntegrationPlugin::create(const QString &system, const QStringList &/*paramList*/,
+                                                         int &argc, char **argv)
+{
     if (system.toLower() == "mirserver")
-        return new MirServerIntegration;
+        return new MirServerIntegration(argc, argv);
     return 0;
 }

=== modified file 'src/platforms/mirserver/plugin.h'
--- src/platforms/mirserver/plugin.h	2015-08-11 12:08:32 +0000
+++ src/platforms/mirserver/plugin.h	2016-03-11 11:36:44 +0000
@@ -25,8 +25,7 @@
     Q_PLUGIN_METADATA(IID QPlatformIntegrationFactoryInterface_iid FILE "mirserver.json")
 
 public:
-    QStringList keys() const;
-    QPlatformIntegration* create(const QString&, const QStringList&);
+    QPlatformIntegration *create(const QString &system, const QStringList &paramList, int &argc, char **argv) override;
 };
 
 #endif // PLUGIN_H

=== modified file 'src/platforms/mirserver/qmirserver.cpp'
--- src/platforms/mirserver/qmirserver.cpp	2015-11-19 12:55:57 +0000
+++ src/platforms/mirserver/qmirserver.cpp	2016-03-11 11:36:44 +0000
@@ -26,24 +26,15 @@
 #include "screencontroller.h"
 #include "screen.h"
 
-QMirServer::QMirServer(const QStringList &arguments, QObject *parent)
+QMirServer::QMirServer(int &argc, char **argv, QObject *parent)
     : QObject(parent)
     , d_ptr(new QMirServerPrivate())
 {
     Q_D(QMirServer);
 
-    // convert arguments back into argc-argv form that Mir wants
-    int argc = arguments.size();
-    char **argv = new char*[argc + 1];
-    for (int i = 0; i < argc; i++) {
-        argv[i] = new char[strlen(arguments.at(i).toStdString().c_str())+1];
-        memcpy(argv[i], arguments.at(i).toStdString().c_str(), strlen(arguments.at(i).toStdString().c_str())+1);
-    }
-    argv[argc] = nullptr;
-
     d->screenController = QSharedPointer<ScreenController>(new ScreenController());
 
-    d->server = QSharedPointer<MirServer>(new MirServer(argc, const_cast<const char**>(argv), d->screenController));
+    d->server = QSharedPointer<MirServer>(new MirServer(argc, argv, d->screenController));
 
     d->serverThread = new MirServerThread(d->server);
 

=== modified file 'src/platforms/mirserver/qmirserver.h'
--- src/platforms/mirserver/qmirserver.h	2015-08-20 10:16:54 +0000
+++ src/platforms/mirserver/qmirserver.h	2016-03-11 11:36:44 +0000
@@ -30,7 +30,7 @@
     Q_OBJECT
 
 public:
-    QMirServer(const QStringList &arguments, QObject* parent=0);
+    QMirServer(int &argc, char **argv, QObject* parent=0);
     virtual ~QMirServer();
 
     bool start();

=== modified file 'src/platforms/mirserver/screen.cpp'
--- src/platforms/mirserver/screen.cpp	2015-10-14 22:59:04 +0000
+++ src/platforms/mirserver/screen.cpp	2016-03-11 11:36:44 +0000
@@ -135,9 +135,11 @@
             ? Qt::LandscapeOrientation : Qt::PortraitOrientation;
     qCDebug(QTMIR_SENSOR_MESSAGES) << "Screen - initial currentOrientation is:" << m_currentOrientation;
 
-    QObject::connect(m_orientationSensor, &QOrientationSensor::readingChanged,
-                     this, &Screen::onOrientationReadingChanged);
-    m_orientationSensor->start();
+    if (internalDisplay()) { // only enable orientation sensor for device-internal display
+        QObject::connect(m_orientationSensor, &QOrientationSensor::readingChanged,
+                         this, &Screen::onOrientationReadingChanged);
+        m_orientationSensor->start();
+    }
 
     if (!skipDBusRegistration) {
         // FIXME This is a unity8 specific dbus call and shouldn't be in qtmir
@@ -171,7 +173,9 @@
 void Screen::onDisplayPowerStateChanged(int status, int reason)
 {
     Q_UNUSED(reason);
-    toggleSensors(status);
+    if (internalDisplay()) {
+        toggleSensors(status);
+    }
 }
 
 void Screen::setMirDisplayConfiguration(const mir::graphics::DisplayConfigurationOutput &screen)
@@ -297,6 +301,13 @@
         qCDebug(QTMIR_SENSOR_MESSAGES) << "Screen::setWindow - overwriting existing ScreenWindow";
     }
     m_screenWindow = window;
+
+    if (m_screenWindow) {
+        if (m_screenWindow->geometry() != geometry()) {
+            qCDebug(QTMIR_SCREENS) << "Screen::setWindow - new geometry for shell surface" << window->window() << geometry();
+            m_screenWindow->setGeometry(geometry());
+        }
+    }
 }
 
 void Screen::setMirDisplayBuffer(mir::graphics::DisplayBuffer *buffer, mir::graphics::DisplaySyncGroup *group)
@@ -334,3 +345,12 @@
 {
     m_renderTarget->release_current();
 }
+
+bool Screen::internalDisplay() const
+{
+    using namespace mir::graphics;
+    if (m_type == DisplayConfigurationOutputType::lvds || m_type == DisplayConfigurationOutputType::edp) {
+        return true;
+    }
+    return false;
+}

=== modified file 'src/platforms/mirserver/screen.h'
--- src/platforms/mirserver/screen.h	2015-10-14 22:59:04 +0000
+++ src/platforms/mirserver/screen.h	2016-03-11 11:36:44 +0000
@@ -53,7 +53,6 @@
     Qt::ScreenOrientation orientation() const override { return m_currentOrientation; }
     QPlatformCursor *cursor() const override;
 
-    void toggleSensors(const bool enable) const;
     mir::graphics::DisplayConfigurationOutputType outputType() const { return m_type; }
 
     ScreenWindow* window() const;
@@ -79,6 +78,9 @@
     void doneCurrent();
 
 private:
+    void toggleSensors(const bool enable) const;
+    bool internalDisplay() const;
+
     QRect m_geometry;
     int m_depth;
     QImage::Format m_format;

=== modified file 'src/platforms/mirserver/screenwindow.cpp'
--- src/platforms/mirserver/screenwindow.cpp	2015-10-15 07:05:16 +0000
+++ src/platforms/mirserver/screenwindow.cpp	2016-03-11 11:36:44 +0000
@@ -89,7 +89,7 @@
     auto renderer = QSGRenderLoop::instance();
     if (exposed) {
         renderer->show(quickWindow);
-        QWindowSystemInterface::handleExposeEvent(window(), QRegion()); // else it won't redraw
+        QWindowSystemInterface::handleExposeEvent(window(), geometry()); // else it won't redraw
     } else {
         quickWindow->setPersistentOpenGLContext(false);
         quickWindow->setPersistentSceneGraph(false);

=== added directory 'src/platforms/mirserver/wm-wip'
=== added file 'src/platforms/mirserver/wm-wip/CMakeLists.txt'
--- src/platforms/mirserver/wm-wip/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/CMakeLists.txt	2016-03-11 11:36:44 +0000
@@ -0,0 +1,22 @@
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC")
+
+add_library(experimentalwindowmanager STATIC
+  server_example_basic_window_manager.cpp
+  server_example_basic_window_manager.h
+  server_example_window_management_info.cpp
+  server_example_window_management_info.h
+)
+
+
+if (EXAMPLE_MIR_WINDOW_MANAGERS)
+
+add_library(examplewindowmanager STATIC
+  server_example_canonical_window_manager.h
+  server_example_tiling_window_manager.h
+  server_example_window_management.h
+  server_example_canonical_window_manager.cpp
+  server_example_tiling_window_manager.cpp
+  server_example_window_management.cpp
+)
+
+endif()

=== added file 'src/platforms/mirserver/wm-wip/README'
--- src/platforms/mirserver/wm-wip/README	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/README	2016-03-11 11:36:44 +0000
@@ -0,0 +1,5 @@
+examples for mir clients. you should have package 'libmirclient-dev' installed
+
+you can compile with a command like:
+    g++ -std=c++0x -o mir_demo_client_scroll `pkg-config --libs --cflags mirclient` demo_client_scroll.cpp graphics_utils.cpp
+    gcc -o mir_demo_client_flicker `pkg-config --libs --cflags mirclient` demo_client_flicker.c

=== added file 'src/platforms/mirserver/wm-wip/server_example_basic_window_manager.cpp'
--- src/platforms/mirserver/wm-wip/server_example_basic_window_manager.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_basic_window_manager.cpp	2016-03-11 11:36:44 +0000
@@ -0,0 +1,312 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * 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 "server_example_basic_window_manager.h"
+
+#include "mir/scene/session.h"
+#include "mir/scene/surface.h"
+#include "mir/scene/surface_creation_parameters.h"
+
+namespace me = mir::examples;
+
+me::BasicWindowManager::BasicWindowManager(
+    shell::FocusController* focus_controller,
+    std::unique_ptr<WindowManagementPolicy> policy) :
+    focus_controller(focus_controller),
+    policy(std::move(policy))
+{
+}
+
+void me::BasicWindowManager::add_session(std::shared_ptr<scene::Session> const& session)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    session_info[session] = SessionInfo();
+    policy->handle_session_info_updated(session_info, displays);
+}
+
+void me::BasicWindowManager::remove_session(std::shared_ptr<scene::Session> const& session)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    session_info.erase(session);
+    policy->handle_session_info_updated(session_info, displays);
+}
+
+auto me::BasicWindowManager::add_surface(
+    std::shared_ptr<scene::Session> const& session,
+    scene::SurfaceCreationParameters const& params,
+    std::function<frontend::SurfaceId(std::shared_ptr<scene::Session> const& session, scene::SurfaceCreationParameters const& params)> const& build)
+-> frontend::SurfaceId
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    scene::SurfaceCreationParameters const placed_params = policy->handle_place_new_surface(session, params);
+    auto const result = build(session, placed_params);
+    auto const surface = session->surface(result);
+    surface_info.emplace(surface, SurfaceInfo{session, surface, placed_params});
+    policy->handle_new_surface(session, surface);
+    policy->generate_decorations_for(session, surface, surface_info, build);
+    return result;
+}
+
+void me::BasicWindowManager::modify_surface(
+    std::shared_ptr<scene::Session> const& session,
+    std::shared_ptr<scene::Surface> const& surface,
+    shell::SurfaceSpecification const& modifications)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    policy->handle_modify_surface(session, surface, modifications);
+}
+
+void me::BasicWindowManager::remove_surface(
+    std::shared_ptr<scene::Session> const& session,
+    std::weak_ptr<scene::Surface> const& surface)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    policy->handle_delete_surface(session, surface);
+
+    surface_info.erase(surface);
+}
+
+void me::BasicWindowManager::forget(std::weak_ptr<scene::Surface> const& surface)
+{
+    surface_info.erase(surface);
+}
+
+void me::BasicWindowManager::add_display(geometry::Rectangle const& area)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    displays.add(area);
+    policy->handle_displays_updated(session_info, displays);
+}
+
+void me::BasicWindowManager::remove_display(geometry::Rectangle const& area)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    displays.remove(area);
+    policy->handle_displays_updated(session_info, displays);
+}
+
+bool me::BasicWindowManager::handle_keyboard_event(MirKeyboardEvent const* event)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    update_event_timestamp(event);
+    return policy->handle_keyboard_event(event);
+}
+
+bool me::BasicWindowManager::handle_touch_event(MirTouchEvent const* event)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    update_event_timestamp(event);
+    return policy->handle_touch_event(event);
+}
+
+bool me::BasicWindowManager::handle_pointer_event(MirPointerEvent const* event)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    update_event_timestamp(event);
+
+    cursor = {
+        mir_pointer_event_axis_value(event, mir_pointer_axis_x),
+        mir_pointer_event_axis_value(event, mir_pointer_axis_y)};
+
+    return policy->handle_pointer_event(event);
+}
+
+void me::BasicWindowManager::handle_raise_surface(
+    std::shared_ptr<scene::Session> const& session,
+    std::shared_ptr<scene::Surface> const& surface,
+    uint64_t timestamp)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    if (timestamp >= last_input_event_timestamp)
+        policy->handle_raise_surface(session, surface);
+}
+
+int me::BasicWindowManager::set_surface_attribute(
+    std::shared_ptr<scene::Session> const& /*session*/,
+    std::shared_ptr<scene::Surface> const& surface,
+    MirSurfaceAttrib attrib,
+    int value)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    switch (attrib)
+    {
+    case mir_surface_attrib_state:
+    {
+        auto const state = policy->handle_set_state(surface, MirSurfaceState(value));
+        return surface->configure(attrib, state);
+    }
+    default:
+        return surface->configure(attrib, value);
+    }
+}
+
+auto me::BasicWindowManager::find_session(std::function<bool(SessionInfo const& info)> const& predicate)
+-> std::shared_ptr<scene::Session>
+    {
+        for(auto& info : session_info)
+        {
+            if (predicate(info.second))
+            {
+                return info.first.lock();
+            }
+        }
+
+        return std::shared_ptr<scene::Session>{};
+    }
+
+auto me::BasicWindowManager::info_for(std::weak_ptr<scene::Session> const& session) const
+-> SessionInfo&
+{
+    return const_cast<SessionInfo&>(session_info.at(session));
+}
+
+auto me::BasicWindowManager::info_for(std::weak_ptr<scene::Surface> const& surface) const
+-> SurfaceInfo&
+{
+    return const_cast<SurfaceInfo&>(surface_info.at(surface));
+}
+
+auto me::BasicWindowManager::focused_session() const
+-> std::shared_ptr<scene::Session>
+{
+    return focus_controller->focused_session();
+}
+
+auto me::BasicWindowManager::focused_surface() const
+->std::shared_ptr<scene::Surface>
+{
+    return focus_controller->focused_surface();
+}
+
+void me::BasicWindowManager::focus_next_session()
+{
+    focus_controller->focus_next_session();
+}
+
+void me::BasicWindowManager::set_focus_to(
+    std::shared_ptr<scene::Session> const& focus,
+    std::shared_ptr<scene::Surface> const& surface)
+{
+    focus_controller->set_focus_to(focus, surface);
+}
+
+auto me::BasicWindowManager::surface_at(geometry::Point cursor) const
+-> std::shared_ptr<scene::Surface>
+{
+    return focus_controller->surface_at(cursor);
+}
+
+auto me::BasicWindowManager::active_display()
+-> geometry::Rectangle const
+{
+    geometry::Rectangle result;
+
+    // 1. If a window has input focus, whichever display contains the largest
+    //    proportion of the area of that window.
+    if (auto const surface = focused_surface())
+    {
+        auto const surface_rect = surface->input_bounds();
+        int max_overlap_area = -1;
+
+        for (auto const& display : displays)
+        {
+            auto const intersection = surface_rect.intersection_with(display).size;
+            if (intersection.width.as_int()*intersection.height.as_int() > max_overlap_area)
+            {
+                max_overlap_area = intersection.width.as_int()*intersection.height.as_int();
+                result = display;
+            }
+        }
+        return result;
+    }
+
+    // 2. Otherwise, if any window previously had input focus, for the window that had
+    //    it most recently, the display that contained the largest proportion of the
+    //    area of that window at the moment it closed, as long as that display is still
+    //    available.
+
+    // 3. Otherwise, the display that contains the pointer, if there is one.
+    for (auto const& display : displays)
+    {
+        if (display.contains(cursor))
+        {
+            // Ignore the (unspecified) possiblity of overlapping displays
+            return display;
+        }
+    }
+
+    // 4. Otherwise, the primary display, if there is one (for example, the laptop display).
+
+    // 5. Otherwise, the first display.
+    if (displays.size())
+        result = *displays.begin();
+
+    return result;
+}
+
+void me::BasicWindowManager::raise_tree(std::shared_ptr<scene::Surface> const& root)
+{
+    SurfaceSet surfaces;
+    std::function<void(std::weak_ptr<scene::Surface> const& surface)> const add_children =
+        [&,this](std::weak_ptr<scene::Surface> const& surface)
+            {
+            auto const& info = info_for(surface);
+            surfaces.insert(begin(info.children), end(info.children));
+            for (auto const& child : info.children)
+                add_children(child);
+            };
+
+    surfaces.insert(root);
+    add_children(root);
+
+    focus_controller->raise(surfaces);
+}
+
+void me::BasicWindowManager::update_event_timestamp(MirKeyboardEvent const* kev)
+{
+    auto iev = mir_keyboard_event_input_event(kev);
+    last_input_event_timestamp = mir_input_event_get_event_time(iev);
+}
+
+void me::BasicWindowManager::update_event_timestamp(MirPointerEvent const* pev)
+{
+    auto iev = mir_pointer_event_input_event(pev);
+    auto pointer_action = mir_pointer_event_action(pev);
+
+    if (pointer_action == mir_pointer_action_button_up ||
+        pointer_action == mir_pointer_action_button_down)
+    {
+        last_input_event_timestamp = mir_input_event_get_event_time(iev);
+    }
+}
+
+void me::BasicWindowManager::update_event_timestamp(MirTouchEvent const* tev)
+{
+    auto iev = mir_touch_event_input_event(tev);
+    auto touch_count = mir_touch_event_point_count(tev);
+    for (unsigned i = 0; i < touch_count; i++)
+    {
+        auto touch_action = mir_touch_event_action(tev, i);
+        if (touch_action == mir_touch_action_up ||
+            touch_action == mir_touch_action_down)
+        {
+            last_input_event_timestamp = mir_input_event_get_event_time(iev);
+            break;
+        }
+    }
+}

=== added file 'src/platforms/mirserver/wm-wip/server_example_basic_window_manager.h'
--- src/platforms/mirserver/wm-wip/server_example_basic_window_manager.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_basic_window_manager.h	2016-03-11 11:36:44 +0000
@@ -0,0 +1,252 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * 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 MIR_EXAMPLE_BASIC_WINDOW_MANAGER_H_
+#define MIR_EXAMPLE_BASIC_WINDOW_MANAGER_H_
+
+#include "server_example_window_management_info.h"
+
+#include "mir/geometry/rectangles.h"
+#include "mir/shell/abstract_shell.h"
+#include "mir/shell/window_manager.h"
+
+#include <map>
+#include <mutex>
+
+///\example server_example_basic_window_manager.h
+/// A generic policy-based window manager implementation
+
+namespace mir
+{
+namespace examples
+{
+using shell::SurfaceSet;
+
+/// The interface through which the policy instructs the controller.
+/// These functions assume that the BasicWindowManager data structures can be accessed freely.
+/// I.e. should only be invoked by the policy handle_... methods (where any necessary locks are held).
+class WindowManagerTools
+{
+public:
+    using SurfaceInfoMap = std::map<std::weak_ptr<scene::Surface>, SurfaceInfo, std::owner_less<std::weak_ptr<scene::Surface>>>;
+    using SessionInfoMap = std::map<std::weak_ptr<scene::Session>, SessionInfo, std::owner_less<std::weak_ptr<scene::Session>>>;
+
+    virtual auto find_session(std::function<bool(SessionInfo const& info)> const& predicate)
+    -> std::shared_ptr<scene::Session> = 0;
+
+    virtual auto info_for(std::weak_ptr<scene::Session> const& session) const -> SessionInfo& = 0;
+
+    virtual auto info_for(std::weak_ptr<scene::Surface> const& surface) const -> SurfaceInfo& = 0;
+
+    virtual std::shared_ptr<scene::Session> focused_session() const = 0;
+
+    virtual std::shared_ptr<scene::Surface> focused_surface() const = 0;
+
+    virtual void focus_next_session() = 0;
+
+    virtual void set_focus_to(
+        std::shared_ptr<scene::Session> const& focus,
+        std::shared_ptr<scene::Surface> const& surface) = 0;
+
+    virtual auto surface_at(geometry::Point cursor) const -> std::shared_ptr<scene::Surface> = 0;
+
+    virtual auto active_display() -> geometry::Rectangle const = 0;
+
+    virtual void forget(std::weak_ptr<scene::Surface> const& surface) = 0;
+
+    virtual void raise_tree(std::shared_ptr<scene::Surface> const& root) = 0;
+
+    virtual ~WindowManagerTools() = default;
+    WindowManagerTools() = default;
+    WindowManagerTools(WindowManagerTools const&) = delete;
+    WindowManagerTools& operator=(WindowManagerTools const&) = delete;
+};
+
+class WindowManagementPolicy
+{
+public:
+    using SessionInfoMap = typename WindowManagerTools::SessionInfoMap;
+    using SurfaceInfoMap = typename WindowManagerTools::SurfaceInfoMap;
+
+    virtual void handle_session_info_updated(SessionInfoMap& session_info, geometry::Rectangles const& displays) = 0;
+
+    virtual void handle_displays_updated(SessionInfoMap& session_info, geometry::Rectangles const& displays) = 0;
+
+    virtual auto handle_place_new_surface(
+        std::shared_ptr<scene::Session> const& session,
+        scene::SurfaceCreationParameters const& request_parameters)
+        -> scene::SurfaceCreationParameters = 0;
+
+    virtual void handle_new_surface(std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface) = 0;
+
+    virtual void handle_modify_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface,
+        shell::SurfaceSpecification const& modifications) = 0;
+
+    virtual void handle_delete_surface(std::shared_ptr<scene::Session> const& session, std::weak_ptr<scene::Surface> const& surface) = 0;
+
+    virtual int handle_set_state(std::shared_ptr<scene::Surface> const& surface, MirSurfaceState value) = 0;
+
+    virtual void generate_decorations_for(
+        std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface,
+        SurfaceInfoMap& surface_info,
+        std::function<frontend::SurfaceId(std::shared_ptr<scene::Session> const&, scene::SurfaceCreationParameters const&)> const& build) = 0;
+
+    virtual bool handle_keyboard_event(MirKeyboardEvent const* event) = 0;
+
+    virtual bool handle_touch_event(MirTouchEvent const* event) = 0;
+
+    virtual bool handle_pointer_event(MirPointerEvent const* event) = 0;
+
+    virtual void handle_raise_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface) = 0;
+
+    virtual ~WindowManagementPolicy() = default;
+    WindowManagementPolicy() = default;
+    WindowManagementPolicy(WindowManagementPolicy const&) = delete;
+    WindowManagementPolicy& operator=(WindowManagementPolicy const&) = delete;
+};
+
+/// A policy based window manager.
+/// This takes care of the management of any meta implementation held for the sessions and surfaces.
+class BasicWindowManager : public virtual shell::WindowManager,
+    protected WindowManagerTools
+{
+protected:
+    BasicWindowManager(
+        shell::FocusController* focus_controller,
+        std::unique_ptr<WindowManagementPolicy> policy);
+
+public:
+    using typename WindowManagerTools::SurfaceInfoMap;
+    using typename WindowManagerTools::SessionInfoMap;
+
+    void add_session(std::shared_ptr<scene::Session> const& session) override;
+
+    void remove_session(std::shared_ptr<scene::Session> const& session) override;
+
+    auto add_surface(
+        std::shared_ptr<scene::Session> const& session,
+        scene::SurfaceCreationParameters const& params,
+        std::function<frontend::SurfaceId(std::shared_ptr<scene::Session> const& session, scene::SurfaceCreationParameters const& params)> const& build)
+    -> frontend::SurfaceId override;
+
+    void modify_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface,
+        shell::SurfaceSpecification const& modifications) override;
+
+    void remove_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::weak_ptr<scene::Surface> const& surface) override;
+
+    void forget(std::weak_ptr<scene::Surface> const& surface) override;
+
+    void add_display(geometry::Rectangle const& area) override;
+
+    void remove_display(geometry::Rectangle const& area) override;
+
+    bool handle_keyboard_event(MirKeyboardEvent const* event) override;
+
+    bool handle_touch_event(MirTouchEvent const* event) override;
+
+    bool handle_pointer_event(MirPointerEvent const* event) override;
+
+    void handle_raise_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface,
+        uint64_t timestamp) override;
+
+    int set_surface_attribute(
+        std::shared_ptr<scene::Session> const& /*session*/,
+        std::shared_ptr<scene::Surface> const& surface,
+        MirSurfaceAttrib attrib,
+        int value) override;
+
+    auto find_session(std::function<bool(SessionInfo const& info)> const& predicate)
+    -> std::shared_ptr<scene::Session> override;
+
+    auto info_for(std::weak_ptr<scene::Session> const& session) const -> SessionInfo& override;
+
+    auto info_for(std::weak_ptr<scene::Surface> const& surface) const -> SurfaceInfo& override;
+
+    std::shared_ptr<scene::Session> focused_session() const override;
+
+    std::shared_ptr<scene::Surface> focused_surface() const override;
+
+    void focus_next_session() override;
+
+    void set_focus_to(
+        std::shared_ptr<scene::Session> const& focus,
+        std::shared_ptr<scene::Surface> const& surface) override;
+
+    auto surface_at(geometry::Point cursor) const -> std::shared_ptr<scene::Surface> override;
+
+    auto active_display() -> geometry::Rectangle const override;
+
+    void raise_tree(std::shared_ptr<scene::Surface> const& root) override;
+
+private:
+    shell::FocusController* const focus_controller;
+    std::unique_ptr<WindowManagementPolicy> const policy;
+
+    std::mutex mutex;
+    SessionInfoMap session_info;
+    SurfaceInfoMap surface_info;
+    geometry::Rectangles displays;
+    geometry::Point cursor;
+    uint64_t last_input_event_timestamp{0};
+
+    void update_event_timestamp(MirKeyboardEvent const* kev);
+    void update_event_timestamp(MirPointerEvent const* pev);
+    void update_event_timestamp(MirTouchEvent const* tev);
+};
+
+/// A policy based window manager. This exists to initialize BasicWindowManager and
+/// the WMPolicy (in an awkward manner).
+/// TODO revisit this initialization sequence.
+template<typename WMPolicy>
+class WindowManagerBuilder : public BasicWindowManager
+{
+public:
+
+    template <typename... PolicyArgs>
+    WindowManagerBuilder(
+        shell::FocusController* focus_controller,
+        PolicyArgs&&... policy_args) :
+        BasicWindowManager(
+            focus_controller,
+            build_policy(std::forward<PolicyArgs>(policy_args)...))
+    {
+    }
+
+private:
+    template <typename... PolicyArgs>
+    auto build_policy(PolicyArgs&&... policy_args)
+    -> std::unique_ptr<WMPolicy>
+    {
+        return std::unique_ptr<WMPolicy>(
+            new WMPolicy(this, std::forward<PolicyArgs>(policy_args)...));
+    }
+};
+}
+}
+
+#endif /* MIR_EXAMPLE_BASIC_WINDOW_MANAGER_H_ */

=== added file 'src/platforms/mirserver/wm-wip/server_example_canonical_window_manager.cpp'
--- src/platforms/mirserver/wm-wip/server_example_canonical_window_manager.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_canonical_window_manager.cpp	2016-03-11 11:36:44 +0000
@@ -0,0 +1,946 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * 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 "server_example_canonical_window_manager.h"
+
+#include "mir/scene/session.h"
+#include "mir/scene/surface.h"
+#include "mir/scene/surface_creation_parameters.h"
+#include "mir/shell/surface_ready_observer.h"
+#include "mir/shell/display_layout.h"
+
+#include <linux/input.h>
+#include <csignal>
+#include <algorithm>
+
+namespace me = mir::examples;
+namespace ms = mir::scene;
+using namespace mir::geometry;
+
+///\example server_example_canonical_window_manager.cpp
+// Based on "Mir and Unity: Surfaces, input, and displays (v0.3)"
+
+namespace
+{
+int const title_bar_height = 10;
+Size titlebar_size_for_window(Size window_size)
+{
+    return {window_size.width, Height{title_bar_height}};
+}
+
+Point titlebar_position_for_window(Point window_position)
+{
+    return {
+        window_position.x,
+        window_position.y - DeltaY(title_bar_height)
+    };
+}
+}
+
+me::CanonicalWindowManagerPolicyCopy::CanonicalWindowManagerPolicyCopy(
+    WindowManagerTools* const tools,
+    std::shared_ptr<shell::DisplayLayout> const& display_layout) :
+    tools{tools},
+    display_layout{display_layout}
+{
+}
+
+void me::CanonicalWindowManagerPolicyCopy::click(Point cursor)
+{
+    if (auto const surface = tools->surface_at(cursor))
+        select_active_surface(surface);
+}
+
+void me::CanonicalWindowManagerPolicyCopy::handle_session_info_updated(SessionInfoMap& /*session_info*/, Rectangles const& /*displays*/)
+{
+}
+
+void me::CanonicalWindowManagerPolicyCopy::handle_displays_updated(SessionInfoMap& /*session_info*/, Rectangles const& displays)
+{
+    display_area = displays.bounding_rectangle();
+
+    for (auto const weak_surface : fullscreen_surfaces)
+    {
+        if (auto const surface = weak_surface.lock())
+        {
+            auto const& info = tools->info_for(weak_surface);
+            Rectangle rect{surface->top_left(), surface->size()};
+
+            display_layout->place_in_output(info.output_id.value(), rect);
+            surface->move_to(rect.top_left);
+            surface->resize(rect.size);
+        }
+    }
+}
+
+void me::CanonicalWindowManagerPolicyCopy::resize(Point cursor)
+{
+    select_active_surface(tools->surface_at(old_cursor));
+    resize(active_surface(), cursor, old_cursor, display_area);
+}
+
+auto me::CanonicalWindowManagerPolicyCopy::handle_place_new_surface(
+    std::shared_ptr<ms::Session> const& session,
+    ms::SurfaceCreationParameters const& request_parameters)
+-> ms::SurfaceCreationParameters
+{
+    auto parameters = request_parameters;
+    auto surf_type = parameters.type.is_set() ? parameters.type.value() : mir_surface_type_normal;
+    bool const needs_titlebar = SurfaceInfo::needs_titlebar(surf_type);
+
+    if (needs_titlebar)
+        parameters.size.height = parameters.size.height + DeltaY{title_bar_height};
+
+    if (!parameters.state.is_set())
+        parameters.state = mir_surface_state_restored;
+
+    auto const active_display = tools->active_display();
+
+    auto const width = parameters.size.width.as_int();
+    auto const height = parameters.size.height.as_int();
+
+    bool positioned = false;
+
+    auto const parent = parameters.parent.lock();
+
+    if (parameters.output_id != mir::graphics::DisplayConfigurationOutputId{0})
+    {
+        Rectangle rect{parameters.top_left, parameters.size};
+        display_layout->place_in_output(parameters.output_id, rect);
+        parameters.top_left = rect.top_left;
+        parameters.size = rect.size;
+        parameters.state = mir_surface_state_fullscreen;
+        positioned = true;
+    }
+    else if (!parent) // No parent => client can't suggest positioning
+    {
+        if (auto const default_surface = session->default_surface())
+        {
+            static Displacement const offset{title_bar_height, title_bar_height};
+
+            parameters.top_left = default_surface->top_left() + offset;
+
+            geometry::Rectangle display_for_app{default_surface->top_left(), default_surface->size()};
+
+            display_layout->size_to_output(display_for_app);
+
+            positioned = display_for_app.overlaps(Rectangle{parameters.top_left, parameters.size});
+        }
+    }
+
+    if (parent && parameters.aux_rect.is_set() && parameters.edge_attachment.is_set())
+    {
+        auto const edge_attachment = parameters.edge_attachment.value();
+        auto const aux_rect = parameters.aux_rect.value();
+        auto const parent_top_left = parent->top_left();
+        auto const top_left = aux_rect.top_left     -Point{} + parent_top_left;
+        auto const top_right= aux_rect.top_right()  -Point{} + parent_top_left;
+        auto const bot_left = aux_rect.bottom_left()-Point{} + parent_top_left;
+
+        if (edge_attachment & mir_edge_attachment_vertical)
+        {
+            if (active_display.contains(top_right + Displacement{width, height}))
+            {
+                parameters.top_left = top_right;
+                positioned = true;
+            }
+            else if (active_display.contains(top_left + Displacement{-width, height}))
+            {
+                parameters.top_left = top_left + Displacement{-width, 0};
+                positioned = true;
+            }
+        }
+
+        if (edge_attachment & mir_edge_attachment_horizontal)
+        {
+            if (active_display.contains(bot_left + Displacement{width, height}))
+            {
+                parameters.top_left = bot_left;
+                positioned = true;
+            }
+            else if (active_display.contains(top_left + Displacement{width, -height}))
+            {
+                parameters.top_left = top_left + Displacement{0, -height};
+                positioned = true;
+            }
+        }
+    }
+    else if (parent)
+    {
+        //  o Otherwise, if the dialog is not the same as any previous dialog for the
+        //    same parent window, and/or it does not have user-customized position:
+        //      o It should be optically centered relative to its parent, unless this
+        //        would overlap or cover the title bar of the parent.
+        //      o Otherwise, it should be cascaded vertically (but not horizontally)
+        //        relative to its parent, unless, this would cause at least part of
+        //        it to extend into shell space.
+        auto const parent_top_left = parent->top_left();
+        auto const centred = parent_top_left
+             + 0.5*(as_displacement(parent->size()) - as_displacement(parameters.size))
+             - DeltaY{(parent->size().height.as_int()-height)/6};
+
+        parameters.top_left = centred;
+        positioned = true;
+    }
+
+    if (!positioned)
+    {
+        auto const centred = active_display.top_left
+            + 0.5*(as_displacement(active_display.size) - as_displacement(parameters.size))
+            - DeltaY{(active_display.size.height.as_int()-height)/6};
+
+        switch (parameters.state.value())
+        {
+        case mir_surface_state_fullscreen:
+        case mir_surface_state_maximized:
+            parameters.top_left = active_display.top_left;
+            parameters.size = active_display.size;
+            break;
+
+        case mir_surface_state_vertmaximized:
+            parameters.top_left = centred;
+            parameters.top_left.y = active_display.top_left.y;
+            parameters.size.height = active_display.size.height;
+            break;
+
+        case mir_surface_state_horizmaximized:
+            parameters.top_left = centred;
+            parameters.top_left.x = active_display.top_left.x;
+            parameters.size.width = active_display.size.width;
+            break;
+
+        default:
+            parameters.top_left = centred;
+        }
+
+        if (parameters.top_left.y < display_area.top_left.y)
+            parameters.top_left.y = display_area.top_left.y;
+    }
+
+    if (parameters.state != mir_surface_state_fullscreen && needs_titlebar)
+    {
+        parameters.top_left.y = parameters.top_left.y + DeltaY{title_bar_height};
+        parameters.size.height = parameters.size.height - DeltaY{title_bar_height};
+    }
+
+    return parameters;
+}
+
+void me::CanonicalWindowManagerPolicyCopy::generate_decorations_for(
+    std::shared_ptr<scene::Session> const& session,
+    std::shared_ptr<scene::Surface> const& surface,
+    SurfaceInfoMap& surface_map,
+    std::function<frontend::SurfaceId(std::shared_ptr<scene::Session> const& session, scene::SurfaceCreationParameters const& params)> const& build)
+{
+    if (!SurfaceInfo::needs_titlebar(surface->type()))
+        return;
+
+    auto format = mir_pixel_format_xrgb_8888;
+    ms::SurfaceCreationParameters params;
+    params.of_size(titlebar_size_for_window(surface->size()))
+        .of_name("decoration")
+        .of_pixel_format(format)
+        .of_buffer_usage(mir::graphics::BufferUsage::software)
+        .of_position(titlebar_position_for_window(surface->top_left()))
+        .of_type(mir_surface_type_gloss);
+    auto id = build(session, params);
+    auto titlebar = session->surface(id);
+    titlebar->set_alpha(0.9);
+
+    auto& surface_info = tools->info_for(surface);
+    surface_info.titlebar = titlebar;
+    surface_info.titlebar_id = id;
+    surface_info.children.push_back(titlebar);
+
+    SurfaceInfo& titlebar_info =
+            surface_map.emplace(titlebar, SurfaceInfo{session, titlebar, {}}).first->second;
+    titlebar_info.is_titlebar = true;
+    titlebar_info.parent = surface;
+    titlebar_info.init_titlebar(titlebar);
+}
+
+void me::CanonicalWindowManagerPolicyCopy::handle_new_surface(std::shared_ptr<ms::Session> const& session, std::shared_ptr<ms::Surface> const& surface)
+{
+    auto& surface_info = tools->info_for(surface);
+    if (auto const parent = surface_info.parent.lock())
+    {
+        tools->info_for(parent).children.push_back(surface);
+    }
+
+    tools->info_for(session).surfaces.push_back(surface);
+
+    if (surface_info.can_be_active())
+    {
+        surface->add_observer(std::make_shared<shell::SurfaceReadyObserver>(
+            [this](std::shared_ptr<scene::Session> const& /*session*/,
+                   std::shared_ptr<scene::Surface> const& surface)
+                {
+                    select_active_surface(surface);
+                },
+            session,
+            surface));
+    }
+
+    if (surface_info.state == mir_surface_state_fullscreen)
+        fullscreen_surfaces.insert(surface);
+}
+
+void me::CanonicalWindowManagerPolicyCopy::handle_modify_surface(
+    std::shared_ptr<scene::Session> const& session,
+    std::shared_ptr<scene::Surface> const& surface,
+    shell::SurfaceSpecification const& modifications)
+{
+    auto& surface_info_old = tools->info_for(surface);
+
+    auto surface_info = surface_info_old;
+
+    if (modifications.parent.is_set())
+        surface_info.parent = modifications.parent.value();
+
+    if (modifications.type.is_set() &&
+        surface_info.type != modifications.type.value())
+    {
+        auto const new_type = modifications.type.value();
+
+        if (!surface_info.can_morph_to(new_type))
+        {
+            throw std::runtime_error("Unsupported surface type change");
+        }
+
+        surface_info.type = new_type;
+
+        if (surface_info.must_not_have_parent())
+        {
+            if (modifications.parent.is_set())
+                throw std::runtime_error("Target surface type does not support parent");
+
+            surface_info.parent.reset();
+        }
+        else if (surface_info.must_have_parent())
+        {
+            if (!surface_info.parent.lock())
+                throw std::runtime_error("Target surface type requires parent");
+        }
+
+        surface->configure(mir_surface_attrib_type, new_type);
+    }
+
+    #define COPY_IF_SET(field)\
+        if (modifications.field.is_set())\
+            surface_info.field = modifications.field.value()
+
+    COPY_IF_SET(min_width);
+    COPY_IF_SET(min_height);
+    COPY_IF_SET(max_width);
+    COPY_IF_SET(max_height);
+    COPY_IF_SET(min_width);
+    COPY_IF_SET(width_inc);
+    COPY_IF_SET(height_inc);
+    COPY_IF_SET(min_aspect);
+    COPY_IF_SET(max_aspect);
+    COPY_IF_SET(output_id);
+
+    #undef COPY_IF_SET
+
+    std::swap(surface_info, surface_info_old);
+
+    if (modifications.name.is_set())
+        surface->rename(modifications.name.value());
+
+    if (modifications.streams.is_set())
+    {
+        auto v = modifications.streams.value();
+        std::vector<shell::StreamSpecification> l (v.begin(), v.end());
+        session->configure_streams(*surface, l);
+    }
+
+    if (modifications.input_shape.is_set())
+    {
+        surface->set_input_region(modifications.input_shape.value());
+    }
+
+    if (modifications.width.is_set() || modifications.height.is_set())
+    {
+        auto new_size = surface->size();
+
+        if (modifications.width.is_set())
+            new_size.width = modifications.width.value();
+
+        if (modifications.height.is_set())
+            new_size.height = modifications.height.value();
+
+        auto top_left = surface->top_left();
+
+        surface_info.constrain_resize(
+            surface,
+            top_left,
+            new_size,
+            false,
+            false,
+            display_area);
+
+        apply_resize(surface, surface_info.titlebar, top_left, new_size);
+    }
+
+    if (modifications.state.is_set())
+    {
+        auto const state = handle_set_state(surface, modifications.state.value());
+        surface->configure(mir_surface_attrib_state, state);
+    }
+}
+
+void me::CanonicalWindowManagerPolicyCopy::handle_delete_surface(std::shared_ptr<ms::Session> const& session, std::weak_ptr<ms::Surface> const& surface)
+{
+    fullscreen_surfaces.erase(surface);
+
+    auto& info = tools->info_for(surface);
+
+    if (auto const parent = info.parent.lock())
+    {
+        auto& siblings = tools->info_for(parent).children;
+
+        for (auto i = begin(siblings); i != end(siblings); ++i)
+        {
+            if (surface.lock() == i->lock())
+            {
+                siblings.erase(i);
+                break;
+            }
+        }
+    }
+
+    session->destroy_surface(surface);
+    if (info.titlebar)
+    {
+        session->destroy_surface(info.titlebar_id);
+        tools->forget(info.titlebar);
+    }
+
+    auto& surfaces = tools->info_for(session).surfaces;
+
+    for (auto i = begin(surfaces); i != end(surfaces); ++i)
+    {
+        if (surface.lock() == i->lock())
+        {
+            surfaces.erase(i);
+            break;
+        }
+    }
+
+    if (surfaces.empty() && session == tools->focused_session())
+    {
+        active_surface_.reset();
+        tools->focus_next_session();
+        select_active_surface(tools->focused_surface());
+    }
+}
+
+int me::CanonicalWindowManagerPolicyCopy::handle_set_state(std::shared_ptr<ms::Surface> const& surface, MirSurfaceState value)
+{
+    auto& info = tools->info_for(surface);
+
+    switch (value)
+    {
+    case mir_surface_state_restored:
+    case mir_surface_state_maximized:
+    case mir_surface_state_vertmaximized:
+    case mir_surface_state_horizmaximized:
+    case mir_surface_state_fullscreen:
+    case mir_surface_state_hidden:
+    case mir_surface_state_minimized:
+        break;
+
+    default:
+        return info.state;
+    }
+
+    if (info.state == mir_surface_state_restored)
+    {
+        info.restore_rect = {surface->top_left(), surface->size()};
+    }
+
+    if (info.state != mir_surface_state_fullscreen)
+    {
+        info.output_id = decltype(info.output_id){};
+        fullscreen_surfaces.erase(surface);
+    }
+    else
+    {
+        fullscreen_surfaces.insert(surface);
+    }
+
+    if (info.state == value)
+    {
+        return info.state;
+    }
+
+    auto const old_pos = surface->top_left();
+    Displacement movement;
+
+    switch (value)
+    {
+    case mir_surface_state_restored:
+        movement = info.restore_rect.top_left - old_pos;
+        surface->resize(info.restore_rect.size);
+        if (info.titlebar)
+        {
+            info.titlebar->resize(titlebar_size_for_window(info.restore_rect.size));
+            info.titlebar->show();
+        }
+        break;
+
+    case mir_surface_state_maximized:
+        movement = display_area.top_left - old_pos;
+        surface->resize(display_area.size);
+        if (info.titlebar)
+            info.titlebar->hide();
+        break;
+
+    case mir_surface_state_horizmaximized:
+        movement = Point{display_area.top_left.x, info.restore_rect.top_left.y} - old_pos;
+        surface->resize({display_area.size.width, info.restore_rect.size.height});
+        if (info.titlebar)
+        {
+            info.titlebar->resize(titlebar_size_for_window({display_area.size.width, info.restore_rect.size.height}));
+            info.titlebar->show();
+        }
+        break;
+
+    case mir_surface_state_vertmaximized:
+        movement = Point{info.restore_rect.top_left.x, display_area.top_left.y} - old_pos;
+        surface->resize({info.restore_rect.size.width, display_area.size.height});
+        if (info.titlebar)
+            info.titlebar->hide();
+        break;
+
+    case mir_surface_state_fullscreen:
+    {
+        Rectangle rect{old_pos, surface->size()};
+
+        if (info.output_id.is_set())
+        {
+            display_layout->place_in_output(info.output_id.value(), rect);
+        }
+        else
+        {
+            display_layout->size_to_output(rect);
+        }
+
+        movement = rect.top_left - old_pos;
+        surface->resize(rect.size);
+        break;
+    }
+
+    case mir_surface_state_hidden:
+    case mir_surface_state_minimized:
+        if (info.titlebar)
+            info.titlebar->hide();
+        surface->hide();
+        return info.state = value;
+
+    default:
+        break;
+    }
+
+    // TODO It is rather simplistic to move a tree WRT the top_left of the root
+    // TODO when resizing. But for more sophistication we would need to encode
+    // TODO some sensible layout rules.
+    move_tree(surface, movement);
+
+    info.state = value;
+
+    if (info.is_visible())
+        surface->show();
+
+    return info.state;
+}
+
+void me::CanonicalWindowManagerPolicyCopy::drag(Point cursor)
+{
+    select_active_surface(tools->surface_at(old_cursor));
+    drag(active_surface(), cursor, old_cursor, display_area);
+}
+
+void me::CanonicalWindowManagerPolicyCopy::handle_raise_surface(
+    std::shared_ptr<ms::Session> const& /*session*/,
+    std::shared_ptr<ms::Surface> const& surface)
+{
+    select_active_surface(surface);
+}
+
+bool me::CanonicalWindowManagerPolicyCopy::handle_keyboard_event(MirKeyboardEvent const* event)
+{
+    auto const action = mir_keyboard_event_action(event);
+    auto const scan_code = mir_keyboard_event_scan_code(event);
+    auto const modifiers = mir_keyboard_event_modifiers(event) & modifier_mask;
+
+    if (action == mir_keyboard_action_down && scan_code == KEY_F11)
+    {
+        switch (modifiers)
+        {
+        case mir_input_event_modifier_alt:
+            toggle(mir_surface_state_maximized);
+            return true;
+
+        case mir_input_event_modifier_shift:
+            toggle(mir_surface_state_vertmaximized);
+            return true;
+
+        case mir_input_event_modifier_ctrl:
+            toggle(mir_surface_state_horizmaximized);
+            return true;
+
+        default:
+            break;
+        }
+    }
+    else if (action == mir_keyboard_action_down && scan_code == KEY_F4)
+    {
+        if (auto const session = tools->focused_session())
+        {
+            switch (modifiers)
+            {
+            case mir_input_event_modifier_alt:
+                kill(session->process_id(), SIGTERM);
+                return true;
+
+            case mir_input_event_modifier_ctrl:
+                if (auto const surf = session->default_surface())
+                {
+                    surf->request_client_surface_close();
+                    return true;
+                }
+
+            default:
+                break;
+            }
+        }
+    }
+    else if (action == mir_keyboard_action_down &&
+            modifiers == mir_input_event_modifier_alt &&
+            scan_code == KEY_TAB)
+    {
+        tools->focus_next_session();
+        if (auto const surface = tools->focused_surface())
+            select_active_surface(surface);
+
+        return true;
+    }
+    else if (action == mir_keyboard_action_down &&
+            modifiers == mir_input_event_modifier_alt &&
+            scan_code == KEY_GRAVE)
+    {
+        if (auto const prev = tools->focused_surface())
+        {
+            if (auto const app = tools->focused_session())
+                select_active_surface(app->surface_after(prev));
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+bool me::CanonicalWindowManagerPolicyCopy::handle_touch_event(MirTouchEvent const* event)
+{
+    auto const count = mir_touch_event_point_count(event);
+
+    long total_x = 0;
+    long total_y = 0;
+
+    for (auto i = 0U; i != count; ++i)
+    {
+        total_x += mir_touch_event_axis_value(event, i, mir_touch_axis_x);
+        total_y += mir_touch_event_axis_value(event, i, mir_touch_axis_y);
+    }
+
+    Point const cursor{total_x/count, total_y/count};
+
+    bool is_drag = true;
+    for (auto i = 0U; i != count; ++i)
+    {
+        switch (mir_touch_event_action(event, i))
+        {
+        case mir_touch_action_up:
+            return false;
+
+        case mir_touch_action_down:
+            is_drag = false;
+
+        case mir_touch_action_change:
+            continue;
+        }
+    }
+
+    bool consumes_event = false;
+    if (is_drag)
+    {
+        switch (count)
+        {
+        case 2:
+            resize(cursor);
+            consumes_event = true;
+            break;
+
+        case 3:
+            drag(cursor);
+            consumes_event = true;
+            break;
+        }
+    }
+
+    old_cursor = cursor;
+    return consumes_event;
+}
+
+bool me::CanonicalWindowManagerPolicyCopy::handle_pointer_event(MirPointerEvent const* event)
+{
+    auto const action = mir_pointer_event_action(event);
+    auto const modifiers = mir_pointer_event_modifiers(event) & modifier_mask;
+    Point const cursor{
+        mir_pointer_event_axis_value(event, mir_pointer_axis_x),
+        mir_pointer_event_axis_value(event, mir_pointer_axis_y)};
+
+    bool consumes_event = false;
+
+    if (action == mir_pointer_action_button_down)
+    {
+        click(cursor);
+    }
+    else if (action == mir_pointer_action_motion &&
+             modifiers == mir_input_event_modifier_alt)
+    {
+        if (mir_pointer_event_button_state(event, mir_pointer_button_primary))
+        {
+            drag(cursor);
+            consumes_event = true;
+        }
+
+        if (mir_pointer_event_button_state(event, mir_pointer_button_tertiary))
+        {
+            resize(cursor);
+            consumes_event = true;
+        }
+    }
+    else if (action == mir_pointer_action_motion && !modifiers)
+    {
+        if (mir_pointer_event_button_state(event, mir_pointer_button_primary))
+        {
+            if (auto const possible_titlebar = tools->surface_at(old_cursor))
+            {
+                if (tools->info_for(possible_titlebar).is_titlebar)
+                {
+                    drag(cursor);
+                    consumes_event = true;
+                }
+            }
+        }
+    }
+
+    old_cursor = cursor;
+    return consumes_event;
+}
+
+void me::CanonicalWindowManagerPolicyCopy::toggle(MirSurfaceState state)
+{
+    if (auto const surface = active_surface())
+    {
+        auto& info = tools->info_for(surface);
+
+        if (info.state == state)
+            state = mir_surface_state_restored;
+
+        auto const value = handle_set_state(surface, MirSurfaceState(state));
+        surface->configure(mir_surface_attrib_state, value);
+    }
+}
+
+void me::CanonicalWindowManagerPolicyCopy::select_active_surface(std::shared_ptr<ms::Surface> const& surface)
+{
+    if (surface == active_surface_.lock())
+        return;
+
+    if (!surface)
+    {
+        if (auto const active_surface = active_surface_.lock())
+        {
+            if (auto const titlebar = tools->info_for(active_surface).titlebar)
+            {
+                tools->info_for(titlebar).paint_titlebar(0x3F);
+            }
+        }
+
+        if (active_surface_.lock())
+            tools->set_focus_to({}, {});
+
+        active_surface_.reset();
+        return;
+    }
+
+    auto const& info_for = tools->info_for(surface);
+
+    if (info_for.can_be_active())
+    {
+        if (auto const active_surface = active_surface_.lock())
+        {
+            if (auto const titlebar = tools->info_for(active_surface).titlebar)
+            {
+                tools->info_for(titlebar).paint_titlebar(0x3F);
+            }
+        }
+        if (auto const titlebar = tools->info_for(surface).titlebar)
+        {
+            tools->info_for(titlebar).paint_titlebar(0xFF);
+        }
+        tools->set_focus_to(info_for.session.lock(), surface);
+        tools->raise_tree(surface);
+        active_surface_ = surface;
+    }
+    else
+    {
+        // Cannot have input focus - try the parent
+        if (auto const parent = info_for.parent.lock())
+            select_active_surface(parent);
+    }
+}
+
+auto me::CanonicalWindowManagerPolicyCopy::active_surface() const
+-> std::shared_ptr<ms::Surface>
+{
+    if (auto const surface = active_surface_.lock())
+        return surface;
+
+    if (auto const session = tools->focused_session())
+    {
+        if (auto const surface = session->default_surface())
+            return surface;
+    }
+
+    return std::shared_ptr<ms::Surface>{};
+}
+
+bool me::CanonicalWindowManagerPolicyCopy::resize(std::shared_ptr<ms::Surface> const& surface, Point cursor, Point old_cursor, Rectangle bounds)
+{
+    if (!surface || !surface->input_area_contains(old_cursor))
+        return false;
+
+    auto const top_left = surface->top_left();
+    Rectangle const old_pos{top_left, surface->size()};
+
+    auto anchor = top_left;
+
+    for (auto const& corner : {
+        old_pos.top_right(),
+        old_pos.bottom_left(),
+        old_pos.bottom_right()})
+    {
+        if ((old_cursor - anchor).length_squared() <
+            (old_cursor - corner).length_squared())
+        {
+            anchor = corner;
+        }
+    }
+
+    bool const left_resize = anchor.x != top_left.x;
+    bool const top_resize  = anchor.y != top_left.y;
+    int const x_sign = left_resize? -1 : 1;
+    int const y_sign = top_resize?  -1 : 1;
+
+    auto const delta = cursor-old_cursor;
+
+    Size new_size{old_pos.size.width + x_sign*delta.dx, old_pos.size.height + y_sign*delta.dy};
+
+    Point new_pos = top_left + left_resize*delta.dx + top_resize*delta.dy;
+
+
+    auto const& surface_info = tools->info_for(surface);
+
+    surface_info.constrain_resize(surface, new_pos, new_size, left_resize, top_resize, bounds);
+
+    apply_resize(surface, surface_info.titlebar, new_pos, new_size);
+
+    return true;
+}
+
+void me::CanonicalWindowManagerPolicyCopy::apply_resize(
+    std::shared_ptr<ms::Surface> const& surface,
+    std::shared_ptr<ms::Surface> const& titlebar,
+    Point const& new_pos,
+    Size const& new_size) const
+{
+    if (titlebar)
+        titlebar->resize({new_size.width, Height{title_bar_height}});
+
+    surface->resize(new_size);
+
+    move_tree(surface, new_pos-surface->top_left());
+}
+
+bool me::CanonicalWindowManagerPolicyCopy::drag(std::shared_ptr<ms::Surface> surface, Point to, Point from, Rectangle /*bounds*/)
+{
+    if (!surface)
+        return false;
+
+    if (!surface->input_area_contains(from) && !tools->info_for(surface).titlebar)
+        return false;
+
+    auto movement = to - from;
+
+    // placeholder - constrain onscreen
+
+    switch (tools->info_for(surface).state)
+    {
+    case mir_surface_state_restored:
+        break;
+
+    // "A vertically maximised surface is anchored to the top and bottom of
+    // the available workspace and can have any width."
+    case mir_surface_state_vertmaximized:
+        movement.dy = DeltaY(0);
+        break;
+
+    // "A horizontally maximised surface is anchored to the left and right of
+    // the available workspace and can have any height"
+    case mir_surface_state_horizmaximized:
+        movement.dx = DeltaX(0);
+        break;
+
+    // "A maximised surface is anchored to the top, bottom, left and right of the
+    // available workspace. For example, if the launcher is always-visible then
+    // the left-edge of the surface is anchored to the right-edge of the launcher."
+    case mir_surface_state_maximized:
+    case mir_surface_state_fullscreen:
+    default:
+        return true;
+    }
+
+    move_tree(surface, movement);
+
+    return true;
+}
+
+void me::CanonicalWindowManagerPolicyCopy::move_tree(std::shared_ptr<ms::Surface> const& root, Displacement movement) const
+{
+    root->move_to(root->top_left() + movement);
+
+    for (auto const& child: tools->info_for(root).children)
+    {
+        move_tree(child.lock(), movement);
+    }
+}

=== added file 'src/platforms/mirserver/wm-wip/server_example_canonical_window_manager.h'
--- src/platforms/mirserver/wm-wip/server_example_canonical_window_manager.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_canonical_window_manager.h	2016-03-11 11:36:44 +0000
@@ -0,0 +1,132 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * 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 MIR_EXAMPLE_CANONICAL_WINDOW_MANAGER_H_
+#define MIR_EXAMPLE_CANONICAL_WINDOW_MANAGER_H_
+
+#include "server_example_basic_window_manager.h"
+
+#include "mir/geometry/displacement.h"
+
+#include <atomic>
+#include <set>
+
+///\example server_example_canonical_window_manager.h
+// Based on "Mir and Unity: Surfaces, input, and displays (v0.3)"
+
+namespace mir
+{
+namespace shell { class DisplayLayout; }
+namespace examples
+{
+// standard window management algorithm:
+//  o Switch apps: tap or click on the corresponding tile
+//  o Move window: Alt-leftmousebutton drag (three finger drag)
+//  o Resize window: Alt-middle_button drag (two finger drag)
+//  o Maximize/restore current window (to display size): Alt-F11
+//  o Maximize/restore current window (to display height): Shift-F11
+//  o Maximize/restore current window (to display width): Ctrl-F11
+//  o client requests to maximize, vertically maximize & restore
+class CanonicalWindowManagerPolicyCopy  : public WindowManagementPolicy
+{
+public:
+
+    explicit CanonicalWindowManagerPolicyCopy(
+        WindowManagerTools* const tools,
+        std::shared_ptr<shell::DisplayLayout> const& display_layout);
+
+    void click(geometry::Point cursor);
+
+    void handle_session_info_updated(SessionInfoMap& session_info, geometry::Rectangles const& displays);
+
+    void handle_displays_updated(SessionInfoMap& session_info, geometry::Rectangles const& displays);
+
+    void resize(geometry::Point cursor);
+
+    auto handle_place_new_surface(
+        std::shared_ptr<scene::Session> const& session,
+        scene::SurfaceCreationParameters const& request_parameters)
+    -> scene::SurfaceCreationParameters;
+
+    void handle_new_surface(std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface);
+
+    void handle_modify_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface,
+        shell::SurfaceSpecification const& modifications);
+
+    void handle_delete_surface(std::shared_ptr<scene::Session> const& session, std::weak_ptr<scene::Surface> const& surface);
+
+    int handle_set_state(std::shared_ptr<scene::Surface> const& surface, MirSurfaceState value);
+
+    void drag(geometry::Point cursor);
+
+    bool handle_keyboard_event(MirKeyboardEvent const* event);
+
+    bool handle_touch_event(MirTouchEvent const* event);
+
+    bool handle_pointer_event(MirPointerEvent const* event);
+
+    void handle_raise_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface);
+
+    void generate_decorations_for(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface,
+        SurfaceInfoMap& surface_map,
+        std::function<frontend::SurfaceId(std::shared_ptr<scene::Session> const& session, scene::SurfaceCreationParameters const& params)> const& build);
+
+private:
+    static const int modifier_mask =
+        mir_input_event_modifier_alt |
+        mir_input_event_modifier_shift |
+        mir_input_event_modifier_sym |
+        mir_input_event_modifier_ctrl |
+        mir_input_event_modifier_meta;
+
+    void toggle(MirSurfaceState state);
+
+    // "Mir and Unity: Surfaces, input, and displays (v0.3)" talks about active
+    //  *window*,but Mir really only understands surfaces
+    void select_active_surface(std::shared_ptr<scene::Surface> const& surface);
+    auto active_surface() const -> std::shared_ptr<scene::Surface>;
+
+    bool resize(std::shared_ptr<scene::Surface> const& surface, geometry::Point cursor, geometry::Point old_cursor, geometry::Rectangle bounds);
+    bool drag(std::shared_ptr<scene::Surface> surface, geometry::Point to, geometry::Point from, geometry::Rectangle bounds);
+    void move_tree(std::shared_ptr<scene::Surface> const& root, geometry::Displacement movement) const;
+    void apply_resize(
+        std::shared_ptr<mir::scene::Surface> const& surface,
+        std::shared_ptr<mir::scene::Surface> const& titlebar,
+        geometry::Point const& new_pos,
+        geometry::Size const& new_size) const;
+
+    WindowManagerTools* const tools;
+    std::shared_ptr<shell::DisplayLayout> const display_layout;
+
+    geometry::Rectangle display_area;
+    geometry::Point old_cursor{};
+    std::weak_ptr<scene::Surface> active_surface_;
+    using FullscreenSurfaces = std::set<std::weak_ptr<scene::Surface>, std::owner_less<std::weak_ptr<scene::Surface>>>;
+
+    FullscreenSurfaces fullscreen_surfaces;
+};
+}
+}
+
+#endif /* MIR_EXAMPLE_CANONICAL_WINDOW_MANAGER_H_ */

=== added file 'src/platforms/mirserver/wm-wip/server_example_tiling_window_manager.cpp'
--- src/platforms/mirserver/wm-wip/server_example_tiling_window_manager.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_tiling_window_manager.cpp	2016-03-11 11:36:44 +0000
@@ -0,0 +1,640 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * 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 "server_example_tiling_window_manager.h"
+
+#include "mir/scene/session.h"
+#include "mir/scene/surface.h"
+#include "mir/scene/surface_creation_parameters.h"
+#include "mir/shell/surface_specification.h"
+#include "mir/shell/surface_stack.h"
+#include "mir/shell/surface_ready_observer.h"
+#include "mir/geometry/displacement.h"
+
+#include <linux/input.h>
+#include <csignal>
+
+namespace me = mir::examples;
+namespace ms = mir::scene;
+namespace mf = mir::frontend;
+using namespace mir::geometry;
+
+///\example server_example_tiling_window_manager.cpp
+/// Demonstrate implementing a simple tiling algorithm
+
+me::TilingWindowManagerPolicy::TilingWindowManagerPolicy(WindowManagerTools* const tools) :
+    tools{tools}
+{
+}
+
+void me::TilingWindowManagerPolicy::click(Point cursor)
+{
+    auto const session = session_under(cursor);
+    auto const surface = tools->surface_at(cursor);
+    select_active_surface(session, surface);
+}
+
+void me::TilingWindowManagerPolicy::handle_session_info_updated(SessionInfoMap& session_info, Rectangles const& displays)
+{
+    update_tiles(session_info, displays);
+}
+
+void me::TilingWindowManagerPolicy::handle_displays_updated(SessionInfoMap& session_info, Rectangles const& displays)
+{
+    update_tiles(session_info, displays);
+}
+
+void me::TilingWindowManagerPolicy::resize(Point cursor)
+{
+    if (auto const session = session_under(cursor))
+    {
+        if (session == session_under(old_cursor))
+        {
+            if (auto const surface = select_active_surface(session, tools->surface_at(old_cursor)))
+            {
+                resize(surface, cursor, old_cursor, tools->info_for(session).tile);
+            }
+        }
+    }
+}
+
+auto me::TilingWindowManagerPolicy::handle_place_new_surface(
+    std::shared_ptr<ms::Session> const& session,
+    ms::SurfaceCreationParameters const& request_parameters)
+-> ms::SurfaceCreationParameters
+{
+    auto parameters = request_parameters;
+
+    Rectangle const& tile = tools->info_for(session).tile;
+    parameters.top_left = parameters.top_left + (tile.top_left - Point{0, 0});
+
+    if (auto const parent = parameters.parent.lock())
+    {
+        auto const width = parameters.size.width.as_int();
+        auto const height = parameters.size.height.as_int();
+
+        if (parameters.aux_rect.is_set() && parameters.edge_attachment.is_set())
+        {
+            auto const edge_attachment = parameters.edge_attachment.value();
+            auto const aux_rect = parameters.aux_rect.value();
+            auto const parent_top_left = parent->top_left();
+            auto const top_left = aux_rect.top_left     -Point{} + parent_top_left;
+            auto const top_right= aux_rect.top_right()  -Point{} + parent_top_left;
+            auto const bot_left = aux_rect.bottom_left()-Point{} + parent_top_left;
+
+            if (edge_attachment & mir_edge_attachment_vertical)
+            {
+                if (tile.contains(top_right + Displacement{width, height}))
+                {
+                    parameters.top_left = top_right;
+                }
+                else if (tile.contains(top_left + Displacement{-width, height}))
+                {
+                    parameters.top_left = top_left + Displacement{-width, 0};
+                }
+            }
+
+            if (edge_attachment & mir_edge_attachment_horizontal)
+            {
+                if (tile.contains(bot_left + Displacement{width, height}))
+                {
+                    parameters.top_left = bot_left;
+                }
+                else if (tile.contains(top_left + Displacement{width, -height}))
+                {
+                    parameters.top_left = top_left + Displacement{0, -height};
+                }
+            }
+        }
+        else
+        {
+            auto const parent_top_left = parent->top_left();
+            auto const centred = parent_top_left
+                                 + 0.5*(as_displacement(parent->size()) - as_displacement(parameters.size))
+                                 - DeltaY{(parent->size().height.as_int()-height)/6};
+
+            parameters.top_left = centred;
+        }
+    }
+
+    clip_to_tile(parameters, tile);
+    return parameters;
+}
+
+void me::TilingWindowManagerPolicy::generate_decorations_for(
+    std::shared_ptr<ms::Session> const&,
+    std::shared_ptr<ms::Surface> const&,
+    SurfaceInfoMap&,
+    std::function<mf::SurfaceId(std::shared_ptr<ms::Session> const&, ms::SurfaceCreationParameters const&)> const&)
+{
+}
+
+void me::TilingWindowManagerPolicy::handle_new_surface(std::shared_ptr<ms::Session> const& session, std::shared_ptr<ms::Surface> const& surface)
+{
+    tools->info_for(session).surfaces.push_back(surface);
+
+    auto& surface_info = tools->info_for(surface);
+    if (auto const parent = surface_info.parent.lock())
+    {
+        tools->info_for(parent).children.push_back(surface);
+    }
+
+    if (surface_info.can_be_active())
+    {
+        surface->add_observer(std::make_shared<shell::SurfaceReadyObserver>(
+            [this](std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface)
+                { select_active_surface(session, surface); },
+            session,
+            surface));
+    }
+}
+
+void me::TilingWindowManagerPolicy::handle_modify_surface(
+    std::shared_ptr<scene::Session> const& /*session*/,
+    std::shared_ptr<scene::Surface> const& surface,
+    shell::SurfaceSpecification const& modifications)
+{
+    if (modifications.name.is_set())
+        surface->rename(modifications.name.value());
+}
+
+void me::TilingWindowManagerPolicy::handle_delete_surface(std::shared_ptr<ms::Session> const& session, std::weak_ptr<ms::Surface> const& surface)
+{
+    auto& info = tools->info_for(surface);
+
+    if (auto const parent = info.parent.lock())
+    {
+        auto& siblings = tools->info_for(parent).children;
+
+        for (auto i = begin(siblings); i != end(siblings); ++i)
+        {
+            if (surface.lock() == i->lock())
+            {
+                siblings.erase(i);
+                break;
+            }
+        }
+    }
+
+    auto& surfaces = tools->info_for(session).surfaces;
+
+    for (auto i = begin(surfaces); i != end(surfaces); ++i)
+    {
+        if (surface.lock() == i->lock())
+        {
+            surfaces.erase(i);
+            break;
+        }
+    }
+
+    session->destroy_surface(surface);
+
+    if (surfaces.empty() && session == tools->focused_session())
+    {
+        tools->focus_next_session();
+        select_active_surface(tools->focused_session(), tools->focused_surface());
+    }
+}
+
+int me::TilingWindowManagerPolicy::handle_set_state(std::shared_ptr<ms::Surface> const& surface, MirSurfaceState value)
+{
+    auto& info = tools->info_for(surface);
+
+    switch (value)
+    {
+    case mir_surface_state_restored:
+    case mir_surface_state_maximized:
+    case mir_surface_state_vertmaximized:
+    case mir_surface_state_horizmaximized:
+        break;
+
+    default:
+        return info.state;
+    }
+
+    if (info.state == mir_surface_state_restored)
+    {
+        info.restore_rect = {surface->top_left(), surface->size()};
+    }
+
+    if (info.state == value)
+    {
+        return info.state;
+    }
+
+    auto const& tile = tools->info_for(info.session).tile;
+
+    switch (value)
+    {
+    case mir_surface_state_restored:
+        surface->resize(info.restore_rect.size);
+        drag(surface, info.restore_rect.top_left, surface->top_left(), tile);
+        break;
+
+    case mir_surface_state_maximized:
+        surface->resize(tile.size);
+        drag(surface, tile.top_left, surface->top_left(), tile);
+        break;
+
+    case mir_surface_state_horizmaximized:
+        surface->resize({tile.size.width, info.restore_rect.size.height});
+        drag(surface, {tile.top_left.x, info.restore_rect.top_left.y}, surface->top_left(), tile);
+        break;
+
+    case mir_surface_state_vertmaximized:
+        surface->resize({info.restore_rect.size.width, tile.size.height});
+        drag(surface, {info.restore_rect.top_left.x, tile.top_left.y}, surface->top_left(), tile);
+        break;
+
+    default:
+        break;
+    }
+
+    return info.state = value;
+}
+
+void me::TilingWindowManagerPolicy::drag(Point cursor)
+{
+    if (auto const session = session_under(cursor))
+    {
+        if (session == session_under(old_cursor))
+        {
+            if (auto const surface = select_active_surface(session, tools->surface_at(old_cursor)))
+            {
+                drag(surface, cursor, old_cursor, tools->info_for(session).tile);
+            }
+        }
+    }
+}
+
+void me::TilingWindowManagerPolicy::handle_raise_surface(
+    std::shared_ptr<ms::Session> const& session,
+    std::shared_ptr<ms::Surface> const& surface)
+{
+    select_active_surface(session, surface);
+}
+
+bool me::TilingWindowManagerPolicy::handle_keyboard_event(MirKeyboardEvent const* event)
+{
+    auto const action = mir_keyboard_event_action(event);
+    auto const scan_code = mir_keyboard_event_scan_code(event);
+    auto const modifiers = mir_keyboard_event_modifiers(event) & modifier_mask;
+
+    if (action == mir_keyboard_action_down && scan_code == KEY_F11)
+    {
+        switch (modifiers & modifier_mask)
+        {
+        case mir_input_event_modifier_alt:
+            toggle(mir_surface_state_maximized);
+            return true;
+
+        case mir_input_event_modifier_shift:
+            toggle(mir_surface_state_vertmaximized);
+            return true;
+
+        case mir_input_event_modifier_ctrl:
+            toggle(mir_surface_state_horizmaximized);
+            return true;
+
+        default:
+            break;
+        }
+    }
+    else if (action == mir_keyboard_action_down && scan_code == KEY_F4)
+    {
+        if (auto const session = tools->focused_session())
+        {
+            switch (modifiers & modifier_mask)
+            {
+            case mir_input_event_modifier_alt:
+                kill(session->process_id(), SIGTERM);
+                return true;
+
+            case mir_input_event_modifier_ctrl:
+                if (auto const surf = session->default_surface())
+                {
+                    surf->request_client_surface_close();
+                    return true;
+                }
+
+            default:
+                break;
+            }
+        }
+    }
+    else if (action == mir_keyboard_action_down &&
+            modifiers == mir_input_event_modifier_alt &&
+            scan_code == KEY_TAB)
+    {
+        tools->focus_next_session();
+        select_active_surface(tools->focused_session(), tools->focused_surface());
+
+        return true;
+    }
+    else if (action == mir_keyboard_action_down &&
+            modifiers == mir_input_event_modifier_alt &&
+            scan_code == KEY_GRAVE)
+    {
+        if (auto const prev = tools->focused_surface())
+        {
+            if (auto const app = tools->focused_session())
+                if (auto const surface = app->surface_after(prev))
+                {
+                    select_active_surface(app, surface);
+                }
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+bool me::TilingWindowManagerPolicy::handle_touch_event(MirTouchEvent const* event)
+{
+    auto const count = mir_touch_event_point_count(event);
+
+    long total_x = 0;
+    long total_y = 0;
+
+    for (auto i = 0U; i != count; ++i)
+    {
+        total_x += mir_touch_event_axis_value(event, i, mir_touch_axis_x);
+        total_y += mir_touch_event_axis_value(event, i, mir_touch_axis_y);
+    }
+
+    Point const cursor{total_x/count, total_y/count};
+
+    bool is_drag = true;
+    for (auto i = 0U; i != count; ++i)
+    {
+        switch (mir_touch_event_action(event, i))
+        {
+        case mir_touch_action_up:
+            return false;
+
+        case mir_touch_action_down:
+            is_drag = false;
+
+        case mir_touch_action_change:
+            continue;
+        }
+    }
+
+    bool consumes_event = false;
+    if (is_drag)
+    {
+        switch (count)
+        {
+        case 2:
+            resize(cursor);
+            consumes_event = true;
+            break;
+
+        case 3:
+            drag(cursor);
+            consumes_event = true;
+            break;
+        }
+    }
+
+    old_cursor = cursor;
+    return consumes_event;
+}
+
+bool me::TilingWindowManagerPolicy::handle_pointer_event(MirPointerEvent const* event)
+{
+    auto const action = mir_pointer_event_action(event);
+    auto const modifiers = mir_pointer_event_modifiers(event) & modifier_mask;
+    Point const cursor{
+        mir_pointer_event_axis_value(event, mir_pointer_axis_x),
+        mir_pointer_event_axis_value(event, mir_pointer_axis_y)};
+
+    bool consumes_event = false;
+
+    if (action == mir_pointer_action_button_down)
+    {
+        click(cursor);
+    }
+    else if (action == mir_pointer_action_motion &&
+             modifiers == mir_input_event_modifier_alt)
+    {
+        if (mir_pointer_event_button_state(event, mir_pointer_button_primary))
+        {
+            drag(cursor);
+            consumes_event = true;
+        }
+        else if (mir_pointer_event_button_state(event, mir_pointer_button_tertiary))
+        {
+            resize(cursor);
+            consumes_event = true;
+        }
+    }
+
+    old_cursor = cursor;
+    return consumes_event;
+}
+
+void me::TilingWindowManagerPolicy::toggle(MirSurfaceState state)
+{
+    if (auto const session = tools->focused_session())
+    {
+        if (auto const surface = session->default_surface())
+        {
+            if (surface->state() == state)
+                state = mir_surface_state_restored;
+
+            auto const value = handle_set_state(surface, MirSurfaceState(state));
+            surface->configure(mir_surface_attrib_state, value);
+        }
+    }
+}
+
+std::shared_ptr<ms::Session> me::TilingWindowManagerPolicy::session_under(Point position)
+{
+    return tools->find_session([&](SessionInfo const& info) { return info.tile.contains(position);});
+}
+
+void me::TilingWindowManagerPolicy::update_tiles(
+    SessionInfoMap& session_info,
+    Rectangles const& displays)
+{
+    if (session_info.size() < 1 || displays.size() < 1) return;
+
+    auto const sessions = session_info.size();
+
+    auto const bounding_rect = displays.bounding_rectangle();
+
+    auto const total_width  = bounding_rect.size.width.as_int();
+    auto const total_height = bounding_rect.size.height.as_int();
+
+    auto index = 0;
+
+    for (auto& info : session_info)
+    {
+        auto const x = (total_width*index)/sessions;
+        ++index;
+        auto const dx = (total_width*index)/sessions - x;
+
+        auto const old_tile = info.second.tile;
+        Rectangle const new_tile{{x, 0}, {dx, total_height}};
+
+        update_surfaces(info.first, old_tile, new_tile);
+
+        info.second.tile = new_tile;
+    }
+}
+
+void me::TilingWindowManagerPolicy::update_surfaces(std::weak_ptr<ms::Session> const& session, Rectangle const& old_tile, Rectangle const& new_tile)
+{
+    auto displacement = new_tile.top_left - old_tile.top_left;
+    auto& info = tools->info_for(session);
+
+    for (auto const& ps : info.surfaces)
+    {
+        if (auto const surface = ps.lock())
+        {
+            auto const old_pos = surface->top_left();
+            surface->move_to(old_pos + displacement);
+
+            fit_to_new_tile(*surface, old_tile, new_tile);
+        }
+    }
+}
+
+void me::TilingWindowManagerPolicy::clip_to_tile(ms::SurfaceCreationParameters& parameters, Rectangle const& tile)
+{
+    auto const displacement = parameters.top_left - tile.top_left;
+
+    auto width = std::min(tile.size.width.as_int()-displacement.dx.as_int(), parameters.size.width.as_int());
+    auto height = std::min(tile.size.height.as_int()-displacement.dy.as_int(), parameters.size.height.as_int());
+
+    parameters.size = Size{width, height};
+}
+
+void me::TilingWindowManagerPolicy::fit_to_new_tile(ms::Surface& surface, Rectangle const& old_tile, Rectangle const& new_tile)
+{
+    auto const displacement = surface.top_left() - new_tile.top_left;
+
+    // For now just scale if was filling width/height of tile
+    auto const old_size = surface.size();
+    auto const scaled_width = old_size.width == old_tile.size.width ? new_tile.size.width : old_size.width;
+    auto const scaled_height = old_size.height == old_tile.size.height ? new_tile.size.height : old_size.height;
+
+    auto width = std::min(new_tile.size.width.as_int()-displacement.dx.as_int(), scaled_width.as_int());
+    auto height = std::min(new_tile.size.height.as_int()-displacement.dy.as_int(), scaled_height.as_int());
+
+    surface.resize({width, height});
+}
+
+void me::TilingWindowManagerPolicy::drag(std::shared_ptr<ms::Surface> surface, Point to, Point from, Rectangle bounds)
+{
+    if (surface && surface->input_area_contains(from))
+    {
+        auto movement = to - from;
+
+        constrained_move(surface, movement, bounds);
+
+        for (auto const& child: tools->info_for(surface).children)
+        {
+            auto move = movement;
+            constrained_move(child.lock(), move, bounds);
+        }
+    }
+}
+
+void me::TilingWindowManagerPolicy::constrained_move(
+    std::shared_ptr<scene::Surface> const& surface,
+    Displacement& movement,
+    Rectangle const& bounds)
+{
+    auto const top_left = surface->top_left();
+    auto const surface_size = surface->size();
+    auto const bottom_right = top_left + as_displacement(surface_size);
+
+    if (movement.dx < DeltaX{0})
+            movement.dx = std::max(movement.dx, (bounds.top_left - top_left).dx);
+
+    if (movement.dy < DeltaY{0})
+            movement.dy = std::max(movement.dy, (bounds.top_left - top_left).dy);
+
+    if (movement.dx > DeltaX{0})
+            movement.dx = std::min(movement.dx, (bounds.bottom_right() - bottom_right).dx);
+
+    if (movement.dy > DeltaY{0})
+            movement.dy = std::min(movement.dy, (bounds.bottom_right() - bottom_right).dy);
+
+    auto new_pos = surface->top_left() + movement;
+
+    surface->move_to(new_pos);
+}
+
+void me::TilingWindowManagerPolicy::resize(std::shared_ptr<ms::Surface> surface, Point cursor, Point old_cursor, Rectangle bounds)
+{
+    if (surface && surface->input_area_contains(old_cursor))
+    {
+        auto const top_left = surface->top_left();
+
+        auto const old_displacement = old_cursor - top_left;
+        auto const new_displacement = cursor - top_left;
+
+        auto const scale_x = new_displacement.dx.as_float()/std::max(1.0f, old_displacement.dx.as_float());
+        auto const scale_y = new_displacement.dy.as_float()/std::max(1.0f, old_displacement.dy.as_float());
+
+        if (scale_x <= 0.0f || scale_y <= 0.0f) return;
+
+        auto const old_size = surface->size();
+        Size new_size{scale_x*old_size.width, scale_y*old_size.height};
+
+        auto const size_limits = as_size(bounds.bottom_right() - top_left);
+
+        if (new_size.width > size_limits.width)
+            new_size.width = size_limits.width;
+
+        if (new_size.height > size_limits.height)
+            new_size.height = size_limits.height;
+
+        surface->resize(new_size);
+    }
+}
+
+std::shared_ptr<ms::Surface> me::TilingWindowManagerPolicy::select_active_surface(std::shared_ptr<ms::Session> const& session, std::shared_ptr<scene::Surface> const& surface)
+{
+    if (!surface)
+    {
+        tools->set_focus_to({}, {});
+        return surface;
+    }
+
+    auto const& info_for = tools->info_for(surface);
+
+    if (info_for.can_be_active())
+    {
+        tools->set_focus_to(session, surface);
+        tools->raise_tree(surface);
+        return surface;
+    }
+    else
+    {
+        // Cannot have input focus - try the parent
+        if (auto const parent = info_for.parent.lock())
+            return select_active_surface(session, parent);
+
+        return {};
+    }
+}

=== added file 'src/platforms/mirserver/wm-wip/server_example_tiling_window_manager.h'
--- src/platforms/mirserver/wm-wip/server_example_tiling_window_manager.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_tiling_window_manager.h	2016-03-11 11:36:44 +0000
@@ -0,0 +1,124 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * 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 MIR_EXAMPLE_TILING_WINDOW_MANAGER_H_
+#define MIR_EXAMPLE_TILING_WINDOW_MANAGER_H_
+
+#include "server_example_basic_window_manager.h"
+
+///\example server_example_tiling_window_manager.h
+/// Demonstrate implementing a simple tiling algorithm
+
+namespace mir
+{
+namespace examples
+{
+// simple tiling algorithm:
+//  o Switch apps: tap or click on the corresponding tile
+//  o Move window: Alt-leftmousebutton drag (three finger drag)
+//  o Resize window: Alt-middle_button drag (two finger drag)
+//  o Maximize/restore current window (to tile size): Alt-F11
+//  o Maximize/restore current window (to tile height): Shift-F11
+//  o Maximize/restore current window (to tile width): Ctrl-F11
+//  o client requests to maximize, vertically maximize & restore
+class TilingWindowManagerPolicy : public WindowManagementPolicy
+{
+public:
+    explicit TilingWindowManagerPolicy(WindowManagerTools* const tools);
+
+    void click(geometry::Point cursor);
+
+    void handle_session_info_updated(SessionInfoMap& session_info, geometry::Rectangles const& displays);
+
+    void handle_displays_updated(SessionInfoMap& session_info, geometry::Rectangles const& displays);
+
+    void resize(geometry::Point cursor);
+
+    auto handle_place_new_surface(
+        std::shared_ptr<scene::Session> const& session,
+        scene::SurfaceCreationParameters const& request_parameters)
+    -> scene::SurfaceCreationParameters;
+
+    void handle_new_surface(std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface);
+
+    void handle_modify_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface,
+        shell::SurfaceSpecification const& modifications);
+
+    void handle_delete_surface(std::shared_ptr<scene::Session> const& session, std::weak_ptr<scene::Surface> const& surface);
+
+    int handle_set_state(std::shared_ptr<scene::Surface> const& surface, MirSurfaceState value);
+
+    void drag(geometry::Point cursor);
+
+    bool handle_keyboard_event(MirKeyboardEvent const* event);
+
+    bool handle_touch_event(MirTouchEvent const* event);
+
+    bool handle_pointer_event(MirPointerEvent const* event);
+
+    void handle_raise_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface);
+
+    void generate_decorations_for(
+        std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface,
+        SurfaceInfoMap& surface_info,
+        std::function<frontend::SurfaceId(std::shared_ptr<scene::Session> const&, scene::SurfaceCreationParameters const&)> const& build);
+
+private:
+    static const int modifier_mask =
+        mir_input_event_modifier_alt |
+        mir_input_event_modifier_shift |
+        mir_input_event_modifier_sym |
+        mir_input_event_modifier_ctrl |
+        mir_input_event_modifier_meta;
+
+    void toggle(MirSurfaceState state);
+
+    std::shared_ptr<scene::Session> session_under(geometry::Point position);
+
+    void update_tiles(
+        SessionInfoMap& session_info,
+        geometry::Rectangles const& displays);
+
+    void update_surfaces(std::weak_ptr<scene::Session> const& session, geometry::Rectangle const& old_tile, geometry::Rectangle const& new_tile);
+
+    static void clip_to_tile(scene::SurfaceCreationParameters& parameters, geometry::Rectangle const& tile);
+
+    static void fit_to_new_tile(scene::Surface& surface, geometry::Rectangle const& old_tile, geometry::Rectangle const& new_tile);
+
+    void drag(std::shared_ptr<scene::Surface> surface, geometry::Point to, geometry::Point from, geometry::Rectangle bounds);
+
+    static void resize(std::shared_ptr<scene::Surface> surface, geometry::Point cursor, geometry::Point old_cursor, geometry::Rectangle bounds);
+
+    static void constrained_move(std::shared_ptr<scene::Surface> const& surface, geometry::Displacement& movement, geometry::Rectangle const& bounds);
+
+    std::shared_ptr<scene::Surface> select_active_surface(std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface);
+
+    WindowManagerTools* const tools;
+
+    geometry::Point old_cursor{};
+};
+
+using TilingWindowManager = WindowManagerBuilder<TilingWindowManagerPolicy>;
+}
+}
+
+#endif /* MIR_EXAMPLE_TILING_WINDOW_MANAGER_H_ */

=== added file 'src/platforms/mirserver/wm-wip/server_example_window_management.cpp'
--- src/platforms/mirserver/wm-wip/server_example_window_management.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_window_management.cpp	2016-03-11 11:36:44 +0000
@@ -0,0 +1,155 @@
+/*
+ * 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: Alan Griffiths <[e-mail]>
+ */
+
+#include "server_example_window_management.h"
+
+#include "server_example_tiling_window_manager.h"
+#include "server_example_canonical_window_manager.h"
+
+#include "mir/abnormal_exit.h"
+#include "mir/server.h"
+#include "mir/input/composite_event_filter.h"
+#include "mir/options/option.h"
+#include "mir/scene/session.h"
+#include "mir/scene/surface_creation_parameters.h"
+#include "mir/shell/display_layout.h"
+#include "mir/shell/system_compositor_window_manager.h"
+
+namespace me = mir::examples;
+namespace mf = mir::frontend;
+namespace mg = mir::graphics;
+namespace mi = mir::input;
+namespace ms = mir::scene;
+namespace msh = mir::shell;
+using namespace mir::geometry;
+
+///\example server_example_window_management.cpp
+/// Demonstrate introducing a window management strategy
+
+namespace
+{
+char const* const wm_option = "window-manager";
+char const* const wm_description = "window management strategy [{tiling|fullscreen|canonical|system-compositor}]";
+
+char const* const wm_tiling = "tiling";
+char const* const wm_fullscreen = "fullscreen";
+char const* const wm_canonical = "canonical";
+char const* const wm_system_compositor = "system-compositor";
+
+// Very simple - make every surface fullscreen
+class FullscreenWindowManagerPolicy  : public me::WindowManagementPolicy
+{
+public:
+    FullscreenWindowManagerPolicy(me::WindowManagerTools* const /*tools*/, std::shared_ptr<msh::DisplayLayout> const& display_layout) :
+        display_layout{display_layout} {}
+
+    void handle_session_info_updated(SessionInfoMap& /*session_info*/, Rectangles const& /*displays*/) {}
+
+    void handle_displays_updated(SessionInfoMap& /*session_info*/, Rectangles const& /*displays*/) {}
+
+    auto handle_place_new_surface(
+        std::shared_ptr<ms::Session> const& /*session*/,
+        ms::SurfaceCreationParameters const& request_parameters)
+    -> ms::SurfaceCreationParameters
+    {
+        auto placed_parameters = request_parameters;
+
+        Rectangle rect{request_parameters.top_left, request_parameters.size};
+        display_layout->size_to_output(rect);
+        placed_parameters.size = rect.size;
+
+        return placed_parameters;
+    }
+    void handle_modify_surface(
+        std::shared_ptr<ms::Session> const& /*session*/,
+        std::shared_ptr<ms::Surface> const& /*surface*/,
+        msh::SurfaceSpecification const& /*modifications*/)
+    {
+    }
+
+    void handle_new_surface(std::shared_ptr<ms::Session> const& /*session*/, std::shared_ptr<ms::Surface> const& /*surface*/)
+    {
+    }
+
+    void handle_delete_surface(std::shared_ptr<ms::Session> const& session, std::weak_ptr<ms::Surface> const& surface)
+        { session->destroy_surface(surface); }
+
+    int handle_set_state(std::shared_ptr<ms::Surface> const& /*surface*/, MirSurfaceState value)
+        { return value; }
+
+    bool handle_keyboard_event(MirKeyboardEvent const* /*event*/) { return false; }
+
+    bool handle_touch_event(MirTouchEvent const* /*event*/) { return false; }
+
+    bool handle_pointer_event(MirPointerEvent const* /*event*/) { return false; }
+
+    void handle_raise_surface(
+        std::shared_ptr<ms::Session> const& /*session*/,
+        std::shared_ptr<ms::Surface> const& /*surface*/)
+    {
+    }
+
+    void generate_decorations_for(
+        std::shared_ptr<ms::Session> const&,
+        std::shared_ptr<ms::Surface> const&,
+        SurfaceInfoMap&,
+        std::function<mf::SurfaceId(std::shared_ptr<ms::Session> const&, ms::SurfaceCreationParameters const&)> const&)
+    {
+    }
+private:
+    std::shared_ptr<msh::DisplayLayout> const display_layout;
+};
+
+}
+
+using FullscreenWindowManager = me::WindowManagerBuilder<FullscreenWindowManagerPolicy>;
+using CanonicalWindowManager = me::WindowManagerBuilder<me::CanonicalWindowManagerPolicyCopy>;
+
+void me::add_window_manager_option_to(Server& server)
+{
+    server.add_configuration_option(wm_option, wm_description, wm_canonical);
+
+    server.override_the_window_manager_builder([&server](msh::FocusController* focus_controller)
+        -> std::shared_ptr<msh::WindowManager>
+        {
+            auto const options = server.get_options();
+            auto const selection = options->get<std::string>(wm_option);
+
+            if (selection == wm_tiling)
+            {
+                return std::make_shared<TilingWindowManager>(focus_controller);
+            }
+            else if (selection == wm_fullscreen)
+            {
+                return std::make_shared<FullscreenWindowManager>(focus_controller, server.the_shell_display_layout());
+            }
+            else if (selection == wm_canonical)
+            {
+                return std::make_shared<CanonicalWindowManager>(focus_controller, server.the_shell_display_layout());
+            }
+            else if (selection == wm_system_compositor)
+            {
+                return std::make_shared<msh::SystemCompositorWindowManager>(
+                    focus_controller,
+                    server.the_shell_display_layout(),
+                    server.the_session_coordinator());
+            }
+
+            throw mir::AbnormalExit("Unknown window manager: " + selection);
+        });
+}

=== added file 'src/platforms/mirserver/wm-wip/server_example_window_management.h'
--- src/platforms/mirserver/wm-wip/server_example_window_management.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_window_management.h	2016-03-11 11:36:44 +0000
@@ -0,0 +1,33 @@
+/*
+ * 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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIR_EXAMPLES_WINDOW_MANAGEMENT_H_
+#define MIR_EXAMPLES_WINDOW_MANAGEMENT_H_
+
+namespace mir
+{
+class Server;
+
+namespace examples
+{
+void add_window_manager_option_to(Server& server);
+}
+} // namespace mir
+
+
+#endif // MIR_EXAMPLES_WINDOW_MANAGEMENT_H_

=== added file 'src/platforms/mirserver/wm-wip/server_example_window_management_info.cpp'
--- src/platforms/mirserver/wm-wip/server_example_window_management_info.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_window_management_info.cpp	2016-03-11 11:36:44 +0000
@@ -0,0 +1,406 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * 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 "server_example_window_management_info.h"
+
+#include "mir/scene/surface.h"
+#include "mir/scene/surface_creation_parameters.h"
+
+#include "mir/graphics/buffer.h"
+
+#include <atomic>
+
+namespace me = mir::examples;
+namespace ms = mir::scene;
+namespace mg = mir::graphics;
+using namespace mir::geometry;
+
+me::SurfaceInfo::SurfaceInfo(
+    std::shared_ptr<scene::Session> const& session,
+    std::shared_ptr<scene::Surface> const& surface,
+    scene::SurfaceCreationParameters const& params) :
+    type{surface->type()},
+    state{surface->state()},
+    restore_rect{surface->top_left(), surface->size()},
+    session{session},
+    parent{params.parent},
+    min_width{params.min_width.is_set() ? params.min_width.value()  : Width{}},
+    min_height{params.min_height.is_set() ? params.min_height.value() : Height{}},
+    max_width{params.max_width.is_set() ? params.max_width.value() : Width{std::numeric_limits<int>::max()}},
+    max_height{params.max_height.is_set() ? params.max_height.value() : Height{std::numeric_limits<int>::max()}},
+    width_inc{params.width_inc},
+    height_inc{params.height_inc},
+    min_aspect{params.min_aspect},
+    max_aspect{params.max_aspect}
+{
+    if (params.output_id != mir::graphics::DisplayConfigurationOutputId{0})
+        output_id = params.output_id;
+}
+
+bool me::SurfaceInfo::can_be_active() const
+{
+    switch (type)
+    {
+    case mir_surface_type_normal:       /**< AKA "regular"                       */
+    case mir_surface_type_utility:      /**< AKA "floating"                      */
+    case mir_surface_type_dialog:
+    case mir_surface_type_satellite:    /**< AKA "toolbox"/"toolbar"             */
+    case mir_surface_type_freestyle:
+    case mir_surface_type_menu:
+    case mir_surface_type_inputmethod:  /**< AKA "OSK" or handwriting etc.       */
+        return true;
+
+    case mir_surface_type_gloss:
+    case mir_surface_type_tip:          /**< AKA "tooltip"                       */
+    default:
+        // Cannot have input focus
+        return false;
+    }
+}
+
+bool me::SurfaceInfo::must_have_parent() const
+{
+    switch (type)
+    {
+    case mir_surface_type_overlay:;
+    case mir_surface_type_inputmethod:
+    case mir_surface_type_satellite:
+    case mir_surface_type_tip:
+        return true;
+
+    default:
+        return false;
+    }
+}
+
+bool me::SurfaceInfo::can_morph_to(MirSurfaceType new_type) const
+{
+    switch (new_type)
+    {
+    case mir_surface_type_normal:
+    case mir_surface_type_utility:
+    case mir_surface_type_satellite:
+        switch (type)
+        {
+        case mir_surface_type_normal:
+        case mir_surface_type_utility:
+        case mir_surface_type_dialog:
+        case mir_surface_type_satellite:
+            return true;
+
+        default:
+            break;
+        }
+        break;
+
+    case mir_surface_type_dialog:
+        switch (type)
+        {
+        case mir_surface_type_normal:
+        case mir_surface_type_utility:
+        case mir_surface_type_dialog:
+        case mir_surface_type_popover:
+        case mir_surface_type_satellite:
+            return true;
+
+        default:
+            break;
+        }
+        break;
+
+    default:
+        break;
+    }
+
+    return false;
+}
+
+bool me::SurfaceInfo::must_not_have_parent() const
+{
+    switch (type)
+    {
+    case mir_surface_type_normal:
+    case mir_surface_type_utility:
+        return true;
+
+    default:
+        return false;
+    }
+}
+
+bool me::SurfaceInfo::is_visible() const
+{
+    switch (state)
+    {
+    case mir_surface_state_hidden:
+    case mir_surface_state_minimized:
+        return false;
+    default:
+        break;
+    }
+    return true;
+}
+
+struct mir::examples::SurfaceInfo::StreamPainter
+{
+    virtual void paint(int) = 0;
+    virtual ~StreamPainter() = default;
+    StreamPainter() = default;
+    StreamPainter(StreamPainter const&) = delete;
+    StreamPainter& operator=(StreamPainter const&) = delete;
+};
+
+struct mir::examples::SurfaceInfo::SwappingPainter
+    : mir::examples::SurfaceInfo::StreamPainter
+{
+    SwappingPainter(std::shared_ptr<frontend::BufferStream> const& buffer_stream) :
+        buffer_stream{buffer_stream}, buffer{nullptr}
+    {
+        swap_buffers();
+    }
+
+    void swap_buffers()
+    {
+        auto const callback = [this](mir::graphics::Buffer* new_buffer)
+            {
+                buffer.store(new_buffer);
+            };
+
+        buffer_stream->swap_buffers(buffer, callback);
+    }
+
+    void paint(int intensity) override
+    {
+        if (auto const buf = buffer.load())
+        {
+            auto const format = buffer_stream->pixel_format();
+            auto const sz = buf->size().height.as_int() *
+                            buf->size().width.as_int() * MIR_BYTES_PER_PIXEL(format);
+            std::vector<unsigned char> pixels(sz, intensity);
+            buf->write(pixels.data(), sz);
+            swap_buffers();
+        }
+    }
+
+    std::shared_ptr<frontend::BufferStream> const buffer_stream;
+    std::atomic<graphics::Buffer*> buffer;
+};
+
+struct mir::examples::SurfaceInfo::AllocatingPainter
+    : mir::examples::SurfaceInfo::StreamPainter
+{
+    AllocatingPainter(std::shared_ptr<frontend::BufferStream> const& buffer_stream, Size size) :
+        buffer_stream(buffer_stream),
+        properties({
+            size,
+            buffer_stream->pixel_format(),
+            mg::BufferUsage::software
+        }),
+        front_buffer(buffer_stream->allocate_buffer(properties)),
+        back_buffer(buffer_stream->allocate_buffer(properties))
+    {
+    }
+
+    void paint(int intensity) override
+    {
+        buffer_stream->with_buffer(back_buffer,
+            [this, intensity](graphics::Buffer& buffer)
+            {
+                auto const format = buffer.pixel_format();
+                auto const sz = buffer.size().height.as_int() *
+                                buffer.size().width.as_int() * MIR_BYTES_PER_PIXEL(format);
+                std::vector<unsigned char> pixels(sz, intensity);
+                buffer.write(pixels.data(), sz);
+                buffer_stream->swap_buffers(&buffer, [](mg::Buffer*){});
+            });
+        std::swap(front_buffer, back_buffer);
+    }
+
+    ~AllocatingPainter()
+    {
+        buffer_stream->remove_buffer(front_buffer);
+        buffer_stream->remove_buffer(back_buffer);
+    }
+
+    std::shared_ptr<frontend::BufferStream> const buffer_stream;
+    mg::BufferProperties properties;
+    mg::BufferID front_buffer; 
+    mg::BufferID back_buffer; 
+};
+
+void mir::examples::SurfaceInfo::init_titlebar(std::shared_ptr<scene::Surface> const& surface)
+{
+    auto stream = surface->primary_buffer_stream();
+    try
+    {
+        stream_painter = std::make_shared<AllocatingPainter>(stream, surface->size());
+    }
+    catch (...)
+    {
+        stream_painter = std::make_shared<SwappingPainter>(stream);
+    }
+}
+
+void mir::examples::SurfaceInfo::paint_titlebar(int intensity)
+{
+    stream_painter->paint(intensity);
+}
+
+void me::SurfaceInfo::constrain_resize(
+    std::shared_ptr<ms::Surface> const& surface,
+    Point& requested_pos,
+    Size& requested_size,
+    bool const left_resize,
+    bool const top_resize,
+    Rectangle const& /*bounds*/) const
+{
+    Point new_pos = requested_pos;
+    Size new_size = requested_size;
+
+    if (min_aspect.is_set())
+    {
+        auto const ar = min_aspect.value();
+
+        auto const error = new_size.height.as_int()*long(ar.width) - new_size.width.as_int()*long(ar.height);
+
+        if (error > 0)
+        {
+            // Add (denominator-1) to numerator to ensure rounding up
+            auto const width_correction  = (error+(ar.height-1))/ar.height;
+            auto const height_correction = (error+(ar.width-1))/ar.width;
+
+            if (width_correction < height_correction)
+            {
+                new_size.width = new_size.width + DeltaX(width_correction);
+            }
+            else
+            {
+                new_size.height = new_size.height - DeltaY(height_correction);
+            }
+        }
+    }
+
+    if (max_aspect.is_set())
+    {
+        auto const ar = max_aspect.value();
+
+        auto const error = new_size.width.as_int()*long(ar.height) - new_size.height.as_int()*long(ar.width);
+
+        if (error > 0)
+        {
+            // Add (denominator-1) to numerator to ensure rounding up
+            auto const height_correction = (error+(ar.width-1))/ar.width;
+            auto const width_correction  = (error+(ar.height-1))/ar.height;
+
+            if (width_correction < height_correction)
+            {
+                new_size.width = new_size.width - DeltaX(width_correction);
+            }
+            else
+            {
+                new_size.height = new_size.height + DeltaY(height_correction);
+            }
+        }
+    }
+
+    if (min_width > new_size.width)
+        new_size.width = min_width;
+
+    if (min_height > new_size.height)
+        new_size.height = min_height;
+
+    if (max_width < new_size.width)
+        new_size.width = max_width;
+
+    if (max_height < new_size.height)
+        new_size.height = max_height;
+
+    if (width_inc.is_set())
+    {
+        auto const width = new_size.width.as_int() - min_width.as_int();
+        auto inc = width_inc.value().as_int();
+        if (width % inc)
+            new_size.width = min_width + DeltaX{inc*(((2L*width + inc)/2)/inc)};
+    }
+
+    if (height_inc.is_set())
+    {
+        auto const height = new_size.height.as_int() - min_height.as_int();
+        auto inc = height_inc.value().as_int();
+        if (height % inc)
+            new_size.height = min_height + DeltaY{inc*(((2L*height + inc)/2)/inc)};
+    }
+
+    if (left_resize)
+        new_pos.x += new_size.width - requested_size.width;
+
+    if (top_resize)
+        new_pos.y += new_size.height - requested_size.height;
+
+    // placeholder - constrain onscreen
+
+    switch (state)
+    {
+    case mir_surface_state_restored:
+        break;
+
+        // "A vertically maximised surface is anchored to the top and bottom of
+        // the available workspace and can have any width."
+    case mir_surface_state_vertmaximized:
+        new_pos.y = surface->top_left().y;
+        new_size.height = surface->size().height;
+        break;
+
+        // "A horizontally maximised surface is anchored to the left and right of
+        // the available workspace and can have any height"
+    case mir_surface_state_horizmaximized:
+        new_pos.x = surface->top_left().x;
+        new_size.width = surface->size().width;
+        break;
+
+        // "A maximised surface is anchored to the top, bottom, left and right of the
+        // available workspace. For example, if the launcher is always-visible then
+        // the left-edge of the surface is anchored to the right-edge of the launcher."
+    case mir_surface_state_maximized:
+    default:
+        new_pos.x = surface->top_left().x;
+        new_pos.y = surface->top_left().y;
+        new_size.width = surface->size().width;
+        new_size.height = surface->size().height;
+        break;
+    }
+
+    requested_pos = new_pos;
+    requested_size = new_size;
+}
+
+bool me::SurfaceInfo::needs_titlebar(MirSurfaceType type)
+{
+    switch (type)
+    {
+    case mir_surface_type_freestyle:
+    case mir_surface_type_menu:
+    case mir_surface_type_inputmethod:
+    case mir_surface_type_gloss:
+    case mir_surface_type_tip:
+        // No decorations for these surface types
+        return false;
+    default:
+        return true;
+    }
+}

=== added file 'src/platforms/mirserver/wm-wip/server_example_window_management_info.h'
--- src/platforms/mirserver/wm-wip/server_example_window_management_info.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_window_management_info.h	2016-03-11 11:36:44 +0000
@@ -0,0 +1,103 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * 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 MIR_SERVER_EXAMPLE_WINDOW_MANAGEMENT_INFO_H
+#define MIR_SERVER_EXAMPLE_WINDOW_MANAGEMENT_INFO_H
+
+#include "mir/geometry/rectangles.h"
+#include "mir/optional_value.h"
+#include "mir/shell/surface_specification.h"
+
+#include <vector>
+
+namespace mir
+{
+namespace scene { class Session; class Surface; class SurfaceCreationParameters; }
+namespace examples
+{
+struct SurfaceInfo
+{
+    SurfaceInfo(
+        std::shared_ptr <scene::Session> const& session,
+        std::shared_ptr <scene::Surface> const& surface,
+        scene::SurfaceCreationParameters const& params);
+
+    bool can_be_active() const;
+
+    bool can_morph_to(MirSurfaceType new_type) const;
+
+    bool must_have_parent() const;
+
+    bool must_not_have_parent() const;
+
+    bool is_visible() const;
+
+    static bool needs_titlebar(MirSurfaceType type);
+
+    void constrain_resize(
+        std::shared_ptr <scene::Surface> const& surface,
+        geometry::Point& requested_pos,
+        geometry::Size& requested_size,
+        const bool left_resize,
+        const bool top_resize,
+        geometry::Rectangle const& bounds) const;
+
+    MirSurfaceType type;
+    MirSurfaceState state;
+    geometry::Rectangle restore_rect;
+    std::weak_ptr <scene::Session> session;
+    std::weak_ptr <scene::Surface> parent;
+    std::vector <std::weak_ptr<scene::Surface>> children;
+    std::shared_ptr <scene::Surface> titlebar;
+    frontend::SurfaceId titlebar_id;
+    bool is_titlebar = false;
+    geometry::Width min_width;
+    geometry::Height min_height;
+    geometry::Width max_width;
+    geometry::Height max_height;
+    mir::optional_value<geometry::DeltaX> width_inc;
+    mir::optional_value<geometry::DeltaY> height_inc;
+    mir::optional_value<shell::SurfaceAspectRatio> min_aspect;
+    mir::optional_value<shell::SurfaceAspectRatio> max_aspect;
+    mir::optional_value<graphics::DisplayConfigurationOutputId> output_id;
+
+    void init_titlebar(std::shared_ptr <scene::Surface> const& surface);
+
+    void paint_titlebar(int intensity);
+
+private:
+
+    struct StreamPainter;
+    struct AllocatingPainter;
+    struct SwappingPainter;
+
+    std::shared_ptr <StreamPainter> stream_painter;
+};
+
+struct SessionInfo
+{
+    std::vector<std::weak_ptr<scene::Surface>> surfaces;
+
+    // This is only used by the TilingWindowManagerPolicy,
+    // perhaps we need a more extensible mechanism. (std::experimental::any?)
+    geometry::Rectangle tile;
+};
+}
+}
+
+#endif //MIR_SERVER_EXAMPLE_WINDOW_MANAGEMENT_INFO_H

=== modified file 'tests/framework/mock_proc_info.cpp'
--- tests/framework/mock_proc_info.cpp	2015-11-20 16:47:09 +0000
+++ tests/framework/mock_proc_info.cpp	2016-03-11 11:36:44 +0000
@@ -21,6 +21,8 @@
 
 MockProcInfo::MockProcInfo()
 {
+    using namespace ::testing;
+    ON_CALL(*this, command_line(_)).WillByDefault(Return(QByteArray()));
 }
 
 MockProcInfo::~MockProcInfo()

=== modified file 'tests/framework/mock_session.cpp'
--- tests/framework/mock_session.cpp	2015-10-19 10:45:42 +0000
+++ tests/framework/mock_session.cpp	2016-03-11 11:36:44 +0000
@@ -23,6 +23,7 @@
     : SessionInterface(0)
 {
     m_state = Starting;
+    ON_CALL(*this, name()).WillByDefault(::testing::Return(QString()));
     ON_CALL(*this, suspend()).WillByDefault(::testing::Invoke(this, &MockSession::doSuspend));
     ON_CALL(*this, resume()).WillByDefault(::testing::Invoke(this, &MockSession::doResume));
     ON_CALL(*this, stop()).WillByDefault(::testing::Invoke(this, &MockSession::doStop));

=== modified file 'tests/framework/mock_task_controller.cpp'
--- tests/framework/mock_task_controller.cpp	2016-02-11 11:52:06 +0000
+++ tests/framework/mock_task_controller.cpp	2016-03-11 11:36:44 +0000
@@ -68,11 +68,11 @@
 
 bool MockTaskController::doAppIdHasProcessId(const QString &appId, pid_t pid)
 {
-    auto it = children.find(appId);
-    if (it == children.end())
-        return -1;
+    auto primaryPid = primaryPidForAppId(appId);
+    if (primaryPid == -1)
+        return false;
 
-    return it->pid() == pid;
+    return primaryPid == pid;
 }
 
 

=== modified file 'tests/framework/qtmir_test.cpp'
--- tests/framework/qtmir_test.cpp	2016-02-11 11:52:06 +0000
+++ tests/framework/qtmir_test.cpp	2016-03-11 11:36:44 +0000
@@ -99,13 +99,13 @@
 };
 
 
-namespace {  char const* argv[] = { nullptr }; }
+namespace { int argc = 0; char* argv[] = { nullptr }; }
 
 class FakeMirServer: private TestMirServerInit, public MirServer
 {
 public:
     FakeMirServer(std::shared_ptr<StubPromptSessionManager> const& promptSessionManager)
-    : TestMirServerInit(promptSessionManager), MirServer(0, argv, QSharedPointer<ScreenController>())
+    : TestMirServerInit(promptSessionManager), MirServer(argc, argv, QSharedPointer<ScreenController>())
     {
     }
 

=== added directory 'tests/mirserver/ArgvHelper'
=== added file 'tests/mirserver/ArgvHelper/CMakeLists.txt'
--- tests/mirserver/ArgvHelper/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/mirserver/ArgvHelper/CMakeLists.txt	2016-03-11 11:36:44 +0000
@@ -0,0 +1,18 @@
+set(
+  ARGVHELPER_TEST_SOURCES
+  argvHelper_test.cpp
+)
+
+add_executable(ArgvHelperTest ${ARGVHELPER_TEST_SOURCES})
+
+include_directories(
+  ${CMAKE_SOURCE_DIR}/src/platforms/mirserver
+)
+
+target_link_libraries(
+  ArgvHelperTest
+
+  ${GTEST_BOTH_LIBRARIES}
+)
+
+add_test(ArgvHelper, ArgvHelperTest)

=== added file 'tests/mirserver/ArgvHelper/argvHelper_test.cpp'
--- tests/mirserver/ArgvHelper/argvHelper_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/mirserver/ArgvHelper/argvHelper_test.cpp	2016-03-11 11:36:44 +0000
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2015 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 warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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/>.
+ */
+
+#include <gtest/gtest.h>
+
+#include <argvHelper.h>
+
+using namespace qtmir;
+
+TEST(ArgvHelperTest, StripsCorrectly)
+{
+    int argc = 5;
+    const char *argv[6] = { "/usr/bin/unity8", "-fullscreen", "--debug",
+                            "--platform-input-lib=/path/to/lib.so", "-testability", nullptr };
+
+    const int filteredArgc = 2;
+    const char *filteredArgv[3] = { "-fullscreen", "-testability", nullptr };
+
+    editArgvToMatch(argc, const_cast<char**>(argv), filteredArgc, filteredArgv);
+
+    EXPECT_EQ(argc, 3);
+    EXPECT_EQ(argv[0], "/usr/bin/unity8");
+    EXPECT_EQ(argv[1], "-fullscreen");
+    EXPECT_EQ(argv[2], "-testability");
+    EXPECT_EQ(argv[3], nullptr);
+}
+
+TEST(ArgvHelperTest, NothingToStrip)
+{
+    int argc = 4;
+    const char *argv[5] = { "/usr/bin/unity8", "-fullscreen", "--multisample", "-testability", nullptr };
+
+    const int filteredArgc = 3;
+    const char *filteredArgv[4] = { "-fullscreen", "-testability", "--multisample", nullptr };
+
+    editArgvToMatch(argc, const_cast<char**>(argv), filteredArgc, filteredArgv);
+
+    EXPECT_EQ(argc, 4);
+    EXPECT_EQ(argv[0], "/usr/bin/unity8");
+    EXPECT_EQ(argv[1], "-fullscreen");
+    EXPECT_EQ(argv[2], "-testability");
+    EXPECT_EQ(argv[3], "--multisample");
+    EXPECT_EQ(argv[4], nullptr);
+}
+
+TEST(ArgvHelperTest, NothingToDo)
+{
+    int argc = 1;
+    const char *argv[2] = { "/usr/bin/unity8", nullptr };
+
+    const int filteredArgc = 0;
+    const char *filteredArgv[1] = { nullptr };
+
+    editArgvToMatch(argc, const_cast<char**>(argv), filteredArgc, filteredArgv);
+
+    EXPECT_EQ(argc, 1);
+    EXPECT_EQ(argv[0], "/usr/bin/unity8");
+    EXPECT_EQ(argv[1], nullptr);
+}

=== modified file 'tests/mirserver/CMakeLists.txt'
--- tests/mirserver/CMakeLists.txt	2015-10-27 10:17:45 +0000
+++ tests/mirserver/CMakeLists.txt	2016-03-11 11:36:44 +0000
@@ -1,3 +1,4 @@
+add_subdirectory(ArgvHelper)
 add_subdirectory(QtEventFeeder)
 add_subdirectory(Clipboard)
 add_subdirectory(Screen)

=== modified file 'tests/mirserver/Screen/screen_test.cpp'
--- tests/mirserver/Screen/screen_test.cpp	2015-10-14 22:59:04 +0000
+++ tests/mirserver/Screen/screen_test.cpp	2016-03-11 11:36:44 +0000
@@ -42,9 +42,23 @@
     Screen::skipDBusRegistration = true;
 }
 
-TEST_F(ScreenTest, OrientationSensor)
-{
-    Screen *screen = new Screen(fakeOutput1);
+TEST_F(ScreenTest, OrientationSensorForExternalDisplay)
+{
+    Screen *screen = new Screen(fakeOutput1); // is external display (dvi)
+
+    // Default state should be disabled
+    ASSERT_FALSE(screen->orientationSensorEnabled());
+
+    screen->onDisplayPowerStateChanged(0,0);
+    ASSERT_FALSE(screen->orientationSensorEnabled());
+
+    screen->onDisplayPowerStateChanged(1,0);
+    ASSERT_FALSE(screen->orientationSensorEnabled());
+}
+
+TEST_F(ScreenTest, OrientationSensorForInternalDisplay)
+{
+    Screen *screen = new Screen(fakeOutput2); // is internal display
 
     // Default state should be active
     ASSERT_TRUE(screen->orientationSensorEnabled());

=== modified file 'tests/modules/ApplicationManager/application_manager_test.cpp'
--- tests/modules/ApplicationManager/application_manager_test.cpp	2016-02-12 00:07:09 +0000
+++ tests/modules/ApplicationManager/application_manager_test.cpp	2016-03-11 11:36:44 +0000
@@ -71,6 +71,13 @@
         ASSERT_EQ(Application::InternalState::Suspended, application->internalState());
     }
 
+    static inline qtmir::DesktopFileReader* createMockDesktopFileReader(const QString &appId, const QFileInfo &fi) {
+        using namespace ::testing;
+        auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, fi);
+        ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+        return mockDesktopFileReader;
+    }
+
 protected:
     virtual void SetUp() override {
         if (m_tempDir.isValid()) qputenv("XDG_CACHE_HOME", m_tempDir.path().toUtf8());
@@ -751,11 +758,7 @@
     const QString appId("testAppId");
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -789,11 +792,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -833,11 +833,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -869,16 +866,11 @@
 {
     using namespace ::testing;
     const QString appId("testAppId");
-    const QString desktopFilePath("testAppId.desktop");
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-    ON_CALL(*mockDesktopFileReader, file()).WillByDefault(Return(desktopFilePath));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -917,11 +909,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -960,11 +949,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -1006,11 +992,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -1051,11 +1034,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -1102,11 +1082,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -1160,11 +1137,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -1213,11 +1187,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -1252,11 +1223,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -1348,11 +1316,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -1407,12 +1372,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-    ON_CALL(*mockDesktopFileReader, file()).WillByDefault(Return(appId + ".desktop"));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -1465,11 +1426,7 @@
     ON_CALL(*taskController,appIdHasProcessId(_, procId2)).WillByDefault(Return(false));
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -1525,11 +1482,7 @@
     ON_CALL(*taskController,appIdHasProcessId(_, procId2)).WillByDefault(Return(false));
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -1583,11 +1536,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -1629,19 +1579,14 @@
 {
     using namespace testing;
     const QString appId("webapp");
-    const QString desktopFilePath("webapp.desktop");
     const pid_t procId = 5551;
 
     std::mutex mutex;
     std::condition_variable cv;
     bool done = false;
 
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-    ON_CALL(*mockDesktopFileReader, file()).WillByDefault(Return(desktopFilePath));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -1753,11 +1698,8 @@
     const quint64 procId = 12345;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
             .Times(1)
@@ -1821,11 +1763,8 @@
     const quint64 procId = 12345;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
             .Times(1)
@@ -1863,12 +1802,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-    ON_CALL(*mockDesktopFileReader, file()).WillByDefault(Return(appId + ".desktop"));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -1908,11 +1843,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -1957,11 +1889,8 @@
     const pid_t procId = 5551;
 
     // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -2032,12 +1961,8 @@
     const QString appId("testAppId");
     quint64 procId = 5551;
 
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-    ON_CALL(*mockDesktopFileReader, file()).WillByDefault(Return(appId + ".desktop"));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)
@@ -2085,10 +2010,8 @@
     const QString appId("testAppId");
     quint64 procId = 5551;
 
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _))
-        .WillByDefault(Invoke(
-            [](const QString &appId, const QFileInfo&) { return new FakeDesktopFileReader(appId); }
-        ));
+    ON_CALL(*taskController, primaryPidForAppId(appId)).WillByDefault(Return(procId));
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Invoke(createMockDesktopFileReader));
 
     EXPECT_CALL(*taskController, start(appId, _))
         .Times(1)