Merge lp:~unity-team/qtmir/sizeHints into lp:qtmir

[Michał Sawicz]

Surface Size Hints

* Are there any related MPs required for this MP to build/function as expected? Please list.
https://code.launchpad.net/~unity-team/unity-api/surfaceItemSizeHints/+merge/284890
lp:~unity-team/unity8/sizeHints

 * Did you perform an exploratory manual test run of your code change and any related functionality?
Yes. See unity8 MP.

 * If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
Not applicable

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:419
http://jenkins.qa.ubuntu.com/job/qtmir-ci/580/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/276/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/276/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/158/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/313/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/313/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/158/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/580/rebuild

review: Needs Fixing (continuous-integration)

[Lukáš Tinkl (lukas-kde)]

Text conflict in debian/control
Text conflict in src/modules/Unity/Application/mirsurface.cpp
Text conflict in src/modules/Unity/Application/mirsurface.h
Text conflict in src/platforms/mirserver/surfaceobserver.cpp
Text conflict in src/platforms/mirserver/surfaceobserver.h

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

> Text conflict in debian/control
> Text conflict in src/modules/Unity/Application/mirsurface.cpp
> Text conflict in src/modules/Unity/Application/mirsurface.h
> Text conflict in src/platforms/mirserver/surfaceobserver.cpp
> Text conflict in src/platforms/mirserver/surfaceobserver.h

Fixed.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:423
http://jenkins.qa.ubuntu.com/job/qtmir-ci/585/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/281/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/281/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/163/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/318/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/318/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/163/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/585/rebuild

review: Needs Fixing (continuous-integration)

[Lukáš Tinkl (lukas-kde)]

Code looks good, didn't test yet

review: Approve (code-review)

[Lukáš Tinkl (lukas-kde)]

pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=11)

Needs a bump to 12 here, otherwise it doesn't compile:

In file included from /home/ltinkl/bzr/qtmir/sizeHints/src/modules/Unity/Application/mirsurfacemanager.cpp:24:0:
/home/ltinkl/bzr/qtmir/sizeHints/src/modules/Unity/Application/mirsurface.h:80:9: error: 'int qtmir::MirSurface::minimumWidth() const' marked override, but does not override
     int minimumWidth() const override;

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

> pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=11)
>
> Needs a bump to 12 here, otherwise it doesn't compile:

Done

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:424
http://jenkins.qa.ubuntu.com/job/qtmir-ci/590/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/286/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/286/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/168/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/323/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/323/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/168/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/590/rebuild

review: Needs Fixing (continuous-integration)

[Lukáš Tinkl (lukas-kde)]

LGTM, worked fine in unity8

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:424
http://jenkins.qa.ubuntu.com/job/qtmir-ci/677/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/371/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/373/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/253/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/408/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/410/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/253/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/677/rebuild

review: Needs Fixing (continuous-integration)

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:424
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-1-ci/54/
Executed test runs:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-1-ci/54/rebuild

review: Needs Fixing (continuous-integration)

[lp:~unity-team/qtmir/sizeHints]

395. By Nick Dedekind on 2016-02-10

merged with trunk

396. By Daniel d'Andrada on 2016-02-11

Remove the useless TaskController

It was just forwarding calls between ApplicationManager and ApplicationCrontroller.
Had no logic of its own.

ApplicationCrontroller was then renamed to TaskController as the latter has a better API and it also keeps ApplicationManager code more or less untouched.

Tests have been improved a bit by better emulating TaskController behavior

397. By Daniel d'Andrada on 2016-02-11

Let shell decide the initial surface size

398. By Daniel d'Andrada on 2016-02-11

Surface Size Hints

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-12-07 12:23:29 +0000
+++ CMakeLists.txt	2016-02-03 11:35:51 +0000
@@ -20,7 +20,7 @@
 set(CMAKE_AUTOMOC ON)
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99 -Wall -Wextra -Werror")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -Wall -fno-strict-aliasing -Werror -Wextra")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wall -fno-strict-aliasing -Werror -Wextra")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
 
 

=== modified file 'src/modules/Unity/Application/CMakeLists.txt'
--- src/modules/Unity/Application/CMakeLists.txt	2015-10-13 09:00:00 +0000
+++ src/modules/Unity/Application/CMakeLists.txt	2016-02-03 11:35:51 +0000
@@ -31,7 +31,6 @@
     plugin.cpp
     applicationscreenshotprovider.cpp
     dbuswindowstack.cpp
-    taskcontroller.cpp
     mirsurfacemanager.cpp
     ubuntukeyboardinfo.cpp
     mirsurface.cpp
@@ -42,7 +41,9 @@
     session.cpp
     sessionmanager.cpp
     sharedwakelock.cpp
-    upstart/applicationcontroller.cpp
+    upstart/taskcontroller.cpp
+    timer.cpp
+    timesource.cpp
     tracepoints.c
     settings.cpp
 # We need to run moc on these headers
@@ -53,7 +54,7 @@
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h
 # Feed the automoc monster
     session_interface.h
-    applicationcontroller.h
+    taskcontroller.h
     settings_interface.h
     )
 

=== modified file 'src/modules/Unity/Application/application.cpp'
--- src/modules/Unity/Application/application.cpp	2016-01-22 16:32:39 +0000
+++ src/modules/Unity/Application/application.cpp	2016-02-03 11:35:51 +0000
@@ -20,7 +20,7 @@
 #include "desktopfilereader.h"
 #include "session.h"
 #include "sharedwakelock.h"
-#include "taskcontroller.h"
+#include "timer.h"
 
 // common
 #include <debughelpers.h>
@@ -52,7 +52,7 @@
     , m_session(nullptr)
     , m_requestedState(RequestedRunning)
     , m_processState(ProcessUnknown)
-    , m_closeTimer(0)
+    , m_closeTimer(nullptr)
     , m_exemptFromLifecycle(false)
 {
     qCDebug(QTMIR_APPLICATIONS) << "Application::Application - appId=" << desktopFileReader->appId();
@@ -66,6 +66,8 @@
     m_supportedOrientations = m_desktopData->supportedOrientations();
 
     m_rotatesWindowContents = m_desktopData->rotatesWindowContents();
+
+    setCloseTimer(new Timer);
 }
 
 Application::~Application()
@@ -101,6 +103,7 @@
         delete m_session;
     }
     delete m_desktopData;
+    delete m_closeTimer;
 }
 
 
@@ -433,11 +436,11 @@
 
 void Application::doClose()
 {
-    Q_ASSERT(m_closeTimer == 0);
+    Q_ASSERT(!m_closeTimer->isRunning());;
     Q_ASSERT(m_session != nullptr);
 
     m_session->close();
-    m_closeTimer = startTimer(3000);
+    m_closeTimer->start();
     setInternalState(InternalState::Closing);
 }
 
@@ -682,14 +685,6 @@
     Q_EMIT stopProcessRequested();
 }
 
-void Application::timerEvent(QTimerEvent *event)
-{
-    if (event->timerId() == m_closeTimer) {
-        m_closeTimer = 0;
-        stop();
-    }
-}
-
 bool Application::isTouchApp() const
 {
     return m_desktopData->isTouchApp();
@@ -790,4 +785,30 @@
     }
 }
 
+void Application::setCloseTimer(AbstractTimer *timer)
+{
+    delete m_closeTimer;
+
+    m_closeTimer = timer;
+    m_closeTimer->setInterval(3000);
+    m_closeTimer->setSingleShot(true);
+    connect(m_closeTimer, &Timer::timeout, this, &Application::stop);
+}
+
+QSize Application::initialSurfaceSize() const
+{
+    return m_initialSurfaceSize;
+}
+
+void Application::setInitialSurfaceSize(const QSize &size)
+{
+    qCDebug(QTMIR_APPLICATIONS).nospace() << "Application::setInitialSurfaceSize - appId=" << appId()
+        << " size=" << size;
+
+    if (size != m_initialSurfaceSize) {
+        m_initialSurfaceSize = size;
+        Q_EMIT initialSurfaceSizeChanged(m_initialSurfaceSize);
+    }
+}
+
 } // namespace qtmir

=== modified file 'src/modules/Unity/Application/application.h'
--- src/modules/Unity/Application/application.h	2015-12-07 12:23:29 +0000
+++ src/modules/Unity/Application/application.h	2016-02-03 11:35:51 +0000
@@ -43,6 +43,7 @@
 class DesktopFileReader;
 class Session;
 class SharedWakelock;
+class AbstractTimer;
 
 class Application : public unity::shell::application::ApplicationInfoInterface
 {
@@ -107,6 +108,8 @@
     bool isTouchApp() const override;
     bool exemptFromLifecycle() const override;
     void setExemptFromLifecycle(bool) override;
+    QSize initialSurfaceSize() const override;
+    void setInitialSurfaceSize(const QSize &size) override;
 
     void setStage(Stage stage);
 
@@ -133,6 +136,7 @@
 
     // for tests
     InternalState internalState() const { return m_state; }
+    void setCloseTimer(AbstractTimer *timer);
 
 Q_SIGNALS:
     void fullscreenChanged(bool fullscreen);
@@ -150,9 +154,6 @@
 
     void respawn();
 
-protected:
-    void timerEvent(QTimerEvent *event);
-
 private:
 
     QString longAppId() const;
@@ -187,8 +188,9 @@
     SessionInterface *m_session;
     RequestedState m_requestedState;
     ProcessState m_processState;
-    int m_closeTimer;
+    AbstractTimer *m_closeTimer;
     bool m_exemptFromLifecycle;
+    QSize m_initialSurfaceSize;
 
     friend class ApplicationManager;
     friend class SessionManager;

=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2016-01-22 16:32:39 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2016-02-03 11:35:51 +0000
@@ -22,8 +22,7 @@
 #include "session.h"
 #include "sharedwakelock.h"
 #include "proc_info.h"
-#include "taskcontroller.h"
-#include "upstart/applicationcontroller.h"
+#include "upstart/taskcontroller.h"
 #include "tracepoints.h" // generated from tracepoints.tp
 #include "settings.h"
 
@@ -32,8 +31,8 @@
 #include "nativeinterface.h"
 #include "sessionlistener.h"
 #include "sessionauthorizer.h"
-#include "taskcontroller.h"
 #include "logging.h"
+#include <mirwindowmanager.h>
 
 // mir
 #include <mir/scene/surface.h>
@@ -120,13 +119,12 @@
         return nullptr;
     }
 
-    auto mirServer = nativeInterface->m_mirServer;
+    auto mirServer = nativeInterface->m_mirServer.lock();
 
     SessionListener *sessionListener = static_cast<SessionListener*>(nativeInterface->nativeResourceForIntegration("SessionListener"));
     SessionAuthorizer *sessionAuthorizer = static_cast<SessionAuthorizer*>(nativeInterface->nativeResourceForIntegration("SessionAuthorizer"));
 
-    QSharedPointer<upstart::ApplicationController> appController(new upstart::ApplicationController());
-    QSharedPointer<TaskController> taskController(new TaskController(nullptr, appController));
+    QSharedPointer<TaskController> taskController(new upstart::TaskController());
     QSharedPointer<DesktopFileReader::Factory> fileReaderFactory(new DesktopFileReader::Factory());
     QSharedPointer<ProcInfo> procInfo(new ProcInfo());
     QSharedPointer<SharedWakelock> sharedWakelock(new SharedWakelock);
@@ -149,6 +147,9 @@
     connectToSessionListener(appManager, sessionListener);
     connectToSessionAuthorizer(appManager, sessionAuthorizer);
     connectToTaskController(appManager, taskController.data());
+    connect(mirServer->windowManager(), &MirWindowManager::sessionAboutToCreateSurface,
+        appManager, &ApplicationManager::onSessionAboutToCreateSurface,
+        Qt::BlockingQueuedConnection);
 
     // Emit signal to notify Upstart that Mir is ready to receive client connections
     // see http://upstart.ubuntu.com/cookbook/#expect-stop
@@ -461,15 +462,14 @@
         m_closingApplications.removeAll(application);
     });
     m_closingApplications.append(application);
-    application->close();
     return true;
 }
 
-void ApplicationManager::onProcessFailed(const QString &appId, const bool duringStartup)
+void ApplicationManager::onProcessFailed(const QString &appId, TaskController::Error error)
 {
     // Applications fail if they fail to launch, crash or are killed.
 
-    qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onProcessFailed - appId=" << appId << "duringStartup=" << duringStartup;
+    qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onProcessFailed - appId=" << appId;
 
     Application *application = findApplication(appId);
     if (!application) {
@@ -478,7 +478,7 @@
         return;
     }
 
-    Q_UNUSED(duringStartup); // FIXME(greyback) upstart reports app that fully started up & crashes as failing during startup??
+    Q_UNUSED(error); // FIXME(greyback) upstart reports app that fully started up & crashes as failing during startup??
     application->setProcessState(Application::ProcessFailed);
     application->setPid(0);
 }
@@ -862,4 +862,23 @@
     return nullptr;
 }
 
+void ApplicationManager::onSessionAboutToCreateSurface(
+        const std::shared_ptr<mir::scene::Session> &session, int type, QSize &size)
+{
+    if (type == mir_surface_type_normal) {
+        Application* application = findApplicationWithSession(session);
+
+        if (application) {
+            qCDebug(QTMIR_APPLICATIONS).nospace() << "ApplicationManager::onSessionAboutToCreateSurface appId="
+                << application->appId();
+            size = application->initialSurfaceSize();
+        } else {
+            qCDebug(QTMIR_APPLICATIONS).nospace() << "ApplicationManager::onSessionAboutToCreateSurface unknown app";
+        }
+    } else {
+        qCDebug(QTMIR_APPLICATIONS).nospace() << "ApplicationManager::onSessionAboutToCreateSurface type=" << type
+            << " NOOP";
+    }
+}
+
 } // namespace qtmir

=== modified file 'src/modules/Unity/Application/application_manager.h'
--- src/modules/Unity/Application/application_manager.h	2015-12-07 12:23:29 +0000
+++ src/modules/Unity/Application/application_manager.h	2016-02-03 11:35:51 +0000
@@ -30,6 +30,7 @@
 // local
 #include "application.h"
 #include "desktopfilereader.h"
+#include "taskcontroller.h"
 
 namespace mir {
     namespace scene {
@@ -47,7 +48,6 @@
 class MirSurfaceManager;
 class ProcInfo;
 class SharedWakelock;
-class TaskController;
 class SettingsInterface;
 
 class ApplicationManager : public unity::shell::application::ApplicationManagerInterface
@@ -127,7 +127,7 @@
     void onProcessStarting(const QString& appId);
     void onProcessStopped(const QString& appId);
     void onProcessSuspended(const QString& appId);
-    void onProcessFailed(const QString& appId, const bool duringStartup);
+    void onProcessFailed(const QString& appId, TaskController::Error error);
     void onFocusRequested(const QString& appId);
     void onResumeRequested(const QString& appId);
 
@@ -137,6 +137,8 @@
 
 private Q_SLOTS:
     void onAppDataChanged(const int role);
+    void onSessionAboutToCreateSurface(const std::shared_ptr<mir::scene::Session> &session,
+                                       int type, QSize &size);
 
 private:
     void setFocused(Application *application);

=== modified file 'src/modules/Unity/Application/mirsurface.cpp'
--- src/modules/Unity/Application/mirsurface.cpp	2016-01-22 17:51:40 +0000
+++ src/modules/Unity/Application/mirsurface.cpp	2016-02-03 11:35:51 +0000
@@ -171,7 +171,8 @@
 MirSurface::MirSurface(std::shared_ptr<mir::scene::Surface> surface,
         SessionInterface* session,
         mir::shell::Shell* shell,
-        std::shared_ptr<SurfaceObserver> observer)
+        std::shared_ptr<SurfaceObserver> observer,
+        const SizeHints &sizeHints)
     : MirSurfaceInterface()
     , m_surface(surface)
     , m_session(session)
@@ -182,12 +183,25 @@
     , m_currentFrameNumber(0)
     , m_live(true)
 {
+    m_minimumWidth = sizeHints.minWidth;
+    m_minimumHeight = sizeHints.minHeight;
+    m_maximumWidth = sizeHints.maxWidth;
+    m_maximumHeight = sizeHints.maxHeight;
+    m_widthIncrement = sizeHints.widthIncrement;
+    m_heightIncrement = sizeHints.heightIncrement;
+
     m_surfaceObserver = observer;
     if (observer) {
         connect(observer.get(), &SurfaceObserver::framesPosted, this, &MirSurface::onFramesPostedObserved);
         connect(observer.get(), &SurfaceObserver::attributeChanged, this, &MirSurface::onAttributeChanged);
         connect(observer.get(), &SurfaceObserver::nameChanged, this, &MirSurface::nameChanged);
         connect(observer.get(), &SurfaceObserver::cursorChanged, this, &MirSurface::setCursor);
+        connect(observer.get(), &SurfaceObserver::minimumWidthChanged, this, &MirSurface::setMinimumWidth);
+        connect(observer.get(), &SurfaceObserver::minimumHeightChanged, this, &MirSurface::setMinimumHeight);
+        connect(observer.get(), &SurfaceObserver::maximumWidthChanged, this, &MirSurface::setMaximumWidth);
+        connect(observer.get(), &SurfaceObserver::maximumHeightChanged, this, &MirSurface::setMaximumHeight);
+        connect(observer.get(), &SurfaceObserver::widthIncrementChanged, this, &MirSurface::setWidthIncrement);
+        connect(observer.get(), &SurfaceObserver::heightIncrementChanged, this, &MirSurface::setHeightIncrement);
         observer->setListener(this);
     }
 
@@ -754,3 +768,81 @@
     m_cursor = cursor;
     Q_EMIT cursorChanged(m_cursor);
 }
+
+int MirSurface::minimumWidth() const
+{
+    return m_minimumWidth;
+}
+
+int MirSurface::minimumHeight() const
+{
+    return m_minimumHeight;
+}
+
+int MirSurface::maximumWidth() const
+{
+    return m_maximumWidth;
+}
+
+int MirSurface::maximumHeight() const
+{
+    return m_maximumHeight;
+}
+
+int MirSurface::widthIncrement() const
+{
+    return m_widthIncrement;
+}
+
+int MirSurface::heightIncrement() const
+{
+    return m_heightIncrement;
+}
+
+void MirSurface::setMinimumWidth(int value)
+{
+    if (value != m_minimumWidth) {
+        m_minimumWidth = value;
+        Q_EMIT minimumWidthChanged(value);
+    }
+}
+
+void MirSurface::setMinimumHeight(int value)
+{
+    if (value != m_minimumHeight) {
+        m_minimumHeight = value;
+        Q_EMIT minimumHeightChanged(value);
+    }
+}
+
+void MirSurface::setMaximumWidth(int value)
+{
+    if (value != m_maximumWidth) {
+        m_maximumWidth = value;
+        Q_EMIT maximumWidthChanged(value);
+    }
+}
+
+void MirSurface::setMaximumHeight(int value)
+{
+    if (value != m_maximumHeight) {
+        m_maximumHeight = value;
+        Q_EMIT maximumHeightChanged(value);
+    }
+}
+
+void MirSurface::setWidthIncrement(int value)
+{
+    if (value != m_widthIncrement) {
+        m_widthIncrement = value;
+        Q_EMIT widthIncrementChanged(value);
+    }
+}
+
+void MirSurface::setHeightIncrement(int value)
+{
+    if (value != m_heightIncrement) {
+        m_heightIncrement = value;
+        Q_EMIT heightIncrementChanged(value);
+    }
+}

=== modified file 'src/modules/Unity/Application/mirsurface.h'
--- src/modules/Unity/Application/mirsurface.h	2015-12-10 13:08:43 +0000
+++ src/modules/Unity/Application/mirsurface.h	2016-02-03 11:35:51 +0000
@@ -31,6 +31,9 @@
 #include "mirbuffersgtexture.h"
 #include "session.h"
 
+// mirserver
+#include "sizehints.h"
+
 // mir
 #include <mir/scene/surface.h>
 #include <mir_toolkit/common.h>
@@ -49,7 +52,8 @@
     MirSurface(std::shared_ptr<mir::scene::Surface> surface,
             SessionInterface* session,
             mir::shell::Shell *shell,
-            std::shared_ptr<SurfaceObserver> observer);
+            std::shared_ptr<SurfaceObserver> observer,
+            const SizeHints &);
     virtual ~MirSurface();
 
     ////
@@ -73,6 +77,13 @@
     Mir::OrientationAngle orientationAngle() const override;
     void setOrientationAngle(Mir::OrientationAngle angle) override;
 
+    int minimumWidth() const override;
+    int minimumHeight() const override;
+    int maximumWidth() const override;
+    int maximumHeight() const override;
+    int widthIncrement() const override;
+    int heightIncrement() const override;
+
     ////
     // qtmir::MirSurfaceInterface
 
@@ -124,6 +135,13 @@
 public Q_SLOTS:
     void onCompositorSwappedBuffers() override;
 
+    void setMinimumWidth(int) override;
+    void setMinimumHeight(int) override;
+    void setMaximumWidth(int) override;
+    void setMaximumHeight(int) override;
+    void setWidthIncrement(int) override;
+    void setHeightIncrement(int) override;
+
 private Q_SLOTS:
     void dropPendingBuffer();
     void onAttributeChanged(const MirSurfaceAttrib, const int);
@@ -165,6 +183,13 @@
     QSize m_size;
 
     QCursor m_cursor;
+
+    int m_minimumWidth{0};
+    int m_minimumHeight{0};
+    int m_maximumWidth{0};
+    int m_maximumHeight{0};
+    int m_widthIncrement{0};
+    int m_heightIncrement{0};
 };
 
 } // namespace qtmir

=== modified file 'src/modules/Unity/Application/mirsurfaceinterface.h'
--- src/modules/Unity/Application/mirsurfaceinterface.h	2015-12-10 13:08:43 +0000
+++ src/modules/Unity/Application/mirsurfaceinterface.h	2016-02-03 11:35:51 +0000
@@ -92,6 +92,13 @@
 public Q_SLOTS:
     virtual void onCompositorSwappedBuffers() = 0;
 
+    virtual void setMinimumWidth(int) = 0;
+    virtual void setMinimumHeight(int) = 0;
+    virtual void setMaximumWidth(int) = 0;
+    virtual void setMaximumHeight(int) = 0;
+    virtual void setWidthIncrement(int) = 0;
+    virtual void setHeightIncrement(int) = 0;
+
 Q_SIGNALS:
     void firstFrameDrawn();
     void framesPosted();

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.cpp'
--- src/modules/Unity/Application/mirsurfacemanager.cpp	2015-12-07 12:02:48 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.cpp	2016-02-03 11:35:51 +0000
@@ -34,6 +34,7 @@
 #include "mirserver.h"
 #include "sessionlistener.h"
 #include "logging.h"
+#include "sizehints.h"
 
 Q_LOGGING_CATEGORY(QTMIR_SURFACES, "qtmir.surfaces")
 
@@ -97,13 +98,14 @@
 
 void MirSurfaceManager::onSessionCreatedSurface(const mir::scene::Session *mirSession,
                                                 const std::shared_ptr<mir::scene::Surface> &surface,
-                                                const std::shared_ptr<SurfaceObserver> &observer)
+                                                const std::shared_ptr<SurfaceObserver> &observer,
+                                                qtmir::SizeHints sizeHints)
 {
     qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::onSessionCreatedSurface - mirSession=" << mirSession
                             << "surface=" << surface.get() << "surface.name=" << surface->name().c_str();
 
     SessionInterface* session = m_sessionManager->findSession(mirSession);
-    auto qmlSurface = new MirSurface(surface, session, m_shell, observer);
+    auto qmlSurface = new MirSurface(surface, session, m_shell, observer, sizeHints);
     {
         QMutexLocker lock(&m_mutex);
         m_mirSurfaceToQmlSurfaceHash.insert(surface.get(), qmlSurface);

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.h'
--- src/modules/Unity/Application/mirsurfacemanager.h	2015-08-31 09:51:28 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.h	2016-02-03 11:35:51 +0000
@@ -29,6 +29,8 @@
 // Mir
 #include <mir_toolkit/common.h>
 
+// mirserver qpa
+#include <sizehints.h>
 
 namespace mir {
     namespace scene {
@@ -71,7 +73,8 @@
 public Q_SLOTS:
     void onSessionCreatedSurface(const mir::scene::Session *,
                                  const std::shared_ptr<mir::scene::Surface> &,
-                                 std::shared_ptr<SurfaceObserver> const&);
+                                 std::shared_ptr<SurfaceObserver> const&,
+                                 qtmir::SizeHints);
     void onSessionDestroyingSurface(const mir::scene::Session *, const std::shared_ptr<mir::scene::Surface> &);
 
 protected:

=== removed file 'src/modules/Unity/Application/taskcontroller.cpp'
--- src/modules/Unity/Application/taskcontroller.cpp	2015-10-08 11:20:30 +0000
+++ src/modules/Unity/Application/taskcontroller.cpp	1970-01-01 00:00:00 +0000
@@ -1,119 +0,0 @@
-/*
- * Copyright (C) 2013-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/>.
- */
-
-// local
-#include "taskcontroller.h"
-#include "logging.h"
-
-// Qt
-#include <QStringList>
-
-// STL
-#include <mutex>
-
-// std
-#include <csignal>
-#include <unistd.h>
-
-namespace qtmir
-{
-
-TaskController::TaskController(
-        QObject *parent,
-        const QSharedPointer<ApplicationController> &appController) :
-    QObject(parent),
-    m_appController(appController)
-{
-    connect(m_appController.data(),
-            &ApplicationController::applicationAboutToBeStarted,
-            this,
-            &TaskController::processStarting);
-
-    connect(m_appController.data(),
-            &ApplicationController::applicationStopped,
-            this,
-            &TaskController::processStopped);
-
-    connect(m_appController.data(),
-            &ApplicationController::applicationPaused,
-            this,
-            &TaskController::processSuspended);
-
-    connect(m_appController.data(),
-            &ApplicationController::applicationFocusRequest,
-            this,
-            &TaskController::focusRequested);
-
-    connect(m_appController.data(),
-            &ApplicationController::applicationResumeRequested,
-            this,
-            &TaskController::resumeRequested);
-
-    connect(m_appController.data(),
-            &ApplicationController::applicationError,
-            this,
-            &TaskController::onApplicationError);
-}
-
-TaskController::~TaskController()
-{
-}
-
-bool TaskController::start(const QString& appId, const QStringList& arguments)
-{
-    qCDebug(QTMIR_APPLICATIONS) << "TaskController::start - appId=" << appId;
-    return m_appController->startApplicationWithAppIdAndArgs(appId, arguments);
-}
-
-bool TaskController::stop(const QString& appId)
-{
-    qCDebug(QTMIR_APPLICATIONS) << "TaskController::stop - appId=" << appId;
-    auto result = m_appController->stopApplicationWithAppId(appId);
-    if (!result)
-        qCDebug(QTMIR_APPLICATIONS) << "TaskController::stopApplication - FAILED to stop appId=" << appId;
-
-    return result;
-}
-
-bool TaskController::appIdHasProcessId(const QString& appId, const pid_t pid) const
-{
-    qCDebug(QTMIR_APPLICATIONS) << "TaskController::isApplicationPid - appId=" << appId << "pid=" << pid;
-    return m_appController->appIdHasProcessId(pid, appId);
-}
-
-QFileInfo TaskController::findDesktopFileForAppId(const QString &appId) const
-{
-    return m_appController->findDesktopFileForAppId(appId);
-}
-
-bool TaskController::suspend(const QString &appId)
-{
-    qCDebug(QTMIR_APPLICATIONS) << "TaskController::suspend - appId=" << appId;
-    return m_appController->pauseApplicationWithAppId(appId);
-}
-
-bool TaskController::resume(const QString &appId)
-{
-    qCDebug(QTMIR_APPLICATIONS) << "TaskController::resume - appId=" << appId;
-    return m_appController->resumeApplicationWithAppId(appId);
-}
-
-void TaskController::onApplicationError(const QString& id, ApplicationController::Error error)
-{
-    Q_EMIT processFailed(id, (error == ApplicationController::Error::APPLICATION_FAILED_TO_START) );
-}
-
-} // namespace qtmir

=== renamed file 'src/modules/Unity/Application/applicationcontroller.h' => 'src/modules/Unity/Application/taskcontroller.h'
--- src/modules/Unity/Application/applicationcontroller.h	2015-08-11 12:08:32 +0000
+++ src/modules/Unity/Application/taskcontroller.h	2016-02-03 11:35:51 +0000
@@ -15,8 +15,8 @@
  *
  */
 
-#ifndef APPLICATION_CONTROLLER_H
-#define APPLICATION_CONTROLLER_H
+#ifndef QTMIR_TASK_CONTROLLER_H
+#define QTMIR_TASK_CONTROLLER_H
 
 #include <QObject>
 #include <QString>
@@ -26,7 +26,7 @@
 namespace qtmir
 {
 
-class ApplicationController : public QObject
+class TaskController : public QObject
 {
     Q_OBJECT
 
@@ -37,36 +37,36 @@
         APPLICATION_FAILED_TO_START
     };
 
-    ApplicationController(const ApplicationController&) = delete;
-    virtual ~ApplicationController() = default;
+    TaskController(const TaskController&) = delete;
+    virtual ~TaskController() = default;
 
-    ApplicationController& operator=(const ApplicationController&) = delete;
+    TaskController& operator=(const TaskController&) = delete;
 
     virtual pid_t primaryPidForAppId(const QString &appId) = 0;
-    virtual bool appIdHasProcessId(pid_t pid, const QString &appId) = 0;
-
-    virtual bool stopApplicationWithAppId(const QString &appId) = 0;
-    virtual bool startApplicationWithAppIdAndArgs(const QString &appId, const QStringList &arguments) = 0;
-
-    virtual bool pauseApplicationWithAppId(const QString &appId) = 0;
-    virtual bool resumeApplicationWithAppId(const QString &appId) = 0;
+    virtual bool appIdHasProcessId(const QString &appId, pid_t pid) = 0;
+
+    virtual bool stop(const QString &appId) = 0;
+    virtual bool start(const QString &appId, const QStringList &arguments) = 0;
+
+    virtual bool suspend(const QString &appId) = 0;
+    virtual bool resume(const QString &appId) = 0;
 
     virtual QFileInfo findDesktopFileForAppId(const QString &appId) const = 0;
 
 Q_SIGNALS:
-    void applicationAboutToBeStarted(const QString &appId);
+    void processStarting(const QString &appId);
     void applicationStarted(const QString &appId);
-    void applicationStopped(const QString &appId);
-    void applicationPaused(const QString &appId);
-    void applicationFocusRequest(const QString &appId);
-    void applicationResumeRequested(const QString &appId);
+    void processStopped(const QString &appId);
+    void processSuspended(const QString &appId);
+    void focusRequested(const QString &appId);
+    void resumeRequested(const QString &appId);
 
-    void applicationError(const QString &appId, ApplicationController::Error error);
+    void processFailed(const QString &appId, TaskController::Error error);
 
 protected:
-    ApplicationController() = default;
+    TaskController() = default;
 };
 
 } // namespace qtmir
 
-#endif // APPLICATION_CONTROLLER_H
+#endif // QTMIR_TASK_CONTROLLER_H

=== removed file 'src/modules/Unity/Application/taskcontroller.h'
--- src/modules/Unity/Application/taskcontroller.h	2015-10-08 11:20:30 +0000
+++ src/modules/Unity/Application/taskcontroller.h	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2013-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 TASKCONTROLLER_H
-#define TASKCONTROLLER_H
-
-#include <QObject>
-
-#include "application.h"
-#include "applicationcontroller.h"
-
-namespace qtmir
-{
-
-class TaskController : public QObject
-{
-    Q_OBJECT
-public:
-    TaskController(
-            QObject *parent,
-            const QSharedPointer<ApplicationController> &appController);
-    ~TaskController();
-
-    bool start(const QString &appId, const QStringList &args);
-    bool stop(const QString &appId);
-
-    bool suspend(const QString &appId);
-    bool resume(const QString &appId);
-
-    bool appIdHasProcessId(const QString &appId, const pid_t pid) const;
-    QFileInfo findDesktopFileForAppId(const QString &appId) const;
-
-Q_SIGNALS:
-    void processStarting(const QString &appId);
-    void processStopped(const QString &appId);
-    void processSuspended(const QString &appId);
-    void processFailed(const QString &appId, const bool duringStartup);
-    void focusRequested(const QString &appId);
-    void resumeRequested(const QString &appId);
-
-private Q_SLOTS:
-    void onApplicationError(const QString &id, ApplicationController::Error error);
-
-private:
-    const QSharedPointer<ApplicationController> m_appController;
-};
-
-} // namespace qtmir
-
-#endif // TASKCONTROLLER_H

=== added file 'src/modules/Unity/Application/timer.cpp'
--- src/modules/Unity/Application/timer.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/timer.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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/>.
+ */
+
+#include "timer.h"
+
+using namespace qtmir;
+
+Timer::Timer(QObject *parent) : AbstractTimer(parent)
+{
+    m_timer.setSingleShot(false);
+    connect(&m_timer, &QTimer::timeout, this, &AbstractTimer::timeout);
+}
+
+int Timer::interval() const
+{
+    return m_timer.interval();
+}
+
+void Timer::setInterval(int msecs)
+{
+    m_timer.setInterval(msecs);
+}
+
+void Timer::start()
+{
+    m_timer.start();
+    AbstractTimer::start();
+}
+
+void Timer::stop()
+{
+    m_timer.stop();
+    AbstractTimer::stop();
+}
+
+bool Timer::isSingleShot() const
+{
+    return m_timer.isSingleShot();
+}
+
+void Timer::setSingleShot(bool value)
+{
+    m_timer.setSingleShot(value);
+}
+
+/////////////////////////////////// FakeTimer //////////////////////////////////
+
+FakeTimer::FakeTimer(const SharedTimeSource &timeSource, QObject *parent)
+    : qtmir::AbstractTimer(parent)
+    , m_interval(0)
+    , m_singleShot(false)
+    , m_timeSource(timeSource)
+{
+}
+
+void FakeTimer::update()
+{
+    if (!isRunning()) {
+        return;
+    }
+
+    if (m_nextTimeoutTime <= m_timeSource->msecsSinceReference()) {
+        if (isSingleShot()) {
+            stop();
+        } else {
+            m_nextTimeoutTime += interval();
+        }
+        Q_EMIT timeout();
+    }
+}
+
+void FakeTimer::start()
+{
+    AbstractTimer::start();
+    m_nextTimeoutTime = m_timeSource->msecsSinceReference() + (qint64)interval();
+}
+
+int FakeTimer::interval() const
+{
+    return m_interval;
+}
+
+void FakeTimer::setInterval(int msecs)
+{
+    m_interval = msecs;
+}
+
+bool FakeTimer::isSingleShot() const
+{
+    return m_singleShot;
+}
+
+void FakeTimer::setSingleShot(bool value)
+{
+    m_singleShot = value;
+}

=== added file 'src/modules/Unity/Application/timer.h'
--- src/modules/Unity/Application/timer.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/timer.h	2016-02-03 11:35:51 +0000
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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/>.
+ */
+
+#ifndef QTMIR_TIMER_H
+#define QTMIR_TIMER_H
+
+#include "timesource.h"
+
+#include <QObject>
+#include <QPointer>
+#include <QTimer>
+
+namespace qtmir {
+
+/* Defines an interface for a Timer. Useful for tests. */
+class AbstractTimer : public QObject
+{
+    Q_OBJECT
+public:
+    AbstractTimer(QObject *parent) : QObject(parent), m_isRunning(false) {}
+    virtual int interval() const = 0;
+    virtual void setInterval(int msecs) = 0;
+    virtual void start() { m_isRunning = true; }
+    virtual void stop() { m_isRunning = false; }
+    bool isRunning() const { return m_isRunning; }
+    virtual bool isSingleShot() const = 0;
+    virtual void setSingleShot(bool value) = 0;
+Q_SIGNALS:
+    void timeout();
+private:
+    bool m_isRunning;
+};
+
+/* Essentially a QTimer wrapper */
+class Timer : public AbstractTimer
+{
+    Q_OBJECT
+public:
+    Timer(QObject *parent = nullptr);
+
+    int interval() const override;
+    void setInterval(int msecs) override;
+    void start() override;
+    void stop() override;
+    bool isSingleShot() const override;
+    void setSingleShot(bool value) override;
+private:
+    QTimer m_timer;
+};
+
+/* For tests */
+class FakeTimer : public AbstractTimer
+{
+    Q_OBJECT
+public:
+    FakeTimer(const SharedTimeSource &timeSource, QObject *parent = nullptr);
+
+    void update();
+    qint64 nextTimeoutTime() const { return m_nextTimeoutTime; }
+
+    int interval() const override;
+    void setInterval(int msecs) override;
+    void start() override;
+    bool isSingleShot() const override;
+    void setSingleShot(bool value) override;
+private:
+    int m_interval;
+    bool m_singleShot;
+    SharedTimeSource m_timeSource;
+    qint64 m_nextTimeoutTime;
+};
+
+} // namespace qtmir
+
+#endif // QTMIR_TIMER_H

=== added file 'src/modules/Unity/Application/timesource.cpp'
--- src/modules/Unity/Application/timesource.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/timesource.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,48 @@
+/*
+ * 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, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+#include "timesource.h"
+
+#include <QElapsedTimer>
+
+namespace qtmir {
+class RealTimeSourcePrivate {
+public:
+    QElapsedTimer timer;
+};
+}
+
+using namespace qtmir;
+
+RealTimeSource::RealTimeSource()
+    : TimeSource()
+    , d(new RealTimeSourcePrivate)
+{
+    d->timer.start();
+}
+
+RealTimeSource::~RealTimeSource()
+{
+    delete d;
+}
+
+qint64 RealTimeSource::msecsSinceReference()
+{
+    return d->timer.elapsed();
+}

=== added file 'src/modules/Unity/Application/timesource.h'
--- src/modules/Unity/Application/timesource.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/timesource.h	2016-02-03 11:35:51 +0000
@@ -0,0 +1,61 @@
+/*
+ * 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, as
+ * published by the  Free Software Foundation; either version 2.1 or 3.0
+ * of the License.
+ *
+ * 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 applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>
+ */
+
+#ifndef QTMIR_TIMESOURCE_H
+#define QTMIR_TIMESOURCE_H
+
+#include <QSharedPointer>
+
+namespace qtmir {
+/*
+    Interface for a time source.
+ */
+class TimeSource {
+public:
+    virtual ~TimeSource() {}
+    /* Returns the current time in milliseconds since some reference time in the past. */
+    virtual qint64 msecsSinceReference() = 0;
+};
+typedef QSharedPointer<TimeSource> SharedTimeSource;
+
+/*
+    Implementation of a time source
+ */
+class RealTimeSourcePrivate;
+class RealTimeSource : public TimeSource {
+public:
+    RealTimeSource();
+    virtual ~RealTimeSource();
+    qint64 msecsSinceReference() override;
+private:
+    RealTimeSourcePrivate *d;
+};
+
+/*
+    A fake time source, useful for tests
+ */
+class FakeTimeSource : public TimeSource {
+public:
+    FakeTimeSource() { m_msecsSinceReference = 0; }
+    qint64 msecsSinceReference() override { return m_msecsSinceReference; }
+    qint64 m_msecsSinceReference;
+};
+
+} // namespace qtmir
+
+#endif // QTMIR_TIMESOURCE_H

=== renamed file 'src/modules/Unity/Application/upstart/applicationcontroller.cpp' => 'src/modules/Unity/Application/upstart/taskcontroller.cpp'
--- src/modules/Unity/Application/upstart/applicationcontroller.cpp	2015-05-27 21:07:45 +0000
+++ src/modules/Unity/Application/upstart/taskcontroller.cpp	2016-02-03 11:35:51 +0000
@@ -15,7 +15,7 @@
  *
  */
 
-#include "applicationcontroller.h"
+#include "taskcontroller.h"
 
 // qtmir
 #include <logging.h>
@@ -33,7 +33,7 @@
 namespace upstart
 {
 
-struct ApplicationController::Private
+struct TaskController::Private
 {
     UbuntuAppLaunchAppObserver preStartCallback = nullptr;
     UbuntuAppLaunchAppObserver startedCallback = nullptr;
@@ -100,50 +100,50 @@
 
 } // namespace
 
-ApplicationController::ApplicationController()
-    : qtmir::ApplicationController(),
+TaskController::TaskController()
+    : qtmir::TaskController(),
       impl(new Private())
 {
     impl->preStartCallback = [](const gchar * appId, gpointer userData) {
-        auto thiz = static_cast<ApplicationController*>(userData);
-        Q_EMIT(thiz->applicationAboutToBeStarted(toShortAppIdIfPossible(appId)));
+        auto thiz = static_cast<TaskController*>(userData);
+        Q_EMIT(thiz->processStarting(toShortAppIdIfPossible(appId)));
     };
 
     impl->startedCallback = [](const gchar * appId, gpointer userData) {
-        auto thiz = static_cast<ApplicationController*>(userData);
+        auto thiz = static_cast<TaskController*>(userData);
         Q_EMIT(thiz->applicationStarted(toShortAppIdIfPossible(appId)));
     };
 
     impl->stopCallback = [](const gchar * appId, gpointer userData) {
-        auto thiz = static_cast<ApplicationController*>(userData);
-        Q_EMIT(thiz->applicationStopped(toShortAppIdIfPossible(appId)));
+        auto thiz = static_cast<TaskController*>(userData);
+        Q_EMIT(thiz->processStopped(toShortAppIdIfPossible(appId)));
     };
 
     impl->focusCallback = [](const gchar * appId, gpointer userData) {
-        auto thiz = static_cast<ApplicationController*>(userData);
-        Q_EMIT(thiz->applicationFocusRequest(toShortAppIdIfPossible(appId)));
+        auto thiz = static_cast<TaskController*>(userData);
+        Q_EMIT(thiz->focusRequested(toShortAppIdIfPossible(appId)));
     };
 
     impl->resumeCallback = [](const gchar * appId, gpointer userData) {
-        auto thiz = static_cast<ApplicationController*>(userData);
-        Q_EMIT(thiz->applicationResumeRequested(toShortAppIdIfPossible(appId)));
+        auto thiz = static_cast<TaskController*>(userData);
+        Q_EMIT(thiz->resumeRequested(toShortAppIdIfPossible(appId)));
     };
 
     impl->pausedCallback = [](const gchar * appId, GPid *, gpointer userData) {
-        auto thiz = static_cast<ApplicationController*>(userData);
-        Q_EMIT(thiz->applicationPaused(toShortAppIdIfPossible(appId)));
+        auto thiz = static_cast<TaskController*>(userData);
+        Q_EMIT(thiz->processSuspended(toShortAppIdIfPossible(appId)));
     };
 
     impl->failureCallback = [](const gchar * appId, UbuntuAppLaunchAppFailed failureType, gpointer userData) {
-        ApplicationController::Error error;
+        TaskController::Error error;
         switch(failureType)
         {
-        case UBUNTU_APP_LAUNCH_APP_FAILED_CRASH: error = ApplicationController::Error::APPLICATION_CRASHED;
-        case UBUNTU_APP_LAUNCH_APP_FAILED_START_FAILURE: error = ApplicationController::Error::APPLICATION_FAILED_TO_START;
+        case UBUNTU_APP_LAUNCH_APP_FAILED_CRASH: error = TaskController::Error::APPLICATION_CRASHED;
+        case UBUNTU_APP_LAUNCH_APP_FAILED_START_FAILURE: error = TaskController::Error::APPLICATION_FAILED_TO_START;
         }
 
-        auto thiz = static_cast<ApplicationController*>(userData);
-        Q_EMIT(thiz->applicationError(toShortAppIdIfPossible(appId), error));
+        auto thiz = static_cast<TaskController*>(userData);
+        Q_EMIT(thiz->processFailed(toShortAppIdIfPossible(appId), error));
     };
 
     ubuntu_app_launch_observer_add_app_starting(impl->preStartCallback, this);
@@ -155,7 +155,7 @@
     ubuntu_app_launch_observer_add_app_failed(impl->failureCallback, this);
 }
 
-ApplicationController::~ApplicationController()
+TaskController::~TaskController()
 {
     ubuntu_app_launch_observer_delete_app_starting(impl->preStartCallback, this);
     ubuntu_app_launch_observer_delete_app_started(impl->startedCallback, this);
@@ -166,30 +166,30 @@
     ubuntu_app_launch_observer_delete_app_failed(impl->failureCallback, this);
 }
 
-pid_t ApplicationController::primaryPidForAppId(const QString& appId)
+pid_t TaskController::primaryPidForAppId(const QString& appId)
 {
     GPid pid = ubuntu_app_launch_get_primary_pid(toLongAppIdIfPossible(appId).toLatin1().constData());
     if (!pid)
-        qDebug() << "ApplicationController::primaryPidForAppId FAILED to get PID for appId=" << appId;
+        qDebug() << "TaskController::primaryPidForAppId FAILED to get PID for appId=" << appId;
 
     return pid;
 }
 
-bool ApplicationController::appIdHasProcessId(pid_t pid, const QString& appId)
+bool TaskController::appIdHasProcessId(const QString& appId, pid_t pid)
 {
     return ubuntu_app_launch_pid_in_app_id(pid, toLongAppIdIfPossible(appId).toLatin1().constData());
 }
 
-bool ApplicationController::stopApplicationWithAppId(const QString& appId)
+bool TaskController::stop(const QString& appId)
 {
     auto result = ubuntu_app_launch_stop_application(toLongAppIdIfPossible(appId).toLatin1().constData());
     if (!result)
-        qDebug() << "ApplicationController::stopApplication FAILED to stop appId=" << appId;
+        qDebug() << "TaskController::stopApplication FAILED to stop appId=" << appId;
 
     return result;
 }
 
-bool ApplicationController::startApplicationWithAppIdAndArgs(const QString& appId, const QStringList& arguments)
+bool TaskController::start(const QString& appId, const QStringList& arguments)
 {
     // Convert arguments QStringList into format suitable for ubuntu-app-launch
     // The last item should be null, which is done by g_new0, we just don't fill it.
@@ -206,33 +206,33 @@
     g_strfreev(upstartArgs);
 
     if (!result)
-        qDebug() << "Application::Controller::startApplicationWithAppIdAndArgs FAILED to start appId" << appId;
+        qDebug() << "TaskController::start FAILED to start appId" << appId;
 
     return result;
 }
 
-bool ApplicationController::pauseApplicationWithAppId(const QString& appId)
+bool TaskController::suspend(const QString& appId)
 {
     auto result = ubuntu_app_launch_pause_application(toLongAppIdIfPossible(appId).toLatin1().constData());
     if (!result)
-        qDebug() << "ApplicationController::pauseApplication FAILED to pause appId=" << appId;
+        qDebug() << "TaskController::pauseApplication FAILED to pause appId=" << appId;
 
     return result;
 }
 
-bool ApplicationController::resumeApplicationWithAppId(const QString& appId)
+bool TaskController::resume(const QString& appId)
 {
     auto result = ubuntu_app_launch_resume_application(toLongAppIdIfPossible(appId).toLatin1().constData());
     if (!result)
-        qDebug() << "ApplicationController::resumeApplication FAILED to resume appId=" << appId;
+        qDebug() << "TaskController::resumeApplication FAILED to resume appId=" << appId;
 
     return result;
 }
 
 
-QFileInfo ApplicationController::findDesktopFileForAppId(const QString &appId) const
+QFileInfo TaskController::findDesktopFileForAppId(const QString &appId) const
 {
-    qCDebug(QTMIR_APPLICATIONS) << "ApplicationController::desktopFilePathForAppId - appId=" << appId;
+    qCDebug(QTMIR_APPLICATIONS) << "TaskController::desktopFilePathForAppId - appId=" << appId;
 
     // Search for the correct desktop file using a simple heuristic
     int dashPos = -1;

=== renamed file 'src/modules/Unity/Application/upstart/applicationcontroller.h' => 'src/modules/Unity/Application/upstart/taskcontroller.h'
--- src/modules/Unity/Application/upstart/applicationcontroller.h	2014-09-18 22:03:02 +0000
+++ src/modules/Unity/Application/upstart/taskcontroller.h	2016-02-03 11:35:51 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013,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
@@ -15,30 +15,30 @@
  *
  */
 
-#ifndef UPSTART_APPLICATION_CONTROLLER_H
-#define UPSTART_APPLICATION_CONTROLLER_H
+#ifndef QTMIR_UPSTART_TASK_CONTROLLER_H
+#define QTMIR_UPSTART_TASK_CONTROLLER_H
 
-#include "../applicationcontroller.h"
+#include "../taskcontroller.h"
 
 namespace qtmir
 {
 namespace upstart
 {
 
-class ApplicationController : public qtmir::ApplicationController
+class TaskController : public qtmir::TaskController
 {
 public:
-    ApplicationController();
-    ~ApplicationController();
+    TaskController();
+    ~TaskController();
 
     pid_t primaryPidForAppId(const QString& appId) override;
-    bool appIdHasProcessId(pid_t pid, const QString& appId) override;
-
-    bool stopApplicationWithAppId(const QString& appId) override;
-    bool startApplicationWithAppIdAndArgs(const QString& appId, const QStringList& arguments) override;
-
-    bool pauseApplicationWithAppId(const QString& appId) override;
-    bool resumeApplicationWithAppId(const QString& appId) override;
+    bool appIdHasProcessId(const QString& appId, pid_t pid) override;
+
+    bool stop(const QString& appId) override;
+    bool start(const QString& appId, const QStringList& arguments) override;
+
+    bool suspend(const QString& appId) override;
+    bool resume(const QString& appId) override;
 
     QFileInfo findDesktopFileForAppId(const QString &appId) const override;
 
@@ -50,4 +50,4 @@
 } // namespace upstart
 } // namespace qtmir
 
-#endif // UPSTART_APPLICATION_CONTROLLER_H
+#endif // QTMIR_UPSTART_TASK_CONTROLLER_H

=== modified file 'src/platforms/mirserver/CMakeLists.txt'
--- src/platforms/mirserver/CMakeLists.txt	2015-12-07 10:51:03 +0000
+++ src/platforms/mirserver/CMakeLists.txt	2016-02-03 11:35:51 +0000
@@ -69,6 +69,7 @@
     services.cpp
     ubuntutheme.cpp
     clipboard.cpp
+    sizehints.cpp
     tileddisplayconfigurationpolicy.cpp
     tracepoints.c
 # We need to run moc on these headers

=== modified file 'src/platforms/mirserver/mirserver.cpp'
--- src/platforms/mirserver/mirserver.cpp	2015-11-10 11:07:23 +0000
+++ src/platforms/mirserver/mirserver.cpp	2016-02-03 11:35:51 +0000
@@ -104,10 +104,13 @@
             return std::make_shared<MirServerStatusListener>();
         });
 
-    override_the_window_manager_builder([this](mir::shell::FocusController* focus_controller)
+    override_the_window_manager_builder([this](mir::shell::FocusController*)
         -> std::shared_ptr<mir::shell::WindowManager>
         {
-            return {MirWindowManager::create(focus_controller, the_shell_display_layout())};
+            auto windowManager = MirWindowManager::create(the_shell_display_layout(),
+                    std::static_pointer_cast<::SessionListener>(the_session_listener()));
+            m_windowManager = windowManager;
+            return windowManager;
         });
 
     wrap_display_configuration_policy(
@@ -193,3 +196,8 @@
     std::weak_ptr<MirShell> m_shell = the_shell();
     return m_shell.lock().get();
 }
+
+MirWindowManager *MirServer::windowManager()
+{
+    return m_windowManager.lock().get();
+}

=== modified file 'src/platforms/mirserver/mirserver.h'
--- src/platforms/mirserver/mirserver.h	2015-08-20 10:16:54 +0000
+++ src/platforms/mirserver/mirserver.h	2016-02-03 11:35:51 +0000
@@ -27,6 +27,7 @@
 using MirShell = mir::shell::Shell;
 class PromptSessionListener;
 class ScreenController;
+class MirWindowManager;
 
 // We use virtual inheritance of mir::Server to facilitate derived classes (e.g. testing)
 // calling initialization functions before MirServer is constructed.
@@ -61,11 +62,12 @@
     SessionAuthorizer *sessionAuthorizer();
     SessionListener *sessionListener();
     PromptSessionListener *promptSessionListener();
+    MirWindowManager *windowManager();
     MirShell *shell();
 
 private:
     std::weak_ptr<MirShell> m_shell;
-    std::shared_ptr<QtEventFeeder> m_qtEventFeeder;
+    std::weak_ptr<MirWindowManager> m_windowManager;
     const QSharedPointer<ScreenController> m_screenController;
 };
 

=== modified file 'src/platforms/mirserver/mirwindowmanager.cpp'
--- src/platforms/mirserver/mirwindowmanager.cpp	2015-12-02 12:27:45 +0000
+++ src/platforms/mirserver/mirwindowmanager.cpp	2016-02-03 11:35:51 +0000
@@ -16,6 +16,7 @@
 
 #include "mirwindowmanager.h"
 #include "logging.h"
+#include "surfaceobserver.h"
 #include "tracepoints.h" // generated from tracepoints.tp
 
 #include <mir/geometry/rectangle.h>
@@ -24,6 +25,8 @@
 #include <mir/scene/surface.h>
 #include <mir/shell/display_layout.h>
 
+#include <QMutexLocker>
+
 namespace ms = mir::scene;
 
 namespace
@@ -32,7 +35,8 @@
 {
 public:
 
-    MirWindowManagerImpl(const std::shared_ptr<mir::shell::DisplayLayout> &displayLayout);
+    MirWindowManagerImpl(const std::shared_ptr<mir::shell::DisplayLayout> &displayLayout,
+            std::shared_ptr<::SessionListener> sessionListener);
 
     void add_session(std::shared_ptr<mir::scene::Session> const& session) override;
 
@@ -75,12 +79,15 @@
 
 private:
     std::shared_ptr<mir::shell::DisplayLayout> const m_displayLayout;
+    std::shared_ptr<::SessionListener> m_sessionListener;
 };
 
 }
 
-MirWindowManagerImpl::MirWindowManagerImpl(const std::shared_ptr<mir::shell::DisplayLayout> &displayLayout) :
-    m_displayLayout{displayLayout}
+MirWindowManagerImpl::MirWindowManagerImpl(const std::shared_ptr<mir::shell::DisplayLayout> &displayLayout,
+        std::shared_ptr<::SessionListener> sessionListener) :
+    m_displayLayout{displayLayout},
+    m_sessionListener(sessionListener)
 {
     qCDebug(QTMIR_MIR_MESSAGES) << "MirWindowManagerImpl::MirWindowManagerImpl";
 }
@@ -100,16 +107,28 @@
 {
     tracepoint(qtmirserver, surfacePlacementStart);
 
-    // TODO: Callback unity8 so that it can make a decision on that.
-    //       unity8 must bear in mind that the called function will be on a Mir thread though.
-    //       The QPA shouldn't be deciding for itself on such things.
+    m_sessionListener->surfaceAboutToBeCreated(*session.get(), qtmir::SizeHints(requestParameters));
 
+    QSize initialSize;
+    // can be connected to via Qt::BlockingQueuedConnection to alter surface initial size
+    {
+        int surfaceType = requestParameters.type.is_set() ? requestParameters.type.value() : -1;
+        Q_EMIT sessionAboutToCreateSurface(session, surfaceType, initialSize);
+    }
     ms::SurfaceCreationParameters placedParameters = requestParameters;
 
-    // Just make it fullscreen for now
-    mir::geometry::Rectangle rect{requestParameters.top_left, requestParameters.size};
-    m_displayLayout->size_to_output(rect);
-    placedParameters.size = rect.size;
+    if (initialSize.isValid()) {
+        placedParameters.size.width = mir::geometry::Width(initialSize.width());
+        placedParameters.size.height = mir::geometry::Height(initialSize.height());
+    } else {
+        qCWarning(QTMIR_MIR_MESSAGES) << "MirWindowManagerImpl::add_surface(): didn't get a initial surface"
+            " size from shell. Falling back to fullscreen placement";
+        // This is bad. Fallback to fullscreen
+        mir::geometry::Rectangle rect{requestParameters.top_left, requestParameters.size};
+        m_displayLayout->size_to_output(rect);
+        placedParameters.size = rect.size;
+    }
+
 
     qCDebug(QTMIR_MIR_MESSAGES) << "MirWindowManagerImpl::add_surface(): size requested ("
                                 << requestParameters.size.width.as_int() << "," << requestParameters.size.height.as_int() << ") and placed ("
@@ -172,11 +191,17 @@
     if (modifications.name.is_set()) {
         surface->rename(modifications.name.value());
     }
+
+    QMutexLocker(&SurfaceObserver::mutex);
+    SurfaceObserver *observer = SurfaceObserver::observerForSurface(surface.get());
+    if (observer) {
+        observer->notifySizeHintChanges(modifications);
+    }
 }
 
-std::unique_ptr<MirWindowManager> MirWindowManager::create(
-    mir::shell::FocusController* /*focus_controller*/,
-    const std::shared_ptr<mir::shell::DisplayLayout> &displayLayout)
+std::shared_ptr<MirWindowManager> MirWindowManager::create(
+    const std::shared_ptr<mir::shell::DisplayLayout> &displayLayout,
+    std::shared_ptr<::SessionListener> sessionListener)
 {
-    return std::make_unique<MirWindowManagerImpl>(displayLayout);
+    return std::make_shared<MirWindowManagerImpl>(displayLayout, sessionListener);
 }

=== modified file 'src/platforms/mirserver/mirwindowmanager.h'
--- src/platforms/mirserver/mirwindowmanager.h	2015-11-19 12:55:57 +0000
+++ src/platforms/mirserver/mirwindowmanager.h	2016-02-03 11:35:51 +0000
@@ -19,7 +19,10 @@
 
 #include <mir/shell/window_manager.h>
 
+#include "sessionlistener.h"
+
 #include <QObject>
+#include <QSize>
 
 namespace mir {
     namespace shell {
@@ -33,10 +36,14 @@
     Q_OBJECT
 
 public:
+    static std::shared_ptr<MirWindowManager> create(
+        const std::shared_ptr<mir::shell::DisplayLayout> &displayLayout,
+        std::shared_ptr<::SessionListener> sessionListener);
 
-    static std::unique_ptr<MirWindowManager> create(
-        mir::shell::FocusController* focus_controller,
-        const std::shared_ptr<mir::shell::DisplayLayout> &displayLayout);
+Q_SIGNALS:
+    // requires Qt::BlockingQueuedConnection!!
+    void sessionAboutToCreateSurface(const std::shared_ptr<mir::scene::Session> &session,
+                                     int type, QSize &size);
 };
 
 #endif /* QPAMIRSERVER_WINDOW_MANAGER_H */

=== modified file 'src/platforms/mirserver/sessionlistener.cpp'
--- src/platforms/mirserver/sessionlistener.cpp	2015-08-11 12:08:32 +0000
+++ src/platforms/mirserver/sessionlistener.cpp	2016-02-03 11:35:51 +0000
@@ -34,6 +34,7 @@
     qRegisterMetaType<std::shared_ptr<ms::Session>>("std::shared_ptr<mir::scene::Session>");
     qRegisterMetaType<std::shared_ptr<ms::Surface>>("std::shared_ptr<mir::scene::Surface>");
     qRegisterMetaType<std::shared_ptr<SurfaceObserver>>("std::shared_ptr<SurfaceObserver>");
+    qRegisterMetaType<qtmir::SizeHints>();
 }
 
 SessionListener::~SessionListener()
@@ -73,8 +74,12 @@
     qCDebug(QTMIR_MIR_MESSAGES) << "SessionListener::surface_created - this=" << this << "session=" << &session
                                    << "surface=" << surface.get();
     std::shared_ptr<SurfaceObserver> surfaceObserver = std::make_shared<SurfaceObserver>();
+    SurfaceObserver::registerObserverForSurface(surfaceObserver.get(), surface.get());
     surface->add_observer(surfaceObserver);
-    Q_EMIT sessionCreatedSurface(&session, surface, surfaceObserver);
+
+    qtmir::SizeHints sizeHints = m_sizeHintsForNewSurface.take(&session);
+
+    Q_EMIT sessionCreatedSurface(&session, surface, surfaceObserver, sizeHints);
 }
 
 void SessionListener::destroying_surface(ms::Session& session, std::shared_ptr<ms::Surface> const& surface)
@@ -84,3 +89,8 @@
                                    << "surface=" << surface.get();
     Q_EMIT sessionDestroyingSurface(&session, surface);
 }
+
+void SessionListener::surfaceAboutToBeCreated(mir::scene::Session& session, qtmir::SizeHints sizeHints)
+{
+    m_sizeHintsForNewSurface[&session] = sizeHints;
+}

=== modified file 'src/platforms/mirserver/sessionlistener.h'
--- src/platforms/mirserver/sessionlistener.h	2015-08-31 09:51:28 +0000
+++ src/platforms/mirserver/sessionlistener.h	2016-02-03 11:35:51 +0000
@@ -18,10 +18,13 @@
 #define SESSIONLISTENER_H
 
 #include <QObject>
+#include <QMap>
 
 #include "mir/scene/session_listener.h"
 #include "mir/scene/session.h"
 
+#include "sizehints.h"
+
 class SurfaceObserver;
 
 class SessionListener : public QObject, public mir::scene::SessionListener
@@ -39,6 +42,8 @@
     void surface_created(mir::scene::Session&, std::shared_ptr<mir::scene::Surface> const&) override;
     void destroying_surface(mir::scene::Session&, std::shared_ptr<mir::scene::Surface> const&) override;
 
+    void surfaceAboutToBeCreated(mir::scene::Session&, qtmir::SizeHints sizeHints);
+
 Q_SIGNALS:
     void sessionStarting(std::shared_ptr<mir::scene::Session> const& session);
     void sessionStopping(std::shared_ptr<mir::scene::Session> const& session);
@@ -47,8 +52,12 @@
 
     void sessionCreatedSurface(mir::scene::Session const*,
                                std::shared_ptr<mir::scene::Surface> const&,
-                               std::shared_ptr<SurfaceObserver> const&);
+                               std::shared_ptr<SurfaceObserver> const&,
+                               qtmir::SizeHints);
     void sessionDestroyingSurface(mir::scene::Session const*, std::shared_ptr<mir::scene::Surface> const&);
+
+private:
+    QMap<mir::scene::Session*, qtmir::SizeHints> m_sizeHintsForNewSurface;
 };
 
 #endif // SESSIONLISTENER_H

=== added file 'src/platforms/mirserver/sizehints.cpp'
--- src/platforms/mirserver/sizehints.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/sizehints.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,44 @@
+/*
+ * 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 <mir/scene/surface_creation_parameters.h>
+
+#include "sizehints.h"
+
+using namespace qtmir;
+
+SizeHints::SizeHints(const mir::scene::SurfaceCreationParameters &params)
+{
+    minWidth = params.min_width.is_set() ? params.min_width.value().as_int() : 0;
+    maxWidth = params.max_width.is_set() ? params.max_width.value().as_int() : 0;
+
+    minHeight = params.min_height.is_set() ? params.min_height.value().as_int() : 0;
+    maxHeight = params.max_height.is_set() ? params.max_height.value().as_int() : 0;
+
+    widthIncrement = params.width_inc.is_set() ? params.width_inc.value().as_int() : 0;
+    heightIncrement = params.height_inc.is_set() ? params.height_inc.value().as_int() : 0;
+}
+
+QString SizeHints::toString() const
+{
+    return QString("SizeHints(minW=%1,minH=%2,maxW=%3,maxH=%4,wIncr=%5,hInc=%6)")
+        .arg(minWidth)
+        .arg(minHeight)
+        .arg(maxWidth)
+        .arg(maxHeight)
+        .arg(widthIncrement)
+        .arg(heightIncrement);
+}

=== added file 'src/platforms/mirserver/sizehints.h'
--- src/platforms/mirserver/sizehints.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/sizehints.h	2016-02-03 11:35:51 +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 QTMIR_SIZEHINTS_H
+#define QTMIR_SIZEHINTS_H
+
+#include <QMetaType>
+#include <QString>
+
+namespace mir {
+    namespace scene {
+        class SurfaceCreationParameters;
+    }
+}
+
+namespace qtmir {
+
+class SizeHints {
+public:
+    SizeHints() {}
+    SizeHints(const mir::scene::SurfaceCreationParameters&);
+
+    QString toString() const;
+
+    int minWidth{0};
+    int maxWidth{0};
+
+    int minHeight{0};
+    int maxHeight{0};
+
+    int widthIncrement{0};
+    int heightIncrement{0};
+};
+
+} // namespace qtmir
+
+Q_DECLARE_METATYPE(qtmir::SizeHints)
+
+#endif // QTMIR_SIZEHINTS_H

=== modified file 'src/platforms/mirserver/surfaceobserver.cpp'
--- src/platforms/mirserver/surfaceobserver.cpp	2015-12-04 14:02:54 +0000
+++ src/platforms/mirserver/surfaceobserver.cpp	2016-02-03 11:35:51 +0000
@@ -18,11 +18,17 @@
 
 #include "namedcursor.h"
 
+#include <QImage>
 #include <QMetaObject>
-#include <QImage>
+#include <QMutableMapIterator>
+#include <QMutexLocker>
 #include <QPixmap>
 
 #include <mir/geometry/size.h>
+#include <mir/shell/surface_specification.h>
+
+QMap<const mir::scene::Surface*, SurfaceObserver*> SurfaceObserver::m_surfaceToObserverMap;
+QMutex SurfaceObserver::mutex;
 
 SurfaceObserver::SurfaceObserver()
     : m_listener(nullptr)
@@ -52,6 +58,19 @@
     m_cursorNameToShape["dnd-link"] = Qt::DragLinkCursor;
 }
 
+SurfaceObserver::~SurfaceObserver()
+{
+    QMutexLocker locker(&mutex);
+    QMutableMapIterator<const mir::scene::Surface*, SurfaceObserver*> i(m_surfaceToObserverMap);
+    while (i.hasNext()) {
+        i.next();
+        if (i.value() == this) {
+            i.remove();
+            return;
+        }
+    }
+}
+
 void SurfaceObserver::setListener(QObject *listener)
 {
     m_listener = listener;
@@ -88,6 +107,44 @@
 void SurfaceObserver::resized_to(mir::geometry::Size const&size)
 {
     Q_EMIT resized(QSize(size.width.as_int(), size.height.as_int()));
+
+}
+
+void SurfaceObserver::notifySizeHintChanges(const mir::shell::SurfaceSpecification &modifications)
+{
+    if (modifications.min_width.is_set()) {
+        Q_EMIT minimumWidthChanged(modifications.min_width.value().as_int());
+    }
+    if (modifications.min_height.is_set()) {
+        Q_EMIT minimumHeightChanged(modifications.min_height.value().as_int());
+    }
+    if (modifications.max_width.is_set()) {
+        Q_EMIT maximumWidthChanged(modifications.max_width.value().as_int());
+    }
+    if (modifications.max_height.is_set()) {
+        Q_EMIT maximumHeightChanged(modifications.max_height.value().as_int());
+    }
+    if (modifications.width_inc.is_set()) {
+        Q_EMIT widthIncrementChanged(modifications.width_inc.value().as_int());
+    }
+    if (modifications.height_inc.is_set()) {
+        Q_EMIT heightIncrementChanged(modifications.height_inc.value().as_int());
+    }
+}
+
+SurfaceObserver *SurfaceObserver::observerForSurface(const mir::scene::Surface *surface)
+{
+    if (m_surfaceToObserverMap.contains(surface)) {
+        return m_surfaceToObserverMap.value(surface);
+    } else {
+        return nullptr;
+    }
+}
+
+void SurfaceObserver::registerObserverForSurface(SurfaceObserver *observer, const mir::scene::Surface *surface)
+{
+    QMutexLocker locker(&mutex);
+    m_surfaceToObserverMap[surface] = observer;
 }
 
 void SurfaceObserver::cursor_image_set_to(const mir::graphics::CursorImage &cursorImage)

=== modified file 'src/platforms/mirserver/surfaceobserver.h'
--- src/platforms/mirserver/surfaceobserver.h	2016-01-24 02:51:34 +0000
+++ src/platforms/mirserver/surfaceobserver.h	2016-02-03 11:35:51 +0000
@@ -21,15 +21,26 @@
 #include <QCursor>
 #include <QObject>
 #include <QMap>
+#include <QMutex>
 #include <QSize>
 #include <mir/scene/surface_observer.h>
 
+namespace mir {
+    namespace scene {
+        class Surface;
+    }
+    namespace shell {
+        class SurfaceSpecification;
+    }
+}
+
 class SurfaceObserver : public QObject, public mir::scene::SurfaceObserver
 {
     Q_OBJECT
 
 public:
     SurfaceObserver();
+    virtual ~SurfaceObserver();
 
     void setListener(QObject *listener);
 
@@ -52,6 +63,12 @@
     void renamed(char const * name) override;
     void cursor_image_removed() override;
 
+    void notifySizeHintChanges(const mir::shell::SurfaceSpecification&);
+
+    static SurfaceObserver *observerForSurface(const mir::scene::Surface *surface);
+    static void registerObserverForSurface(SurfaceObserver *observer, const mir::scene::Surface *surface);
+    static QMutex mutex;
+
 Q_SIGNALS:
     void attributeChanged(const MirSurfaceAttrib attribute, const int value);
     void framesPosted();
@@ -59,11 +76,19 @@
     void nameChanged(const QString &name);
     void cursorChanged(const QCursor &cursor);
 
+    void minimumWidthChanged(int);
+    void minimumHeightChanged(int);
+    void maximumWidthChanged(int);
+    void maximumHeightChanged(int);
+    void widthIncrementChanged(int);
+    void heightIncrementChanged(int);
+
 private:
     QCursor createQCursorFromMirCursorImage(const mir::graphics::CursorImage &cursorImage);
     QObject *m_listener;
     bool m_framesPosted;
     QMap<QByteArray, Qt::CursorShape> m_cursorNameToShape;
+    static QMap<const mir::scene::Surface*, SurfaceObserver*> m_surfaceToObserverMap;
 };
 
 #endif

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-12-03 08:56:35 +0000
+++ tests/CMakeLists.txt	2016-02-03 11:35:51 +0000
@@ -1,4 +1,5 @@
 find_package(GMock)
 
+add_subdirectory(framework)
 add_subdirectory(mirserver)
 add_subdirectory(modules)

=== removed directory 'tests/common'
=== renamed directory 'tests/modules/common' => 'tests/framework'
=== added file 'tests/framework/CMakeLists.txt'
--- tests/framework/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/framework/CMakeLists.txt	2016-02-03 11:35:51 +0000
@@ -0,0 +1,45 @@
+include_directories(
+    ${APPLICATION_API_INCLUDE_DIRS}
+    ${CMAKE_SOURCE_DIR}/src/platforms/mirserver
+    ${CMAKE_SOURCE_DIR}/src/modules
+    ${MIRSERVER_INCLUDE_DIRS}
+    ${MIRRENDERERGLDEV_INCLUDE_DIRS}
+
+    ${Qt5Quick_INCLUDE_DIRS}
+    ${Qt5DBus_INCLUDE_DIRS}
+)
+
+set(QTMIR_TEST_PRIVATE_SRC
+    fake_desktopfilereader.cpp
+    fake_mirsurface.cpp
+    fake_session.cpp
+    mock_task_controller.cpp
+    mock_desktop_file_reader.cpp
+    mock_display.cpp
+    mock_display_configuration.cpp
+    mock_gl_display_buffer.cpp
+    mock_main_loop.cpp
+    mock_mir_session.cpp
+    mock_proc_info.cpp
+    mock_prompt_session.cpp
+    mock_prompt_session_manager.cpp
+    mock_renderable.cpp
+    mock_session.cpp
+    mock_settings.cpp
+    mock_shared_wakelock.cpp
+    mock_surface.cpp
+    stub_input_channel.cpp
+    stub_scene_surface.cpp
+    qtmir_test.cpp
+)
+
+add_library(qtmir-test-framework-static STATIC
+    ${QTMIR_TEST_PRIVATE_SRC}
+)
+
+target_link_libraries(
+    qtmir-test-framework-static
+
+    ${GTEST_BOTH_LIBRARIES}
+    ${GMOCK_LIBRARIES}
+)

=== added file 'tests/framework/fake_desktopfilereader.cpp'
--- tests/framework/fake_desktopfilereader.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/fake_desktopfilereader.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,76 @@
+/*
+ * 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 "fake_desktopfilereader.h"
+
+#include <QDebug>
+
+namespace qtmir
+{
+
+FakeDesktopFileReader::FakeDesktopFileReader(const QString &appId)
+    : DesktopFileReader()
+    , m_appId(appId)
+{
+}
+
+FakeDesktopFileReader::FakeDesktopFileReader()
+	: DesktopFileReader()
+	, m_appId("foo-app")
+{
+}
+
+FakeDesktopFileReader::~FakeDesktopFileReader()
+{
+}
+
+QString FakeDesktopFileReader::file() const { return m_appId + ".desktop"; }
+
+QString FakeDesktopFileReader::appId() const { return m_appId; }
+
+QString FakeDesktopFileReader::name() const { return QString(); }
+
+QString FakeDesktopFileReader::comment() const { return QString(); }
+
+QString FakeDesktopFileReader::icon() const { return QString(); }
+
+QString FakeDesktopFileReader::exec() const { return QString(); }
+
+QString FakeDesktopFileReader::path() const { return QString(); }
+
+QString FakeDesktopFileReader::stageHint() const { return QString(); }
+
+QString FakeDesktopFileReader::splashTitle() const { return QString(); }
+
+QString FakeDesktopFileReader::splashImage() const { return QString(); }
+
+QString FakeDesktopFileReader::splashShowHeader() const { return QString(); }
+
+QString FakeDesktopFileReader::splashColor() const { return QString(); }
+
+QString FakeDesktopFileReader::splashColorHeader() const { return QString(); }
+
+QString FakeDesktopFileReader::splashColorFooter() const { return QString(); }
+
+Qt::ScreenOrientations FakeDesktopFileReader::supportedOrientations() const { return Qt::PortraitOrientation; }
+
+bool FakeDesktopFileReader::rotatesWindowContents() const { return false; }
+
+bool FakeDesktopFileReader::isTouchApp() const { return true; }
+
+bool FakeDesktopFileReader::loaded() const { return true; }
+
+} // namespace qtmir

=== modified file 'tests/framework/fake_desktopfilereader.h'
--- tests/modules/common/fake_desktopfilereader.h	2015-09-28 20:11:39 +0000
+++ tests/framework/fake_desktopfilereader.h	2016-02-03 11:35:51 +0000
@@ -17,33 +17,35 @@
 #ifndef FAKE_DESKTOPFILEREADER_H
 #define FAKE_DESKTOPFILEREADER_H
 
+#include <Unity/Application/desktopfilereader.h>
+
 namespace qtmir {
 
 class FakeDesktopFileReader : public qtmir::DesktopFileReader
 {
 public:
-    FakeDesktopFileReader() : DesktopFileReader()
-        , m_appId("foo-app")
-    {}
+    FakeDesktopFileReader(const QString &appId);
+    FakeDesktopFileReader();
+    virtual ~FakeDesktopFileReader();
 
-    QString file() const override { return QString(); }
-    QString appId() const override { return m_appId; }
-    QString name() const override { return QString(); }
-    QString comment() const override { return QString(); }
-    QString icon() const override { return QString(); }
-    QString exec() const override { return QString(); }
-    QString path() const override { return QString(); }
-    QString stageHint() const override { return QString(); }
-    QString splashTitle() const override { return QString(); }
-    QString splashImage() const override { return QString(); }
-    QString splashShowHeader() const override { return QString(); }
-    QString splashColor() const override { return QString(); }
-    QString splashColorHeader() const override { return QString(); }
-    QString splashColorFooter() const override { return QString(); }
-    Qt::ScreenOrientations supportedOrientations() const override { return Qt::PortraitOrientation; }
-    bool rotatesWindowContents() const override { return false; }
-    bool isTouchApp() const override { return true; }
-    bool loaded() const override { return true; }
+    QString file() const override;
+    QString appId() const override;
+    QString name() const override;
+    QString comment() const override;
+    QString icon() const override;
+    QString exec() const override;
+    QString path() const override;
+    QString stageHint() const override;
+    QString splashTitle() const override;
+    QString splashImage() const override;
+    QString splashShowHeader() const override;
+    QString splashColor() const override;
+    QString splashColorHeader() const override;
+    QString splashColorFooter() const override;
+    Qt::ScreenOrientations supportedOrientations() const override;
+    bool rotatesWindowContents() const override;
+    bool isTouchApp() const override;
+    bool loaded() const override;
 
     QString m_appId;
 };

=== renamed file 'tests/common/fake_displayconfigurationoutput.h' => 'tests/framework/fake_displayconfigurationoutput.h'
=== added file 'tests/framework/fake_mirsurface.cpp'
--- tests/framework/fake_mirsurface.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/fake_mirsurface.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,212 @@
+/*
+ * 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 "fake_mirsurface.h"
+
+namespace qtmir
+{
+
+FakeMirSurface::TouchEvent::TouchEvent(Qt::KeyboardModifiers mods,
+                                       const QList<QTouchEvent::TouchPoint> &points,
+                                       Qt::TouchPointStates states,
+                                       ulong timestamp)
+    : keyboardModifiers(mods)
+    , touchPoints(points)
+    , states(states)
+    , timestamp(timestamp)
+{
+}
+
+FakeMirSurface::TouchEvent::~TouchEvent()
+{
+}
+
+FakeMirSurface::FakeMirSurface(QObject *parent)
+    : MirSurfaceInterface(parent)
+    , m_isFirstFrameDrawn(false)
+    , m_isFrameDropperRunning(true)
+    , m_live(true)
+    , m_state(Mir::RestoredState)
+    , m_orientationAngle(Mir::Angle0)
+    , m_visible(true)
+    , m_focused(false)
+{
+}
+
+FakeMirSurface::~FakeMirSurface()
+{
+}
+
+Mir::Type FakeMirSurface::type() const { return Mir::NormalType; }
+
+QString FakeMirSurface::name() const { return QString("Fake MirSurface"); }
+
+QSize FakeMirSurface::size() const { return m_size; }
+
+void FakeMirSurface::resize(int width, int height)
+{
+    if (m_size.width() != width || m_size.height() != height) {
+        m_size.setWidth(width);
+        m_size.setHeight(height);
+        Q_EMIT sizeChanged(m_size);
+    }
+}
+
+void FakeMirSurface::resize(const QSize &size) { resize(size.width(), size.height()); }
+
+Mir::State FakeMirSurface::state() const { return m_state; }
+
+void FakeMirSurface::setState(Mir::State qmlState)
+{
+    if (qmlState != m_state) {
+        m_state = qmlState;
+        Q_EMIT stateChanged(m_state);
+    }
+}
+
+bool FakeMirSurface::live() const { return m_live; }
+
+bool FakeMirSurface::visible() const { return m_visible; }
+
+Mir::OrientationAngle FakeMirSurface::orientationAngle() const { return m_orientationAngle; }
+
+void FakeMirSurface::setOrientationAngle(Mir::OrientationAngle angle)
+{
+    if (m_orientationAngle != angle) {
+        m_orientationAngle = angle;
+        Q_EMIT orientationAngleChanged(m_orientationAngle);
+    }
+}
+
+bool FakeMirSurface::isFirstFrameDrawn() const
+{
+    return m_isFirstFrameDrawn;
+}
+
+void FakeMirSurface::stopFrameDropper()
+{
+    m_isFrameDropperRunning = false;
+}
+
+void FakeMirSurface::startFrameDropper()
+{
+    m_isFrameDropperRunning = true;
+}
+
+void FakeMirSurface::setLive(bool value)
+{
+    if (m_live != value) {
+        m_live = value;
+        Q_EMIT liveChanged(m_live);
+    }
+}
+
+void FakeMirSurface::setViewVisibility(qintptr viewId, bool visible) {
+    if (!m_views.contains(viewId)) return;
+
+    m_views[viewId] = visible;
+    updateVisibility();
+}
+
+bool FakeMirSurface::isBeingDisplayed() const { return !m_views.isEmpty(); }
+
+void FakeMirSurface::registerView(qintptr viewId)
+{
+    m_views.insert(viewId, false);
+    if (m_views.count() == 1) {
+        Q_EMIT isBeingDisplayedChanged();
+    }
+}
+
+void FakeMirSurface::unregisterView(qintptr viewId)
+{
+    m_views.remove(viewId);
+    if (m_views.count() == 0) {
+        Q_EMIT isBeingDisplayedChanged();
+    }
+    updateVisibility();
+}
+
+QSharedPointer<QSGTexture> FakeMirSurface::texture() { return QSharedPointer<QSGTexture>(); }
+
+QSGTexture *FakeMirSurface::weakTexture() const { return nullptr; }
+
+bool FakeMirSurface::updateTexture() { return true; }
+
+unsigned int FakeMirSurface::currentFrameNumber() const { return 0; }
+
+bool FakeMirSurface::numBuffersReadyForCompositor() { return 0; }
+
+void FakeMirSurface::setFocus(bool focus) { m_focused = focus; }
+
+void FakeMirSurface::mousePressEvent(QMouseEvent *) {}
+
+void FakeMirSurface::mouseMoveEvent(QMouseEvent *) {}
+
+void FakeMirSurface::mouseReleaseEvent(QMouseEvent *) {}
+
+void FakeMirSurface::hoverEnterEvent(QHoverEvent *) {}
+
+void FakeMirSurface::hoverLeaveEvent(QHoverEvent *) {}
+
+void FakeMirSurface::hoverMoveEvent(QHoverEvent *) {}
+
+void FakeMirSurface::wheelEvent(QWheelEvent *) {}
+
+void FakeMirSurface::keyPressEvent(QKeyEvent *) {}
+
+void FakeMirSurface::keyReleaseEvent(QKeyEvent *) {}
+
+void FakeMirSurface::touchEvent(Qt::KeyboardModifiers mods,
+                                const QList<QTouchEvent::TouchPoint> &points,
+                                Qt::TouchPointStates states,
+                                ulong timestamp)
+{
+    m_touchesReceived.append(TouchEvent(mods, points, states, timestamp));
+}
+
+QString FakeMirSurface::appId() const { return "foo-app"; }
+
+void FakeMirSurface::onCompositorSwappedBuffers() {}
+
+void FakeMirSurface::drawFirstFrame()
+{
+    if (!m_isFirstFrameDrawn) {
+        m_isFirstFrameDrawn = true;
+        Q_EMIT firstFrameDrawn();
+    }
+}
+
+bool FakeMirSurface::isFrameDropperRunning() const { return m_isFrameDropperRunning; }
+
+QList<FakeMirSurface::TouchEvent> &FakeMirSurface::touchesReceived() { return m_touchesReceived; }
+
+void FakeMirSurface::updateVisibility()
+{
+    bool newVisible = false;
+    QHashIterator<int, bool> i(m_views);
+    while (i.hasNext()) {
+        i.next();
+        newVisible |= i.value();
+    }
+
+    if (m_visible != newVisible) {
+        m_visible = newVisible;
+        Q_EMIT visibleChanged(newVisible);
+    }
+}
+
+} // namespace qtmir

=== modified file 'tests/framework/fake_mirsurface.h'
--- tests/modules/common/fake_mirsurface.h	2015-12-10 13:08:43 +0000
+++ tests/framework/fake_mirsurface.h	2016-02-03 11:35:51 +0000
@@ -36,11 +36,8 @@
         TouchEvent(Qt::KeyboardModifiers mods,
                 const QList<QTouchEvent::TouchPoint> &points,
                 Qt::TouchPointStates states,
-                ulong timestamp)
-            : keyboardModifiers(mods)
-            , touchPoints(points)
-            , states(states)
-            , timestamp(timestamp) {}
+                ulong timestamp);
+        virtual ~TouchEvent();
 
         Qt::KeyboardModifiers keyboardModifiers;
         QList<QTouchEvent::TouchPoint> touchPoints;
@@ -48,129 +45,68 @@
         ulong timestamp;
     };
 
-
-    FakeMirSurface(QObject *parent = nullptr)
-        : MirSurfaceInterface(parent)
-        , m_isFirstFrameDrawn(false)
-        , m_isFrameDropperRunning(true)
-        , m_live(true)
-        , m_state(Mir::RestoredState)
-        , m_orientationAngle(Mir::Angle0)
-        , m_visible(true)
-        , m_focused(false)
-    {}
+    FakeMirSurface(QObject *parent = nullptr);
+    virtual ~FakeMirSurface();
 
     ////
     // unity.shell.application.MirSurfaceInterface
-    Mir::Type type() const override { return Mir::NormalType; }
-
-    QString name() const override { return QString("Fake MirSurface"); }
-
-    QSize size() const override { return m_size; }
-
-    void resize(int width, int height) override {
-        if (m_size.width() != width || m_size.height() != height) {
-            m_size.setWidth(width);
-            m_size.setHeight(height);
-            Q_EMIT sizeChanged(m_size);
-        }
-    }
-    void resize(const QSize &size) override { resize(size.width(), size.height()); }
-
-    Mir::State state() const override { return m_state; }
-    void setState(Mir::State qmlState) override {
-        if (qmlState != m_state) {
-            m_state = qmlState;
-            Q_EMIT stateChanged(m_state);
-        }
-    }
-
-    bool live() const override { return m_live; }
-
-    bool visible() const override { return m_visible; }
-
-    Mir::OrientationAngle orientationAngle() const override { return m_orientationAngle; }
-    void setOrientationAngle(Mir::OrientationAngle angle) override {
-        if (m_orientationAngle != angle) {
-            m_orientationAngle = angle;
-            Q_EMIT orientationAngleChanged(m_orientationAngle);
-        }
-    }
+    Mir::Type type() const override;
+    QString name() const override;
+    QSize size() const override;
+    void resize(int width, int height) override;
+    void resize(const QSize &size) override;
+    Mir::State state() const override;
+    void setState(Mir::State qmlState) override;
+    bool live() const override;
+    bool visible() const override;
+    Mir::OrientationAngle orientationAngle() const override;
+    void setOrientationAngle(Mir::OrientationAngle angle) override;
+
+    int minimumWidth() const override { return 0; }
+    int minimumHeight() const override { return 0; }
+    int maximumWidth() const override { return 0; }
+    int maximumHeight() const override { return 0; }
+    int widthIncrement() const override { return 0; }
+    int heightIncrement() const override { return 0; }
 
     ////
     // qtmir.MirSurfaceInterface
 
-    bool isFirstFrameDrawn() const override {
-        return m_isFirstFrameDrawn;
-    }
-
-    void stopFrameDropper() override {
-        m_isFrameDropperRunning = false;
-    }
-    void startFrameDropper() override {
-        m_isFrameDropperRunning = true;
-    }
-
-    void setLive(bool value) override {
-        if (m_live != value) {
-            m_live = value;
-            Q_EMIT liveChanged(m_live);
-        }
-    }
-
-    void setViewVisibility(qintptr viewId, bool visible) override {
-        if (!m_views.contains(viewId)) return;
-
-        m_views[viewId] = visible;
-        updateVisibility();
-    }
-
-    bool isBeingDisplayed() const override { return !m_views.isEmpty(); }
-
-    void registerView(qintptr viewId) override {
-        m_views.insert(viewId, false);
-        if (m_views.count() == 1) {
-            Q_EMIT isBeingDisplayedChanged();
-        }
-    }
-
-    void unregisterView(qintptr viewId) override {
-        m_views.remove(viewId);
-        if (m_views.count() == 0) {
-            Q_EMIT isBeingDisplayedChanged();
-        }
-        updateVisibility();
-    }
+    bool isFirstFrameDrawn() const override;
+    void stopFrameDropper() override;
+    void startFrameDropper() override;
+    void setLive(bool value) override;
+    void setViewVisibility(qintptr viewId, bool visible) override;
+    bool isBeingDisplayed() const override;
+    void registerView(qintptr viewId) override;
+    void unregisterView(qintptr viewId) override;
 
     // methods called from the rendering (scene graph) thread:
-    QSharedPointer<QSGTexture> texture() override { return QSharedPointer<QSGTexture>(); }
-    QSGTexture *weakTexture() const override { return nullptr; }
-    bool updateTexture() override { return true; }
-    unsigned int currentFrameNumber() const override { return 0; }
-    bool numBuffersReadyForCompositor() override { return 0; }
+    QSharedPointer<QSGTexture> texture() override;
+    QSGTexture *weakTexture() const override;
+    bool updateTexture() override;
+    unsigned int currentFrameNumber() const override;
+    bool numBuffersReadyForCompositor() override;
     // end of methods called from the rendering (scene graph) thread
 
-    void setFocus(bool focus) override { m_focused = focus; }
-
-    void mousePressEvent(QMouseEvent *) override {}
-    void mouseMoveEvent(QMouseEvent *) override {}
-    void mouseReleaseEvent(QMouseEvent *) override {}
-    void hoverEnterEvent(QHoverEvent *) override {}
-    void hoverLeaveEvent(QHoverEvent *) override {}
-    void hoverMoveEvent(QHoverEvent *) override {}
-    void wheelEvent(QWheelEvent *) override {}
-
-    void keyPressEvent(QKeyEvent *) override {}
-    void keyReleaseEvent(QKeyEvent *) override {}
+    void setFocus(bool focus) override;
+
+    void mousePressEvent(QMouseEvent *) override;
+    void mouseMoveEvent(QMouseEvent *) override;
+    void mouseReleaseEvent(QMouseEvent *) override;
+    void hoverEnterEvent(QHoverEvent *) override;
+    void hoverLeaveEvent(QHoverEvent *) override;
+    void hoverMoveEvent(QHoverEvent *) override;
+    void wheelEvent(QWheelEvent *) override;
+    void keyPressEvent(QKeyEvent *) override;
+    void keyReleaseEvent(QKeyEvent *) override;
 
     void touchEvent(Qt::KeyboardModifiers mods,
             const QList<QTouchEvent::TouchPoint> &points,
             Qt::TouchPointStates states,
-            ulong timestamp) override {
-        m_touchesReceived.append(TouchEvent(mods, points, states, timestamp));
-    }
+            ulong timestamp) override;
 
-    QString appId() const override { return "foo-app"; }
+    QString appId() const override;
 
     QCursor cursor() const override { return QCursor(); }
 
@@ -182,40 +118,28 @@
     void closeRequested();
 
 public Q_SLOTS:
-    void onCompositorSwappedBuffers() override {}
+    void onCompositorSwappedBuffers() override;
+
+    void setMinimumWidth(int) {}
+    void setMinimumHeight(int) {}
+    void setMaximumWidth(int) {}
+    void setMaximumHeight(int) {}
+    void setWidthIncrement(int) {}
+    void setHeightIncrement(int) {}
 
     ////
     // Test API from now on
 
 public:
 
-    void drawFirstFrame() {
-        if (!m_isFirstFrameDrawn) {
-            m_isFirstFrameDrawn = true;
-            Q_EMIT firstFrameDrawn();
-        }
-    }
-
-    bool isFrameDropperRunning() const {
-        return m_isFrameDropperRunning;
-    }
-
-    QList<TouchEvent> &touchesReceived() { return m_touchesReceived; }
+    void drawFirstFrame();
+
+    bool isFrameDropperRunning() const;
+
+    QList<TouchEvent> &touchesReceived();
 
 private:
-    void updateVisibility() {
-        bool newVisible = false;
-        QHashIterator<int, bool> i(m_views);
-        while (i.hasNext()) {
-            i.next();
-            newVisible |= i.value();
-        }
-
-        if (m_visible != newVisible) {
-            m_visible = newVisible;
-            Q_EMIT visibleChanged(newVisible);
-        }
-    }
+    void updateVisibility();
 
 
     bool m_isFirstFrameDrawn;

=== added file 'tests/framework/fake_session.cpp'
--- tests/framework/fake_session.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/fake_session.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,119 @@
+/*
+ * 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 "fake_session.h"
+
+namespace qtmir
+{
+
+FakeSession::FakeSession()
+    : SessionInterface(0)
+    , m_application(nullptr)
+    , m_state(Starting)
+{
+}
+
+FakeSession::~FakeSession()
+{
+}
+
+void FakeSession::release() {}
+
+QString FakeSession::name() const { return QString("foo-session"); }
+
+unity::shell::application::ApplicationInfoInterface *FakeSession::application() const { return m_application; }
+
+MirSurfaceInterface *FakeSession::lastSurface() const { return nullptr; }
+
+const ObjectListModel<MirSurfaceInterface> *FakeSession::surfaces() const { return nullptr; }
+
+SessionInterface *FakeSession::parentSession() const { return nullptr; }
+
+SessionModel *FakeSession::childSessions() const { return nullptr; }
+
+SessionInterface::State FakeSession::state() const { return m_state; }
+
+bool FakeSession::fullscreen() const { return false; }
+
+bool FakeSession::live() const { return true; }
+
+std::shared_ptr<mir::scene::Session> FakeSession::session() const { return nullptr; }
+
+void FakeSession::registerSurface(MirSurfaceInterface *) {}
+
+void FakeSession::removeSurface(MirSurfaceInterface *) {}
+
+void FakeSession::setApplication(unity::shell::application::ApplicationInfoInterface *app)
+{
+    if (m_application != app) {
+        m_application = app;
+        Q_EMIT applicationChanged(m_application);
+    }
+}
+
+void FakeSession::suspend()
+{
+    if (m_state == Running) {
+        setState(Suspending);
+    }
+}
+
+void FakeSession::resume()
+{
+    if (m_state == Suspending || m_state == Suspended) {
+        setState(Running);
+    }
+}
+
+void FakeSession::stop()
+{
+    setState(Stopped);
+}
+
+void FakeSession::close() {}
+
+void FakeSession::addChildSession(SessionInterface *) {}
+
+void FakeSession::insertChildSession(uint, SessionInterface *) {}
+
+void FakeSession::removeChildSession(SessionInterface *) {}
+
+void FakeSession::foreachChildSession(std::function<void (SessionInterface *)>) const {}
+
+std::shared_ptr<mir::scene::PromptSession> FakeSession::activePromptSession() const
+{
+    return std::shared_ptr<mir::scene::PromptSession>();
+}
+
+void FakeSession::foreachPromptSession(std::function<void (const std::shared_ptr<mir::scene::PromptSession> &)>) const {}
+
+void FakeSession::setFullscreen(bool) {}
+
+void FakeSession::setLive(const bool) {}
+
+void FakeSession::appendPromptSession(const std::shared_ptr<mir::scene::PromptSession> &) {}
+
+void FakeSession::removePromptSession(const std::shared_ptr<mir::scene::PromptSession> &) {}
+
+void FakeSession::setState(SessionInterface::State state)
+{
+    if (m_state != state) {
+        m_state = state;
+        Q_EMIT stateChanged(m_state);
+    }
+}
+
+} // namespace qtmir

=== modified file 'tests/framework/fake_session.h'
--- tests/modules/common/fake_session.h	2015-12-07 12:02:48 +0000
+++ tests/framework/fake_session.h	2016-02-03 11:35:51 +0000
@@ -27,83 +27,56 @@
     Q_OBJECT
 
 public:
-    FakeSession()
-        : SessionInterface(0)
-        , m_application(nullptr)
-        , m_state(Starting)
-    {
-    }
+    FakeSession();
+    virtual ~FakeSession();
 
     // For QML use
-    void release() override {}
-
-    QString name() const override { return QString("foo-session"); }
-    unity::shell::application::ApplicationInfoInterface* application() const override { return m_application; }
-    MirSurfaceInterface* lastSurface() const override { return nullptr; }
-    const ObjectListModel<MirSurfaceInterface>* surfaces() const override { return nullptr; }
-    SessionInterface* parentSession() const override { return nullptr; }
-    SessionModel* childSessions() const override { return nullptr; }
-    State state() const override { return m_state; }
-    bool fullscreen() const override { return false; }
-    bool live() const override { return true; }
-
-    std::shared_ptr<mir::scene::Session> session() const override { return nullptr; }
+    void release() override;
+
+    QString name() const override;
+    unity::shell::application::ApplicationInfoInterface* application() const override;
+    MirSurfaceInterface* lastSurface() const override;
+    const ObjectListModel<MirSurfaceInterface>* surfaces() const override;
+    SessionInterface* parentSession() const override;
+    SessionModel* childSessions() const override;
+    State state() const override;
+    bool fullscreen() const override;
+    bool live() const override;
+
+    std::shared_ptr<mir::scene::Session> session() const override;
 
     // For MirSurfaceItem and MirSurfaceManager use
 
-    void registerSurface(MirSurfaceInterface*) override {}
-    void removeSurface(MirSurfaceInterface*) override {}
+    void registerSurface(MirSurfaceInterface*) override;
+    void removeSurface(MirSurfaceInterface*) override;
 
     // For Application use
 
-    void setApplication(unity::shell::application::ApplicationInfoInterface* app) override {
-        if (m_application != app) {
-            m_application = app;
-            Q_EMIT applicationChanged(m_application);
-        }
-    }
-    void suspend() override {
-        if (m_state == Running) {
-            setState(Suspending);
-        }
-    }
-    void resume() override {
-        if (m_state == Suspending || m_state == Suspended) {
-            setState(Running);
-        }
-    }
-    void stop() override {
-        setState(Stopped);
-    }
+    void setApplication(unity::shell::application::ApplicationInfoInterface* app) override;
+    void suspend() override;
+    void resume() override;
+    void stop() override;
 
-    void close() override {
-    }
+    void close() override;
 
     // For SessionManager use
 
-    void addChildSession(SessionInterface*) override {}
-    void insertChildSession(uint, SessionInterface*) override {}
-    void removeChildSession(SessionInterface*) override {}
-    void foreachChildSession(std::function<void(SessionInterface* session)>) const override {}
-
-    std::shared_ptr<mir::scene::PromptSession> activePromptSession() const override {
-        return std::shared_ptr<mir::scene::PromptSession>();
-    }
-    void foreachPromptSession(std::function<void(const std::shared_ptr<mir::scene::PromptSession>&)>) const override {}
-
-    void setFullscreen(bool) override {}
-    void setLive(const bool) override {}
-    void appendPromptSession(const std::shared_ptr<mir::scene::PromptSession>&) override {}
-    void removePromptSession(const std::shared_ptr<mir::scene::PromptSession>&) override {}
+    void addChildSession(SessionInterface*) override;
+    void insertChildSession(uint, SessionInterface*) override;
+    void removeChildSession(SessionInterface*) override;
+    void foreachChildSession(std::function<void(SessionInterface* session)>) const override;
+
+    std::shared_ptr<mir::scene::PromptSession> activePromptSession() const override;
+    void foreachPromptSession(std::function<void(const std::shared_ptr<mir::scene::PromptSession>&)>) const override;
+
+    void setFullscreen(bool) override;
+    void setLive(const bool) override;
+    void appendPromptSession(const std::shared_ptr<mir::scene::PromptSession>&) override;
+    void removePromptSession(const std::shared_ptr<mir::scene::PromptSession>&) override;
 
     // For tests
 
-    void setState(State state) {
-        if (m_state != state) {
-            m_state = state;
-            Q_EMIT stateChanged(m_state);
-        }
-    }
+    void setState(State state);
 
 private:
     unity::shell::application::ApplicationInfoInterface* m_application;

=== renamed file 'tests/common/gmock_fixes.h' => 'tests/framework/gmock_fixes.h'
=== added file 'tests/framework/mock_desktop_file_reader.cpp'
--- tests/framework/mock_desktop_file_reader.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/mock_desktop_file_reader.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,117 @@
+/*
+ * 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 "mock_desktop_file_reader.h"
+
+namespace qtmir
+{
+
+MockDesktopFileReader::MockDesktopFileReader(const QString &appId, const QFileInfo &fileInfo)
+    : DesktopFileReader(appId, fileInfo)
+{
+    using namespace ::testing;
+
+    ON_CALL(*this, file()).WillByDefault(Invoke(this, &MockDesktopFileReader::doFile));
+    ON_CALL(*this, appId()).WillByDefault(Invoke(this, &MockDesktopFileReader::doAppId));
+    ON_CALL(*this, name()).WillByDefault(Invoke(this, &MockDesktopFileReader::doName));
+    ON_CALL(*this, comment()).WillByDefault(Invoke(this, &MockDesktopFileReader::doComment));
+    ON_CALL(*this, icon()).WillByDefault(Invoke(this, &MockDesktopFileReader::doIcon));
+    ON_CALL(*this, exec()).WillByDefault(Invoke(this, &MockDesktopFileReader::doExec));
+    ON_CALL(*this, path()).WillByDefault(Invoke(this, &MockDesktopFileReader::doPath));
+    ON_CALL(*this, stageHint()).WillByDefault(Invoke(this, &MockDesktopFileReader::doStageHint));
+    ON_CALL(*this, isTouchApp()).WillByDefault(Invoke(this, &MockDesktopFileReader::doIsTouchApp));
+    ON_CALL(*this, loaded()).WillByDefault(Invoke(this, &MockDesktopFileReader::doLoaded));
+}
+
+MockDesktopFileReader::~MockDesktopFileReader()
+{
+}
+
+QString MockDesktopFileReader::doFile() const
+{
+    return DesktopFileReader::file();
+}
+
+QString MockDesktopFileReader::doAppId() const
+{
+    return DesktopFileReader::appId();
+}
+
+QString MockDesktopFileReader::doName() const
+{
+    return DesktopFileReader::name();
+}
+
+QString MockDesktopFileReader::doComment() const
+{
+    return DesktopFileReader::comment();
+}
+
+QString MockDesktopFileReader::doIcon() const
+{
+    return DesktopFileReader::icon();
+}
+
+QString MockDesktopFileReader::doExec() const
+{
+    return DesktopFileReader::exec();
+}
+
+QString MockDesktopFileReader::doPath() const
+{
+    return DesktopFileReader::path();
+}
+
+QString MockDesktopFileReader::doStageHint() const
+{
+    return DesktopFileReader::stageHint();
+}
+
+bool MockDesktopFileReader::doIsTouchApp() const
+{
+    return DesktopFileReader::isTouchApp();
+}
+
+bool MockDesktopFileReader::doLoaded() const
+{
+    return DesktopFileReader::loaded();
+}
+
+
+MockDesktopFileReaderFactory::MockDesktopFileReaderFactory()
+{
+    using namespace ::testing;
+    ON_CALL(*this, createInstance(_, _))
+            .WillByDefault(
+                Invoke(
+                    this,
+                    &MockDesktopFileReaderFactory::doCreateInstance));
+}
+
+MockDesktopFileReaderFactory::~MockDesktopFileReaderFactory()
+{
+}
+
+qtmir::DesktopFileReader *MockDesktopFileReaderFactory::doCreateInstance(const QString &appId, const QFileInfo &fi)
+{
+    using namespace ::testing;
+    auto instance = new NiceMock<MockDesktopFileReader>(appId, fi);
+    ON_CALL(*instance, loaded()).WillByDefault(Return(true));
+
+    return instance;
+}
+
+} // namespace qtmir

=== modified file 'tests/framework/mock_desktop_file_reader.h'
--- tests/modules/common/mock_desktop_file_reader.h	2015-09-29 18:27:27 +0000
+++ tests/framework/mock_desktop_file_reader.h	2016-02-03 11:35:51 +0000
@@ -21,26 +21,13 @@
 
 #include <gmock/gmock.h>
 
-namespace testing
+namespace qtmir
 {
+
 struct MockDesktopFileReader : public qtmir::DesktopFileReader
 {
-    MockDesktopFileReader(const QString &appId, const QFileInfo& fileInfo)
-        : DesktopFileReader(appId, fileInfo)
-    {
-        using namespace ::testing;
-
-        ON_CALL(*this, file()).WillByDefault(Invoke(this, &MockDesktopFileReader::doFile));
-        ON_CALL(*this, appId()).WillByDefault(Invoke(this, &MockDesktopFileReader::doAppId));
-        ON_CALL(*this, name()).WillByDefault(Invoke(this, &MockDesktopFileReader::doName));
-        ON_CALL(*this, comment()).WillByDefault(Invoke(this, &MockDesktopFileReader::doComment));
-        ON_CALL(*this, icon()).WillByDefault(Invoke(this, &MockDesktopFileReader::doIcon));
-        ON_CALL(*this, exec()).WillByDefault(Invoke(this, &MockDesktopFileReader::doExec));
-        ON_CALL(*this, path()).WillByDefault(Invoke(this, &MockDesktopFileReader::doPath));
-        ON_CALL(*this, stageHint()).WillByDefault(Invoke(this, &MockDesktopFileReader::doStageHint));
-        ON_CALL(*this, isTouchApp()).WillByDefault(Invoke(this, &MockDesktopFileReader::doIsTouchApp));
-        ON_CALL(*this, loaded()).WillByDefault(Invoke(this, &MockDesktopFileReader::doLoaded));
-    }
+    MockDesktopFileReader(const QString &appId, const QFileInfo& fileInfo);
+    virtual ~MockDesktopFileReader();
 
     MOCK_CONST_METHOD0(file, QString());
     MOCK_CONST_METHOD0(appId, QString ());
@@ -53,80 +40,28 @@
     MOCK_CONST_METHOD0(isTouchApp, bool());
     MOCK_CONST_METHOD0(loaded, bool());
 
-    QString doFile() const
-    {
-        return DesktopFileReader::file();
-    }
-
-    QString doAppId() const
-    {
-        return DesktopFileReader::appId();
-    }
-
-    QString doName() const
-    {
-        return DesktopFileReader::name();
-    }
-
-    QString doComment() const
-    {
-        return DesktopFileReader::comment();
-    }
-
-    QString doIcon() const
-    {
-        return DesktopFileReader::icon();
-    }
-
-    QString doExec() const
-    {
-        return DesktopFileReader::exec();
-    }
-
-    QString doPath() const
-    {
-        return DesktopFileReader::path();
-    }
-
-    QString doStageHint() const
-    {
-        return DesktopFileReader::stageHint();
-    }
-
-    bool doIsTouchApp() const
-    {
-        return DesktopFileReader::isTouchApp();
-    }
-
-    bool doLoaded() const
-    {
-        return DesktopFileReader::loaded();
-    }
+    QString doFile() const;
+    QString doAppId() const;
+    QString doName() const;
+    QString doComment() const;
+    QString doIcon() const;
+    QString doExec() const;
+    QString doPath() const;
+    QString doStageHint() const;
+    bool doIsTouchApp() const;
+    bool doLoaded() const;
 };
 
 struct MockDesktopFileReaderFactory : public qtmir::DesktopFileReader::Factory
 {
-    MockDesktopFileReaderFactory()
-    {
-        using namespace ::testing;
-        ON_CALL(*this, createInstance(_, _))
-                .WillByDefault(
-                    Invoke(
-                        this,
-                        &MockDesktopFileReaderFactory::doCreateInstance));
-    }
-
-    virtual qtmir::DesktopFileReader* doCreateInstance(const QString &appId, const QFileInfo &fi)
-    {
-        using namespace ::testing;
-        auto instance = new NiceMock<MockDesktopFileReader>(appId, fi);
-        ON_CALL(*instance, loaded()).WillByDefault(Return(true));
-
-        return instance;
-    }
+    MockDesktopFileReaderFactory();
+    virtual ~MockDesktopFileReaderFactory();
+
+    virtual qtmir::DesktopFileReader* doCreateInstance(const QString &appId, const QFileInfo &fi);
 
     MOCK_METHOD2(createInstance, qtmir::DesktopFileReader*(const QString &appId, const QFileInfo &fi));
 };
-}
+
+} // namespace qtmir
 
 #endif // MOCK_DESKTOP_FILE_READER_H

=== added file 'tests/framework/mock_display.cpp'
--- tests/framework/mock_display.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/mock_display.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,35 @@
+/*
+ * 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 "mock_display.h"
+#include <mir/graphics/event_handler_register.h>
+#include <mir/graphics/display_configuration.h>
+
+MockDisplaySyncGroup::MockDisplaySyncGroup()
+{
+}
+
+MockDisplaySyncGroup::~MockDisplaySyncGroup()
+{
+}
+
+MockDisplay::MockDisplay()
+{
+}
+
+MockDisplay::~MockDisplay()
+{
+}

=== renamed file 'tests/common/mock_display.h' => 'tests/framework/mock_display.h'
--- tests/common/mock_display.h	2015-08-20 10:16:54 +0000
+++ tests/framework/mock_display.h	2016-02-03 11:35:51 +0000
@@ -26,6 +26,9 @@
 class MockDisplaySyncGroup : public mir::graphics::DisplaySyncGroup
 {
 public:
+    MockDisplaySyncGroup();
+    virtual ~MockDisplaySyncGroup();
+
     MOCK_METHOD1(for_each_display_buffer, void(std::function<void(mir::graphics::DisplayBuffer&)> const& f));
     MOCK_METHOD0(post, void());
 };
@@ -33,6 +36,9 @@
 struct MockDisplay : public mir::graphics::Display
 {
 public:
+    MockDisplay();
+    virtual ~MockDisplay();
+
     MOCK_METHOD1(for_each_display_sync_group, void(std::function<void(mir::graphics::DisplaySyncGroup&)> const&));
     MOCK_CONST_METHOD0(configuration, std::unique_ptr<mir::graphics::DisplayConfiguration>());
     MOCK_METHOD1(configure, void(mir::graphics::DisplayConfiguration const&));
@@ -48,6 +54,4 @@
     MOCK_METHOD0(create_gl_context, std::unique_ptr<mir::graphics::GLContext>());
 };
 
-
-
 #endif // MOCKDISPLAY_H

=== added file 'tests/framework/mock_display_configuration.cpp'
--- tests/framework/mock_display_configuration.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/mock_display_configuration.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,25 @@
+/*
+ * 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 "mock_display_configuration.h"
+
+MockDisplayConfiguration::MockDisplayConfiguration()
+{
+}
+
+MockDisplayConfiguration::~MockDisplayConfiguration()
+{
+}

=== renamed file 'tests/common/mock_display_configuration.h' => 'tests/framework/mock_display_configuration.h'
--- tests/common/mock_display_configuration.h	2015-12-04 15:44:11 +0000
+++ tests/framework/mock_display_configuration.h	2016-02-03 11:35:51 +0000
@@ -25,6 +25,9 @@
 class MockDisplayConfiguration : public mir::graphics::DisplayConfiguration
 {
 public:
+	MockDisplayConfiguration();
+	virtual ~MockDisplayConfiguration();
+
     MOCK_CONST_METHOD1(for_each_card, void(std::function<void(mir::graphics::DisplayConfigurationCard const&)>));
 
     MOCK_CONST_METHOD1(for_each_output, void(std::function<void(mir::graphics::DisplayConfigurationOutput const&)>));
@@ -33,4 +36,5 @@
 
     MOCK_CONST_METHOD0(valid, bool());
 };
+
 #endif // MOCK_DISPLAY_CONFIGURATION_H

=== added file 'tests/framework/mock_gl_display_buffer.cpp'
--- tests/framework/mock_gl_display_buffer.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/mock_gl_display_buffer.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,30 @@
+/*
+ * 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 "mock_gl_display_buffer.h"
+
+MockGLDisplayBuffer::MockGLDisplayBuffer()
+{
+    using namespace testing;
+    ON_CALL(*this, view_area())
+        .WillByDefault(Return(mir::geometry::Rectangle{{0,0},{0,0}}));
+    ON_CALL(*this, native_display_buffer())
+        .WillByDefault(Return(dynamic_cast<mir::graphics::NativeDisplayBuffer*>(this)));
+}
+
+MockGLDisplayBuffer::~MockGLDisplayBuffer()
+{
+}

=== renamed file 'tests/common/mock_gl_display_buffer.h' => 'tests/framework/mock_gl_display_buffer.h'
--- tests/common/mock_gl_display_buffer.h	2015-10-14 23:14:48 +0000
+++ tests/framework/mock_gl_display_buffer.h	2016-02-03 11:35:51 +0000
@@ -27,14 +27,9 @@
                             public mir::graphics::NativeDisplayBuffer
 {
 public:
-    MockGLDisplayBuffer()
-    {
-        using namespace testing;
-        ON_CALL(*this, view_area())
-            .WillByDefault(Return(mir::geometry::Rectangle{{0,0},{0,0}}));
-        ON_CALL(*this, native_display_buffer())
-            .WillByDefault(Return(dynamic_cast<mir::graphics::NativeDisplayBuffer*>(this)));
-    }
+    MockGLDisplayBuffer();
+    virtual ~MockGLDisplayBuffer();
+
     MOCK_CONST_METHOD0(view_area, mir::geometry::Rectangle());
     MOCK_METHOD1(post_renderables_if_optimizable, bool(mir::graphics::RenderableList const&));
     MOCK_CONST_METHOD0(orientation, MirOrientation());
@@ -45,5 +40,4 @@
     MOCK_METHOD0(swap_buffers, void());
 };
 
-
 #endif // MOCK_GL_DISPLAY_BUFFER_H

=== added file 'tests/framework/mock_main_loop.cpp'
--- tests/framework/mock_main_loop.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/mock_main_loop.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,28 @@
+/*
+ * 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 "mock_main_loop.h"
+
+MockMainLoop::MockMainLoop()
+{
+}
+
+MockMainLoop::~MockMainLoop()
+{
+}
+
+void MockMainLoop::run() {}
+void MockMainLoop::stop() {}
\ No newline at end of file

=== renamed file 'tests/common/mock_main_loop.h' => 'tests/framework/mock_main_loop.h'
--- tests/common/mock_main_loop.h	2015-08-20 10:16:54 +0000
+++ tests/framework/mock_main_loop.h	2016-02-03 11:35:51 +0000
@@ -17,19 +17,17 @@
 #ifndef MOCKMAINLOOP_H
 #define MOCKMAINLOOP_H
 
-#include <gmock/gmock.h>
-
 #include <mir/main_loop.h>
-
-#include <memory>
+#include "gmock_fixes.h"
 
 class MockMainLoop : public mir::MainLoop
 {
 public:
-    ~MockMainLoop() noexcept {}
+    MockMainLoop();
+    ~MockMainLoop() noexcept;
 
-    void run() override {}
-    void stop() override {}
+    void run() override;
+    void stop() override;
 
     MOCK_METHOD2(register_signal_handler,
                  void(std::initializer_list<int>,
@@ -49,5 +47,4 @@
     MOCK_METHOD1(create_alarm, std::unique_ptr<mir::time::Alarm>(std::shared_ptr<mir::LockableCallback> const& callback));
 };
 
-
 #endif // MOCKMAINLOOP_H

=== added file 'tests/framework/mock_mir_session.cpp'
--- tests/framework/mock_mir_session.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/mock_mir_session.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,63 @@
+/*
+ * 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 "mock_mir_session.h"
+
+namespace mir
+{
+namespace scene
+{
+
+MockSession::MockSession()
+{
+}
+
+MockSession::MockSession(const std::string &sessionName, pid_t processId)
+    : m_sessionName(sessionName), m_sessionId(processId)
+{
+}
+
+MockSession::~MockSession()
+{
+}
+
+std::string MockSession::name() const
+{
+    return m_sessionName;
+}
+
+pid_t MockSession::process_id() const
+{
+    return m_sessionId;
+}
+
+void MockSession::resume_prompt_session() {}
+
+void MockSession::suspend_prompt_session() {}
+
+void MockSession::stop_prompt_session() {}
+
+void MockSession::start_prompt_session() {}
+
+std::shared_ptr<scene::Surface> MockSession::surface_after(const std::shared_ptr<scene::Surface> &) const
+{
+    return {};
+}
+
+void MockSession::configure_streams(scene::Surface &, const std::vector<mir::shell::StreamSpecification> &) {}
+
+} // namespace scene
+} // namespace mir

=== modified file 'tests/framework/mock_mir_session.h'
--- tests/modules/common/mock_mir_session.h	2016-01-20 20:01:54 +0000
+++ tests/framework/mock_mir_session.h	2016-02-03 11:35:51 +0000
@@ -29,20 +29,13 @@
 
 struct MockSession : public Session
 {
-    MockSession() {}
-    MockSession(std::string const& sessionName, pid_t processId)
-        : m_sessionName(sessionName), m_sessionId(processId)
-    {}
-
-    std::string name() const override
-    {
-        return m_sessionName;
-    }
-
-    pid_t process_id() const override
-    {
-        return m_sessionId;
-    }
+    MockSession();
+    MockSession(std::string const& sessionName, pid_t processId);
+    virtual ~MockSession();
+
+    std::string name() const override;
+
+    pid_t process_id() const override;
 
     MOCK_METHOD0(force_requests_to_complete, void());
 
@@ -63,16 +56,16 @@
     MOCK_METHOD1(send_display_config, void(graphics::DisplayConfiguration const&));
     MOCK_METHOD3(configure_surface, int(frontend::SurfaceId, MirSurfaceAttrib, int));
 
-    void start_prompt_session() override {};
-    void stop_prompt_session() override {};
-    void suspend_prompt_session() override {};
-    void resume_prompt_session() override {};
-    std::shared_ptr<Surface> surface_after(std::shared_ptr<Surface> const&) const override { return {}; }
+    void start_prompt_session() override;
+    void stop_prompt_session() override;
+    void suspend_prompt_session() override;
+    void resume_prompt_session() override;
+    std::shared_ptr<Surface> surface_after(std::shared_ptr<Surface> const&) const override;
 
     MOCK_CONST_METHOD1(get_buffer_stream, std::shared_ptr<frontend::BufferStream>(frontend::BufferStreamId));
     MOCK_METHOD1(destroy_buffer_stream, void(frontend::BufferStreamId));
     MOCK_METHOD1(create_buffer_stream, frontend::BufferStreamId(graphics::BufferProperties const&));
-    void configure_streams(Surface&, std::vector<shell::StreamSpecification> const&) override {};
+    void configure_streams(Surface&, std::vector<shell::StreamSpecification> const&) override;;
 
     MOCK_METHOD1(send_input_device_change, void(std::vector<std::shared_ptr<mir::input::Device>> const&));
     //void send_input_device_change(std::vector<std::shared_ptr<input::Device>> const& devices) = 0;

=== added file 'tests/framework/mock_proc_info.cpp'
--- tests/framework/mock_proc_info.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/mock_proc_info.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,35 @@
+/*
+ * 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 "mock_proc_info.h"
+
+namespace qtmir
+{
+
+MockProcInfo::MockProcInfo()
+{
+}
+
+MockProcInfo::~MockProcInfo()
+{
+}
+
+std::unique_ptr<qtmir::ProcInfo::CommandLine> MockProcInfo::commandLine(pid_t pid)
+{
+    return std::unique_ptr<CommandLine>(new CommandLine{command_line(pid)});
+}
+
+} // namespace qtmir

=== modified file 'tests/framework/mock_proc_info.h'
--- tests/modules/common/mock_proc_info.h	2015-10-08 11:20:30 +0000
+++ tests/framework/mock_proc_info.h	2016-02-03 11:35:51 +0000
@@ -21,16 +21,17 @@
 
 #include <gmock/gmock.h>
 
-namespace testing
-{
+namespace qtmir {
+
 struct MockProcInfo : public qtmir::ProcInfo
 {
+    MockProcInfo();
+    virtual ~MockProcInfo();
+
     MOCK_METHOD1(command_line, QByteArray(pid_t));
-    std::unique_ptr<CommandLine> commandLine(pid_t pid)
-    {
-      return std::unique_ptr<CommandLine>(new CommandLine{command_line(pid)});
-    }
+    std::unique_ptr<CommandLine> commandLine(pid_t pid);
 };
-}
+
+} // namespace qtmir
 
 #endif // MOCK_PROC_INFO_H

=== added file 'tests/framework/mock_prompt_session.cpp'
--- tests/framework/mock_prompt_session.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/mock_prompt_session.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,33 @@
+/*
+ * 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 "mock_prompt_session.h"
+
+namespace mir
+{
+namespace scene
+{
+
+MockPromptSession::MockPromptSession()
+{
+}
+
+MockPromptSession::~MockPromptSession()
+{
+}
+
+} // namespace scene
+} // namespace mir

=== modified file 'tests/framework/mock_prompt_session.h'
--- tests/modules/common/mock_prompt_session.h	2015-08-11 12:08:32 +0000
+++ tests/framework/mock_prompt_session.h	2016-02-03 11:35:51 +0000
@@ -26,6 +26,9 @@
 struct MockPromptSession : public PromptSession
 {
 public:
+    MockPromptSession();
+    virtual ~MockPromptSession();
+
     MOCK_METHOD1(start, void(std::shared_ptr<Session> const&));
     MOCK_METHOD1(stop, void(std::shared_ptr<Session> const&));
     MOCK_METHOD1(suspend, void(std::shared_ptr<Session> const&));

=== added file 'tests/framework/mock_prompt_session_manager.cpp'
--- tests/framework/mock_prompt_session_manager.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/mock_prompt_session_manager.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,33 @@
+/*
+ * 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 "mock_prompt_session_manager.h"
+
+namespace mir
+{
+namespace scene
+{
+
+MockPromptSessionManager::MockPromptSessionManager()
+{
+}
+
+MockPromptSessionManager::~MockPromptSessionManager()
+{
+}
+
+} // namespace scene
+} // namespace mir

=== modified file 'tests/framework/mock_prompt_session_manager.h'
--- tests/modules/common/mock_prompt_session_manager.h	2015-08-11 12:08:32 +0000
+++ tests/framework/mock_prompt_session_manager.h	2016-02-03 11:35:51 +0000
@@ -28,6 +28,9 @@
 class MockPromptSessionManager: public PromptSessionManager
 {
 public:
+    MockPromptSessionManager();
+    virtual ~MockPromptSessionManager();
+
     MOCK_CONST_METHOD2(start_prompt_session_for, std::shared_ptr<PromptSession>(std::shared_ptr<mir::scene::Session> const&,
         mir::scene::PromptSessionCreationParameters const&));
 

=== added file 'tests/framework/mock_renderable.cpp'
--- tests/framework/mock_renderable.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/mock_renderable.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,33 @@
+/*
+ * 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 "mock_renderable.h"
+
+namespace mir
+{
+namespace graphics
+{
+
+MockRenderable::MockRenderable()
+{
+}
+
+MockRenderable::~MockRenderable()
+{
+}
+
+} // namespace graphics
+} // namespace mir

=== modified file 'tests/framework/mock_renderable.h'
--- tests/modules/common/mock_renderable.h	2015-08-11 12:08:32 +0000
+++ tests/framework/mock_renderable.h	2016-02-03 11:35:51 +0000
@@ -25,7 +25,8 @@
 
 struct MockRenderable : public Renderable
 {
-    MockRenderable() {};
+    MockRenderable();
+    virtual ~MockRenderable();
 
     MOCK_CONST_METHOD0(id, ID());
     MOCK_CONST_METHOD0(buffer, std::shared_ptr<Buffer>());

=== added file 'tests/framework/mock_session.cpp'
--- tests/framework/mock_session.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/mock_session.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,69 @@
+/*
+ * 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 "mock_session.h"
+
+namespace qtmir
+{
+
+MockSession::MockSession()
+    : SessionInterface(0)
+{
+    m_state = Starting;
+    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));
+    ON_CALL(*this, state()).WillByDefault(::testing::Invoke(this, &MockSession::doState));
+}
+
+MockSession::~MockSession()
+{
+
+}
+
+SessionInterface::State MockSession::doState() const
+{
+    return m_state;
+}
+
+void MockSession::doStop()
+{
+    setState(Stopped);
+}
+
+void MockSession::doResume()
+{
+    if (m_state == Suspending || m_state == Suspended) {
+        setState(Running);
+    }
+}
+
+void MockSession::doSuspend()
+{
+    if (m_state == Running) {
+        setState(Suspending);
+    }
+}
+
+void MockSession::setState(SessionInterface::State state)
+{
+    if (m_state != state) {
+        m_state = state;
+        Q_EMIT stateChanged(m_state);
+    }
+}
+
+} // namespace qtmir

=== modified file 'tests/framework/mock_session.h'
--- tests/modules/common/mock_session.h	2015-12-07 12:02:48 +0000
+++ tests/framework/mock_session.h	2016-02-03 11:35:51 +0000
@@ -24,13 +24,8 @@
 
 class MockSession : public SessionInterface {
 public:
-    MockSession() : SessionInterface(0) {
-        m_state = Starting;
-        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));
-        ON_CALL(*this, state()).WillByDefault(::testing::Invoke(this, &MockSession::doState));
-    }
+    MockSession();
+    virtual ~MockSession();
 
     MOCK_METHOD0(release, void());
 
@@ -66,29 +61,12 @@
     MOCK_CONST_METHOD0(activePromptSession, std::shared_ptr<mir::scene::PromptSession>());
     MOCK_CONST_METHOD1(foreachPromptSession, void(std::function<void(const std::shared_ptr<mir::scene::PromptSession>&)> f));
 
-    void setState(State state) {
-        if (m_state != state) {
-            m_state = state;
-            Q_EMIT stateChanged(m_state);
-        }
-    }
+    void setState(State state);
 
-    void doSuspend() {
-        if (m_state == Running) {
-            setState(Suspending);
-        }
-    }
-    void doResume() {
-        if (m_state == Suspending || m_state == Suspended) {
-            setState(Running);
-        }
-    }
-    void doStop() {
-        setState(Stopped);
-    }
-    State doState() const {
-        return m_state;
-    }
+    void doSuspend();
+    void doResume();
+    void doStop();
+    State doState() const;
 
 protected:
     MOCK_METHOD1(setFullscreen, void(bool fullscreen));
@@ -97,7 +75,6 @@
     MOCK_METHOD1(removePromptSession, void(const std::shared_ptr<mir::scene::PromptSession>& session));
 
 private:
-
     State m_state;
 };
 

=== added file 'tests/framework/mock_settings.cpp'
--- tests/framework/mock_settings.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/mock_settings.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,40 @@
+/*
+ * 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 "mock_settings.h"
+
+namespace qtmir
+{
+
+MockSettings::MockSettings()
+{
+    using namespace ::testing;
+
+    QVariantList lifecycleExemptAppIds;
+    lifecycleExemptAppIds << "com.ubuntu.music";
+    ON_CALL(*this, get(_))
+            .WillByDefault(
+                Return(lifecycleExemptAppIds));
+
+}
+
+MockSettings::~MockSettings()
+{
+
+}
+
+} // namespace qtmir
+

=== modified file 'tests/framework/mock_settings.h'
--- tests/modules/common/mock_settings.h	2015-03-24 23:38:33 +0000
+++ tests/framework/mock_settings.h	2016-02-03 11:35:51 +0000
@@ -18,24 +18,20 @@
 #define MOCK_SETTINGS_H
 
 #include <Unity/Application/settings_interface.h>
-
+#include <QVariant>
+ 
 #include <gmock/gmock.h>
 
-namespace testing
+namespace qtmir
 {
 struct MockSettings : public qtmir::SettingsInterface
 {
-    MockSettings()
-    {
-        QVariantList lifecycleExemptAppIds;
-        lifecycleExemptAppIds << "com.ubuntu.music";
-        ON_CALL(*this, get(_))
-                .WillByDefault(
-                    Return(lifecycleExemptAppIds));
+    MockSettings();
+    virtual ~MockSettings();
 
-    }
     MOCK_CONST_METHOD1(get, QVariant(const QString &));
 };
 
-} // namespace testing
+} // namespace qtmir
+
 #endif // MOCK_SETTINGS_H

=== added file 'tests/framework/mock_shared_wakelock.cpp'
--- tests/framework/mock_shared_wakelock.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/mock_shared_wakelock.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,61 @@
+/*
+ * 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 "mock_shared_wakelock.h"
+
+namespace qtmir
+{
+
+MockSharedWakelock::MockSharedWakelock(const QDBusConnection &)
+{
+    using namespace ::testing;
+
+    ON_CALL(*this, enabled()).WillByDefault(Invoke(this, &MockSharedWakelock::doEnabled));
+    ON_CALL(*this, acquire(_)).WillByDefault(Invoke(this, &MockSharedWakelock::doAcquire));
+    ON_CALL(*this, release(_)).WillByDefault(Invoke(this, &MockSharedWakelock::doRelease));
+}
+
+MockSharedWakelock::~MockSharedWakelock()
+{
+}
+
+void MockSharedWakelock::doRelease(const QObject *object)
+{
+    if (!m_owners.remove(object)) {
+        return;
+    }
+    if (m_owners.isEmpty()) {
+        Q_EMIT enabledChanged(false);
+    }
+}
+
+void MockSharedWakelock::doAcquire(const QObject *object)
+{
+    if (m_owners.contains(object)) {
+        return;
+    }
+    m_owners.insert(object);
+    if (m_owners.size() == 1) {
+        Q_EMIT enabledChanged(true);
+    }
+}
+
+bool MockSharedWakelock::doEnabled()
+{
+    return !m_owners.isEmpty();
+}
+
+} // namespace qtmir

=== modified file 'tests/framework/mock_shared_wakelock.h'
--- tests/modules/common/mock_shared_wakelock.h	2015-03-05 09:36:02 +0000
+++ tests/framework/mock_shared_wakelock.h	2016-02-03 11:35:51 +0000
@@ -21,51 +21,26 @@
 
 #include <gmock/gmock.h>
 
-namespace testing
+namespace qtmir
 {
 class MockSharedWakelock : public qtmir::SharedWakelock
 {
 public:
-    MockSharedWakelock(const QDBusConnection& /*connection*/= QDBusConnection::systemBus())
-    {
-        ON_CALL(*this, enabled()).WillByDefault(Invoke(this, &MockSharedWakelock::doEnabled));
-        ON_CALL(*this, acquire(_)).WillByDefault(Invoke(this, &MockSharedWakelock::doAcquire));
-        ON_CALL(*this, release(_)).WillByDefault(Invoke(this, &MockSharedWakelock::doRelease));
-    }
+    MockSharedWakelock(const QDBusConnection& /*connection*/= QDBusConnection::systemBus());
+    virtual ~MockSharedWakelock();
 
     MOCK_CONST_METHOD0(enabled, bool());
     MOCK_METHOD1(acquire, void(const QObject *));
     MOCK_METHOD1(release, void(const QObject *));
 
-    bool doEnabled()
-    {
-        return !m_owners.isEmpty();
-    }
-
-    void doAcquire(const QObject *object)
-    {
-        if (m_owners.contains(object)) {
-            return;
-        }
-        m_owners.insert(object);
-        if (m_owners.size() == 1) {
-            Q_EMIT enabledChanged(true);
-        }
-    }
-
-    void doRelease(const QObject *object)
-    {
-        if (!m_owners.remove(object)) {
-            return;
-        }
-        if (m_owners.isEmpty()) {
-            Q_EMIT enabledChanged(false);
-        }
-    }
+    bool doEnabled();
+    void doAcquire(const QObject *object);
+    void doRelease(const QObject *object);
 
 private:
     QSet<const QObject *> m_owners;
 };
 
-} // namespace testing
+} // namespace qtmir
+
 #endif // MOCK_SHARED_WAKELOCK_H

=== added file 'tests/framework/mock_surface.cpp'
--- tests/framework/mock_surface.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/mock_surface.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,45 @@
+/*
+ * 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 "mock_surface.h"
+
+namespace mir
+{
+namespace scene
+{
+
+MockSurface::MockSurface()
+{
+}
+
+MockSurface::~MockSurface()
+{
+}
+
+void MockSurface::rename(const std::string &) {}
+
+void MockSurface::set_keymap(MirInputDeviceId,
+                             std::string const&,
+                             std::string const&,
+                             std::string const&,
+                             std::string const&)
+{
+}
+
+// void MockSurface::consume(const MirEvent &event) { consume(&event); }
+
+} // namespace scene
+} // namespace mir

=== modified file 'tests/framework/mock_surface.h'
--- tests/modules/common/mock_surface.h	2016-01-24 02:51:34 +0000
+++ tests/framework/mock_surface.h	2016-02-03 11:35:51 +0000
@@ -28,7 +28,8 @@
 
 struct MockSurface : public mir::scene::Surface
 {
-    MockSurface() {}
+    MockSurface();
+    virtual ~MockSurface();
 
     MOCK_CONST_METHOD0(name, std::string());
     MOCK_CONST_METHOD0(client_size, geometry::Size());
@@ -63,15 +64,15 @@
     MOCK_METHOD0(request_client_surface_close, void());
     MOCK_CONST_METHOD1(buffers_ready_for_compositor, int(void const*));
     void set_keymap(MirInputDeviceId, std::string const&, std::string const&,
-        std::string const&, std::string const&) override {}
-    void rename(std::string const&) override {}
+        std::string const&, std::string const&) override;
+    void rename(std::string const&) override;
     MOCK_METHOD1(set_streams, void(std::list<StreamInfo> const&));
 
     // from mir::input::surface
     MOCK_CONST_METHOD1(input_area_contains, bool(geometry::Point const& point));
     MOCK_CONST_METHOD0(reception_mode, input::InputReceptionMode());
     MOCK_METHOD1(consume, void(MirEvent const* event));
-    //void consume(MirEvent const* event) override { consume(event); }
+    //void consume(MirEvent const* event) override;
 
     // from mir::frontend::surface
     MOCK_CONST_METHOD0(pixel_format, MirPixelFormat());

=== added file 'tests/framework/mock_task_controller.cpp'
--- tests/framework/mock_task_controller.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/mock_task_controller.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,129 @@
+/*
+ * 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 "mock_task_controller.h"
+
+namespace qtmir
+{
+
+MockTaskController::MockTaskController()
+{
+    using namespace ::testing;
+    ON_CALL(*this, primaryPidForAppId(_))
+            .WillByDefault(
+                Invoke(this, &MockTaskController::doPrimaryPidForAppId));
+
+    ON_CALL(*this, appIdHasProcessId(_, _))
+            .WillByDefault(
+                Invoke(this, &MockTaskController::doAppIdHasProcessId));
+
+    ON_CALL(*this, findDesktopFileForAppId(_))
+            .WillByDefault(
+                Invoke(this, &MockTaskController::doFindDesktopFileForAppId));
+
+    ON_CALL(*this, stop(_))
+            .WillByDefault(
+                Invoke(this, &MockTaskController::doStop));
+
+    ON_CALL(*this, start(_, _))
+            .WillByDefault(
+                Invoke(this, &MockTaskController::doStart));
+
+    ON_CALL(*this, suspend(_))
+            .WillByDefault(
+                Invoke(this, &MockTaskController::doSuspend));
+
+    ON_CALL(*this, resume(_))
+            .WillByDefault(
+                Invoke(this, &MockTaskController::doResume));
+}
+
+MockTaskController::~MockTaskController()
+{
+
+}
+
+pid_t MockTaskController::doPrimaryPidForAppId(const QString &appId)
+{
+    auto it = children.find(appId);
+    if (it == children.end())
+        return -1;
+
+    return it->pid();
+}
+
+
+bool MockTaskController::doAppIdHasProcessId(const QString &appId, pid_t pid)
+{
+    auto it = children.find(appId);
+    if (it == children.end())
+        return -1;
+
+    return it->pid() == pid;
+}
+
+
+QFileInfo MockTaskController::doFindDesktopFileForAppId(const QString &appId) const
+{
+    QString path = QString("/usr/share/applications/%1.desktop").arg(appId);
+    return QFileInfo(path);
+}
+
+
+bool MockTaskController::doStop(const QString &appId)
+{
+    Q_UNUSED(appId);
+
+    return false;
+}
+
+
+bool MockTaskController::doStart(const QString &appId, const QStringList &args)
+{
+    Q_UNUSED(args);
+
+    auto child = core::posix::fork([]()
+    {
+        while (true);
+
+        return core::posix::exit::Status::success;
+    }, core::posix::StandardStream::empty);
+
+    if (child.pid() > 0)
+    {
+        children.insert(appId, child);
+        return true;
+    }
+
+    return false;
+}
+
+
+bool MockTaskController::doSuspend(const QString &appId)
+{
+    Q_UNUSED(appId);
+
+    return false;
+}
+
+bool MockTaskController::doResume(const QString &appId)
+{
+    Q_UNUSED(appId);
+
+    return false;
+}
+
+} // namespace qtmir

=== renamed file 'tests/modules/common/mock_application_controller.h' => 'tests/framework/mock_task_controller.h'
--- tests/modules/common/mock_application_controller.h	2015-08-11 12:08:32 +0000
+++ tests/framework/mock_task_controller.h	2016-02-03 11:35:51 +0000
@@ -14,127 +14,50 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef MOCK_APPLICATION_CONTROLLER_H
-#define MOCK_APPLICATION_CONTROLLER_H
+#ifndef MOCK_TASK_CONTROLLER_H
+#define MOCK_TASK_CONTROLLER_H
 
-#include <Unity/Application/applicationcontroller.h>
+#include <Unity/Application/taskcontroller.h>
+#include <QMap>
 
 #include <core/posix/fork.h>
 
 #include <gmock/gmock.h>
 
-namespace testing
-{
-struct MockApplicationController : public qtmir::ApplicationController
-{
+namespace qtmir
+{
+struct MockTaskController : public qtmir::TaskController
+{
+    MockTaskController();
+    virtual ~MockTaskController();
+
     MOCK_METHOD1(primaryPidForAppId, pid_t(const QString& appId));
-    MOCK_METHOD2(appIdHasProcessId, bool(pid_t, const QString&));
+    MOCK_METHOD2(appIdHasProcessId, bool(const QString&, pid_t));
     MOCK_CONST_METHOD1(findDesktopFileForAppId, QFileInfo(const QString &appId));
 
-    MOCK_METHOD1(stopApplicationWithAppId, bool(const QString&));
-    MOCK_METHOD2(startApplicationWithAppIdAndArgs, bool(const QString&, const QStringList&));
-    MOCK_METHOD1(pauseApplicationWithAppId, bool(const QString&));
-    MOCK_METHOD1(resumeApplicationWithAppId, bool(const QString&));
-
-    MockApplicationController()
-    {
-        using namespace ::testing;
-        ON_CALL(*this, primaryPidForAppId(_))
-                .WillByDefault(
-                    Invoke(this, &MockApplicationController::doPrimaryPidForAppId));
-
-        ON_CALL(*this, appIdHasProcessId(_, _))
-                .WillByDefault(
-                    Invoke(this, &MockApplicationController::doAppIdHasProcessId));
-
-        ON_CALL(*this, findDesktopFileForAppId(_))
-                .WillByDefault(
-                    Invoke(this, &MockApplicationController::doFindDesktopFileForAppId));
-
-        ON_CALL(*this, stopApplicationWithAppId(_))
-                .WillByDefault(
-                    Invoke(this, &MockApplicationController::doStopApplicationWithAppId));
-
-        ON_CALL(*this, startApplicationWithAppIdAndArgs(_, _))
-                .WillByDefault(
-                    Invoke(this, &MockApplicationController::doStartApplicationWithAppIdAndArgs));
-
-        ON_CALL(*this, pauseApplicationWithAppId(_))
-                .WillByDefault(
-                    Invoke(this, &MockApplicationController::doPauseApplicationWithAppId));
-
-        ON_CALL(*this, resumeApplicationWithAppId(_))
-                .WillByDefault(
-                    Invoke(this, &MockApplicationController::doResumeApplicationWithAppId));
-    }
-
-    pid_t doPrimaryPidForAppId(const QString& appId)
-    {
-        auto it = children.find(appId);
-        if (it == children.end())
-            return -1;
-
-        return it->pid();
-    }
-
-    bool doAppIdHasProcessId(pid_t pid, const QString& appId)
-    {
-        auto it = children.find(appId);
-        if (it == children.end())
-            return -1;
-
-        return it->pid() == pid;
-    }
-
-    QFileInfo doFindDesktopFileForAppId(const QString& appId) const
-    {
-        QString path = QString("/usr/share/applications/%1.desktop").arg(appId);
-        return QFileInfo(path);
-    }
-
-    bool doStopApplicationWithAppId(const QString& appId)
-    {
-        Q_UNUSED(appId);
-
-        return false;
-    }
-
-    bool doStartApplicationWithAppIdAndArgs(const QString& appId, const QStringList& args)
-    {
-        Q_UNUSED(args);
-
-        auto child = core::posix::fork([]()
-        {
-            while (true);
-
-            return core::posix::exit::Status::success;
-        }, core::posix::StandardStream::empty);
-
-        if (child.pid() > 0)
-        {
-            children.insert(appId, child);
-            return true;
-        }
-
-        return false;
-    }
-
-    bool doPauseApplicationWithAppId(const QString& appId)
-    {
-        Q_UNUSED(appId);
-
-        return false;
-    }
-
-    bool doResumeApplicationWithAppId(const QString& appId)
-    {
-        Q_UNUSED(appId);
-
-        return false;
-    }
-
+    MOCK_METHOD1(stop, bool(const QString&));
+    MOCK_METHOD2(start, bool(const QString&, const QStringList&));
+    MOCK_METHOD1(suspend, bool(const QString&));
+    MOCK_METHOD1(resume, bool(const QString&));
+
+    pid_t doPrimaryPidForAppId(const QString& appId);
+
+    bool doAppIdHasProcessId(const QString& appId, pid_t pid);
+
+    QFileInfo doFindDesktopFileForAppId(const QString& appId) const;
+
+    bool doStop(const QString& appId);
+
+    bool doStart(const QString& appId, const QStringList& args);
+
+    bool doSuspend(const QString& appId);
+
+    bool doResume(const QString& appId);
+
+private:
     QMap<QString, core::posix::ChildProcess> children;
 };
-} // namespace testing
-
-#endif // MOCK_APPLICATION_CONTROLLER_H
+
+} // namespace qtmir
+
+#endif // MOCK_TASK_CONTROLLER_H

=== modified file 'tests/framework/qtmir_test.cpp'
--- tests/modules/common/qtmir_test.cpp	2016-01-22 16:32:39 +0000
+++ tests/framework/qtmir_test.cpp	2016-02-03 11:35:51 +0000
@@ -18,7 +18,8 @@
 
 namespace qtmir {
 
-void PrintTo(const Application::InternalState& state, ::std::ostream* os) {
+void PrintTo(const Application::InternalState& state, ::std::ostream* os)
+{
     switch (state) {
     case Application::InternalState::Starting:
         *os << "Starting";
@@ -77,4 +78,97 @@
     }
 }
 
+// Initialization of mir::Server needed for by tests
+class TestMirServerInit : public virtual mir::Server
+{
+public:
+    TestMirServerInit(std::shared_ptr<StubPromptSessionManager> const& promptSessionManager)
+        : mock_prompt_session_manager(promptSessionManager)
+    {
+        override_the_prompt_session_manager(
+            [this]{ return the_mock_prompt_session_manager(); });
+    }
+
+    std::shared_ptr<mir::scene::MockPromptSessionManager> the_mock_prompt_session_manager()
+    {
+        return mock_prompt_session_manager;
+    }
+
+private:
+    std::shared_ptr<StubPromptSessionManager> const mock_prompt_session_manager;
+};
+
+
+namespace {  char const* argv[] = { nullptr }; }
+
+class FakeMirServer: private TestMirServerInit, public MirServer
+{
+public:
+    FakeMirServer(std::shared_ptr<StubPromptSessionManager> const& promptSessionManager)
+    : TestMirServerInit(promptSessionManager), MirServer(0, argv, QSharedPointer<ScreenController>())
+    {
+    }
+
+    using TestMirServerInit::the_mock_prompt_session_manager;
+};
+
 } // namespace qtmir
+
+namespace testing
+{
+
+QtMirTest::QtMirTest()
+    : promptSessionManager(std::make_shared<StubPromptSessionManager>())
+    , mirServer(QSharedPointer<MirServer>(new FakeMirServer(promptSessionManager)))
+    , applicationManager(mirServer,
+                         taskControllerSharedPointer,
+                         QSharedPointer<MockSharedWakelock>(&sharedWakelock, [](MockSharedWakelock *){}),
+                         QSharedPointer<DesktopFileReader::Factory>(&desktopFileReaderFactory,[](DesktopFileReader::Factory*){}),
+                         QSharedPointer<ProcInfo>(&procInfo,[](ProcInfo *){}),
+                         QSharedPointer<MockSettings>(&settings,[](MockSettings *){}))
+    , sessionManager(mirServer, &applicationManager)
+    , surfaceManager(mirServer, mirShell, &sessionManager)
+{
+}
+
+QtMirTest::~QtMirTest()
+{
+
+}
+
+Application *QtMirTest::startApplication(pid_t procId, const QString &appId)
+{
+    using namespace testing;
+
+    ON_CALL(*taskController,appIdHasProcessId(appId, procId)).WillByDefault(Return(true));
+
+    // 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));
+
+    EXPECT_CALL(desktopFileReaderFactory, createInstance(appId, _))
+            .Times(1)
+            .WillOnce(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(*taskController, start(appId, _))
+            .Times(1)
+            .WillOnce(Return(true));
+
+    auto application = applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+
+    bool authed = false;
+    applicationManager.authorizeSession(procId, authed);
+    EXPECT_EQ(authed, true);
+
+    auto appSession = std::make_shared<mir::scene::MockSession>(appId.toStdString(), procId);
+    applicationManager.onSessionStarting(appSession);
+    sessionManager.onSessionStarting(appSession);
+
+    Mock::VerifyAndClearExpectations(taskController);
+    Mock::VerifyAndClearExpectations(&desktopFileReaderFactory);
+    return application;
+}
+
+} // namespace testing

=== modified file 'tests/framework/qtmir_test.h'
--- tests/modules/common/qtmir_test.h	2015-12-07 10:51:03 +0000
+++ tests/framework/qtmir_test.h	2016-02-03 11:35:51 +0000
@@ -21,18 +21,17 @@
 
 #include <gtest/gtest.h>
 
+#include <QSharedPointer>
+
 #include <Unity/Application/application.h>
 #include <Unity/Application/application_manager.h>
-#include <Unity/Application/applicationcontroller.h>
 #include <Unity/Application/mirsurfacemanager.h>
 #include <Unity/Application/sessionmanager.h>
 #include <Unity/Application/session_interface.h>
 #include <Unity/Application/sharedwakelock.h>
-#include <Unity/Application/taskcontroller.h>
 #include <Unity/Application/proc_info.h>
 #include <mirserver.h>
 
-#include "mock_application_controller.h"
 #include "mock_desktop_file_reader.h"
 #include "mock_proc_info.h"
 #include "mock_mir_session.h"
@@ -40,51 +39,19 @@
 #include "mock_prompt_session.h"
 #include "mock_shared_wakelock.h"
 #include "mock_settings.h"
+#include "mock_task_controller.h"
 
 namespace ms = mir::scene;
 using namespace qtmir;
 
 namespace qtmir {
 
+typedef testing::NiceMock<mir::scene::MockPromptSessionManager> StubPromptSessionManager;
+
 // For better output in ASSERT_* and EXPECT_* error messages
 void PrintTo(const Application::InternalState& state, ::std::ostream* os);
 void PrintTo(const SessionInterface::State& state, ::std::ostream* os);
 
-// Initialization of mir::Server needed for by tests
-class TestMirServerInit : public virtual mir::Server
-{
-public:
-    TestMirServerInit()
-    {
-        override_the_prompt_session_manager(
-            [this]{ return the_mock_prompt_session_manager(); });
-    }
-
-    std::shared_ptr<mir::scene::MockPromptSessionManager> the_mock_prompt_session_manager()
-    {
-        return mock_prompt_session_manager;
-    }
-
-private:
-    typedef testing::NiceMock<mir::scene::MockPromptSessionManager> StubPromptSessionManager;
-    std::shared_ptr<StubPromptSessionManager> const mock_prompt_session_manager
-        {std::make_shared<StubPromptSessionManager>()};
-};
-
-
-namespace {  char const* argv[] = { nullptr }; }
-
-class FakeMirServer: private TestMirServerInit, public MirServer
-{
-public:
-    FakeMirServer()
-    : MirServer(0, argv, QSharedPointer<ScreenController>())
-    {
-    }
-
-    using TestMirServerInit::the_mock_prompt_session_manager;
-};
-
 } // namespace qtmir
 
 namespace testing {
@@ -92,85 +59,21 @@
 class QtMirTest : public ::testing::Test
 {
 public:
-    QtMirTest()
-        : mirServer{
-            QSharedPointer<FakeMirServer> (new FakeMirServer)
-        }
-        , taskController{
-              QSharedPointer<TaskController> (
-                  new TaskController(
-                      nullptr,
-                      QSharedPointer<ApplicationController>(
-                          &appController,
-                          [](ApplicationController*){})
-                  )
-              )
-        }
-        , applicationManager{
-            mirServer,
-            taskController,
-            QSharedPointer<MockSharedWakelock>(&sharedWakelock, [](MockSharedWakelock *){}),
-            QSharedPointer<DesktopFileReader::Factory>(
-                &desktopFileReaderFactory,
-                [](DesktopFileReader::Factory*){}),
-            QSharedPointer<ProcInfo>(&procInfo,[](ProcInfo *){}),
-            QSharedPointer<MockSettings>(&settings,[](MockSettings *){})
-        }
-        , sessionManager{
-            mirServer,
-            &applicationManager,
-        }
-        , surfaceManager{
-            mirServer,
-            mirShell,
-            &sessionManager
-        }
-    {
-    }
-
-    Application* startApplication(pid_t procId, QString const& appId)
-    {
-        using namespace testing;
-
-        ON_CALL(appController,appIdHasProcessId(procId, appId)).WillByDefault(Return(true));
-
-        // 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));
-
-        EXPECT_CALL(desktopFileReaderFactory, createInstance(appId, _))
-                .Times(1)
-                .WillOnce(Return(mockDesktopFileReader));
-
-        EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
-                .Times(1)
-                .WillOnce(Return(true));
-
-        auto application = applicationManager.startApplication(appId, ApplicationManager::NoFlag);
-        applicationManager.onProcessStarting(appId);
-
-        bool authed = false;
-        applicationManager.authorizeSession(procId, authed);
-        EXPECT_EQ(authed, true);
-
-        auto appSession = std::make_shared<mir::scene::MockSession>(appId.toStdString(), procId);
-        applicationManager.onSessionStarting(appSession);
-        sessionManager.onSessionStarting(appSession);
-        
-        Mock::VerifyAndClearExpectations(&appController);
-        Mock::VerifyAndClearExpectations(&desktopFileReaderFactory);
-        return application;
-    }
-
-    testing::NiceMock<testing::MockApplicationController> appController;
-    testing::NiceMock<testing::MockProcInfo> procInfo;
-    testing::NiceMock<testing::MockDesktopFileReaderFactory> desktopFileReaderFactory;
-    testing::NiceMock<testing::MockSharedWakelock> sharedWakelock;
-    testing::NiceMock<testing::MockSettings> settings;
-    QSharedPointer<FakeMirServer> mirServer;
+    QtMirTest();
+    virtual ~QtMirTest();
+
+    Application* startApplication(pid_t procId, QString const& appId);
+
+    QSharedPointer<qtmir::TaskController> taskControllerSharedPointer{new testing::NiceMock<qtmir::MockTaskController>};
+    testing::NiceMock<qtmir::MockTaskController> *taskController{static_cast<testing::NiceMock<qtmir::MockTaskController>*>(taskControllerSharedPointer.data())};
+    testing::NiceMock<MockProcInfo> procInfo;
+    testing::NiceMock<MockDesktopFileReaderFactory> desktopFileReaderFactory;
+    testing::NiceMock<MockSharedWakelock> sharedWakelock;
+    testing::NiceMock<MockSettings> settings;
+    std::shared_ptr<StubPromptSessionManager> promptSessionManager;
+    QSharedPointer<MirServer> mirServer;
+
     MirShell *mirShell{nullptr};
-    QSharedPointer<TaskController> taskController;
     ApplicationManager applicationManager;
     SessionManager sessionManager;
     MirSurfaceManager surfaceManager;

=== added file 'tests/framework/stub_input_channel.cpp'
--- tests/framework/stub_input_channel.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/stub_input_channel.cpp	2016-02-03 11:35:51 +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/>.
+ */
+
+#include "stub_input_channel.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+StubInputChannel::StubInputChannel(int fd)
+    : input_fd(fd)
+{
+}
+
+StubInputChannel::StubInputChannel()
+    : StubInputChannel(0)
+{
+}
+
+StubInputChannel::~StubInputChannel()
+{
+}
+
+int StubInputChannel::client_fd() const
+{
+    return input_fd;
+}
+
+int StubInputChannel::server_fd() const
+{
+    return input_fd;
+}
+
+} // namespace doubles
+} // namespace test
+} // namespace mir

=== modified file 'tests/framework/stub_input_channel.h'
--- tests/modules/common/stub_input_channel.h	2015-08-11 12:08:32 +0000
+++ tests/framework/stub_input_channel.h	2016-02-03 11:35:51 +0000
@@ -28,24 +28,14 @@
 
 struct StubInputChannel : public input::InputChannel
 {
-    StubInputChannel(int fd)
-      : input_fd(fd)
-    {
-    }
-
-    StubInputChannel()
-     : StubInputChannel(0)
-    {
-    }
-
-    int client_fd() const override
-    {
-        return input_fd;
-    }
-    int server_fd() const override
-    {
-        return input_fd;
-    }
+    StubInputChannel(int fd);
+
+    StubInputChannel();
+
+    virtual ~StubInputChannel();
+
+    int client_fd() const override;
+    int server_fd() const override;
     int input_fd;
 };
 

=== added file 'tests/framework/stub_scene_surface.cpp'
--- tests/framework/stub_scene_surface.cpp	1970-01-01 00:00:00 +0000
+++ tests/framework/stub_scene_surface.cpp	2016-02-03 11:35:51 +0000
@@ -0,0 +1,103 @@
+/*
+ * 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 "stub_scene_surface.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+StubSceneSurface::StubSceneSurface(int fd)
+    : channel(std::make_shared<StubInputChannel>(fd)), fd(fd)
+{
+}
+
+StubSceneSurface::~StubSceneSurface()
+{
+}
+
+std::shared_ptr<mir::input::InputChannel> StubSceneSurface::input_channel() const
+{
+    return channel;
+}
+
+mir::input::InputReceptionMode StubSceneSurface::reception_mode() const
+{
+    return input_mode;
+}
+
+std::string StubSceneSurface::name() const { return {}; }
+
+mir::geometry::Point StubSceneSurface::top_left() const { return {}; }
+
+mir::geometry::Size StubSceneSurface::client_size() const { return {};}
+
+mir::geometry::Size StubSceneSurface::size() const { return {}; }
+
+mir::geometry::Rectangle StubSceneSurface::input_bounds() const { return {{},{}}; }
+
+bool StubSceneSurface::input_area_contains(mir::geometry::Point const&) const { return false; }
+
+mir::graphics::RenderableList StubSceneSurface::generate_renderables(mir::compositor::CompositorID) const { return {};}
+
+float StubSceneSurface::alpha() const { return 0.0f; }
+
+MirSurfaceType StubSceneSurface::type() const { return mir_surface_type_normal; }
+
+MirSurfaceState StubSceneSurface::state() const { return mir_surface_state_unknown; }
+
+void StubSceneSurface::hide() {}
+
+void StubSceneSurface::show() {}
+
+void StubSceneSurface::move_to(const mir::geometry::Point &) {}
+
+void StubSceneSurface::set_input_region(const std::vector<mir::geometry::Rectangle> &) {}
+
+void StubSceneSurface::resize(const mir::geometry::Size &) {}
+
+void StubSceneSurface::set_transformation(const glm::mat4 &) {}
+
+void StubSceneSurface::set_alpha(float) {}
+
+void StubSceneSurface::set_orientation(MirOrientation) {}
+
+void StubSceneSurface::add_observer(const std::shared_ptr<mir::scene::SurfaceObserver> &) {}
+
+void StubSceneSurface::remove_observer(const std::weak_ptr<mir::scene::SurfaceObserver> &) {}
+
+void StubSceneSurface::set_reception_mode(mir::input::InputReceptionMode mode) { input_mode = mode; }
+
+void StubSceneSurface::consume(const MirEvent *) {}
+
+void StubSceneSurface::set_cursor_image(const std::shared_ptr<mir::graphics::CursorImage> &) {}
+
+std::shared_ptr<mir::graphics::CursorImage> StubSceneSurface::cursor_image() const { return {}; }
+
+bool StubSceneSurface::supports_input() const { return true; }
+
+int StubSceneSurface::client_input_fd() const { return fd;}
+
+int StubSceneSurface::configure(MirSurfaceAttrib, int) { return 0; }
+
+int StubSceneSurface::query(MirSurfaceAttrib) const { return 0; }
+
+} // namespace doubles
+} // namespace test
+} // namespace mir

=== modified file 'tests/framework/stub_scene_surface.h'
--- tests/modules/common/stub_scene_surface.h	2016-01-20 20:01:54 +0000
+++ tests/framework/stub_scene_surface.h	2016-02-03 11:35:51 +0000
@@ -38,55 +38,47 @@
     int fd;
     mir::input::InputReceptionMode input_mode{mir::input::InputReceptionMode::normal};
 
-    StubSceneSurface(int fd)
-        : channel(std::make_shared<StubInputChannel>(fd)), fd(fd)
-    {
-    }
-
-    std::shared_ptr<mir::input::InputChannel> input_channel() const override
-    {
-        return channel;
-    }
-
-    mir::input::InputReceptionMode reception_mode() const override
-    {
-        return input_mode;
-    }
-
-    std::string name() const override { return {}; }
-    geometry::Point top_left() const override { return {}; }
-    geometry::Size client_size() const override { return {};}
-    geometry::Size size() const override { return {}; }
-    geometry::Rectangle input_bounds() const override { return {{},{}}; }
-    bool input_area_contains(mir::geometry::Point const&) const override { return false; }
-
-    graphics::RenderableList generate_renderables(compositor::CompositorID) const override { return {};}
-    float alpha() const override { return 0.0f;}