Merge lp:~gerboland/qtmir/initialSurfaceGeometry into lp:qtmir

[Gerry Boland]

Implement a callback mechanism to allow shell override the initial surface geometry requested by clients

* Are there any related MPs required for this MP to build/function as expected? Please list.
https://code.launchpad.net/~gerboland/unity-api/surfaceSizerCallback/+merge/231698
 * Did you perform an exploratory manual test run of your code change and any related functionality?
Y
 * If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
N/A
 * If you changed the UI, has there been a design review?
N/A

[Michał Sawicz (saviq)]

See inline.

review: Needs Fixing

[Gerry Boland (gerboland)]

Comments addressed, please check out rev 234

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:235
http://jenkins.qa.ubuntu.com/job/qtmir-ci/1/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/1/console

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

review: Needs Fixing (continuous-integration)

[Daniel d'Andrada (dandrader)]

In src/platforms/mirserver/mirplacementstrategy.h
+ void sessionAboutToCreateSurface(const mir::scene::Session &session, QSize &surfaceGeometry); // requires Qt::BlockingQueuedConnection!!

That line is way too long.

In tests/modules/ApplicationManager/application_manager_test.cpp

+ QJSValue callback = jsEngine->evaluate("(function(surface) { var out = new Object(); out.height = 333; return out; })");

Here as well.

Looks good otherwise.

review: Needs Fixing

[Gerry Boland (gerboland)]

Done

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:236
http://jenkins.qa.ubuntu.com/job/qtmir-ci/11/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/11/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/11/console

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

review: Needs Fixing (continuous-integration)

[Daniel d'Andrada (dandrader)]

review: Approve

[Michał Sawicz (saviq)]

Minor inline.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:237
http://jenkins.qa.ubuntu.com/job/qtmir-ci/27/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/27/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/27/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:238
http://jenkins.qa.ubuntu.com/job/qtmir-ci/28/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/28/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/28/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:240
http://jenkins.qa.ubuntu.com/job/qtmir-ci/29/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/29/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/29/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:241
http://jenkins.qa.ubuntu.com/job/qtmir-ci/31/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/31/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/31/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:241
http://jenkins.qa.ubuntu.com/job/qtmir-ci/32/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/32/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/32/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:243
http://jenkins.qa.ubuntu.com/job/qtmir-ci/33/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/33/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/33/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:244
http://jenkins.qa.ubuntu.com/job/qtmir-ci/34/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/34/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/34/console

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

review: Needs Fixing (continuous-integration)

[Michał Sawicz (saviq)]

Looks good.

review: Approve

[Alan Griffiths (alan-griffiths)]

635 + std::shared_ptr<MirPlacementStrategy> m_placementStrategy; // remove when bug lp:1407687 fixed
...
601 + //auto sharedPtr = the_placement_strategy(); - re-instate when bug lp:1407687 fixed
602 + if (m_placementStrategy.unique()) return 0;
603 +
604 + return static_cast<MirPlacementStrategy*>(m_placementStrategy.get());

Better as:

std::weak_ptr<MirPlacementStrategy> m_placementStrategy;
....

return m_placementStrategy.lock().get());

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:261
http://jenkins.qa.ubuntu.com/job/qtmir-ci/195/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/46/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/46/console

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

review: Needs Fixing (continuous-integration)

[Albert Astals Cid (aacid)]

Code looks good, haven't time to test. If nobody beats me to it, i'll do on Monday

review: Approve (code)

[Albert Astals Cid (aacid)]

Doesn't merge correctly

Text conflict in debian/changelog
Text conflict in src/modules/Unity/Application/application_manager.cpp
Text conflict in src/modules/Unity/Application/application_manager.h
3 conflicts encountered.

review: Needs Fixing

[lp:~gerboland/qtmir/initialSurfaceGeometry]

262. By Gerry Boland on 2015-01-19

Merge trunk & fix conflicts

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:262
http://jenkins.qa.ubuntu.com/job/qtmir-ci/198/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/49/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/49/console

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

review: Needs Fixing (continuous-integration)

[Albert Astals Cid (aacid)]

Let's wait for https://code.launchpad.net/~gerboland/unity8/initialSurfaceGeometry/+merge/231726 to be finished so we can try it all together

[lp:~gerboland/qtmir/initialSurfaceGeometry]

263. By Gerry Boland on 2015-01-22

Move Surface Types & States into Globals enum class. Expand surfaceSizer parameter to include state

264. By Gerry Boland on 2015-02-09

Merge trunk

265. By Gerry Boland on 2015-03-30

Merge trunk, required many changes

266. By Gerry Boland on 2015-03-30

Remove accidental commits

267. By Gerry Boland on 2015-03-30

Remove local build tweak

268. By Gerry Boland on 2015-07-13

Merge trunk

269. By Gerry Boland on 2015-07-13

Merge detach-state-from-focus and resolve conflicts

Unmerged revisions

269. By Gerry Boland on 2015-07-13

Merge detach-state-from-focus and resolve conflicts

268. By Gerry Boland on 2015-07-13

Merge trunk

267. By Gerry Boland on 2015-03-30

Remove local build tweak

266. By Gerry Boland on 2015-03-30

Remove accidental commits

265. By Gerry Boland on 2015-03-30

Merge trunk, required many changes

264. By Gerry Boland on 2015-02-09

Merge trunk

263. By Gerry Boland on 2015-01-22

Move Surface Types & States into Globals enum class. Expand surfaceSizer parameter to include state

262. By Gerry Boland on 2015-01-19

Merge trunk & fix conflicts

261. By Gerry Boland on 2015-01-13

Merge trunk

260. By Gerry Boland on 2015-01-05

Workaround MirServer API missing the_placement_strategy method (bug lp:1407687)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-05-21 18:48:59 +0000
+++ CMakeLists.txt	2015-07-13 21:57:32 +0000
@@ -80,7 +80,9 @@
 pkg_check_modules(GSETTINGS_QT REQUIRED gsettings-qt)
 pkg_check_modules(QTDBUSTEST libqtdbustest-1 REQUIRED)
 pkg_check_modules(QTDBUSMOCK libqtdbusmock-1 REQUIRED)
-pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=6)
+pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=7)
+
+include_directories(${APPLICATION_API_INCLUDE_DIRS})
 
 add_definitions(-DMIR_REQUIRE_DEPRECATED_EVENT_OPT_IN=1)
 

=== modified file 'debian/changelog'
--- debian/changelog	2015-06-17 13:46:09 +0000
+++ debian/changelog	2015-07-13 21:57:32 +0000
@@ -1,3 +1,10 @@
+qtmir (0.4.6) UNRELEASED; urgency=medium
+
+  * Implement a callback mechanism to allow shell override the initial 
+    surface geometry requested by clients
+
+ -- Gerry Boland <[e-mail]>  Mon, 12 Jul 2015 14:47:07 +0100
+
 qtmir (0.4.5+15.10.20150617-0ubuntu1) wily; urgency=medium
 
   [ Gerry Boland ]

=== modified file 'debian/control'
--- debian/control	2015-06-17 13:45:56 +0000
+++ debian/control	2015-07-13 21:57:32 +0000
@@ -28,7 +28,7 @@
                libubuntu-app-launch2-dev,
                libubuntu-application-api-dev (>= 2.1.0),
                libudev-dev,
-               libunity-api-dev (>= 7.97),
+               libunity-api-dev (>= 7.99),
                liburl-dispatcher1-dev,
                libxkbcommon-dev,
                libxrender-dev,

=== added file 'src/common/globals.h'
--- src/common/globals.h	1970-01-01 00:00:00 +0000
+++ src/common/globals.h	2015-07-13 21:57:32 +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/>.
+ */
+
+#ifndef GLOBALS_H
+#define GLOBALS_H
+
+#include <QObject>
+#include <QSize>
+#include <mir_toolkit/common.h>
+
+namespace qtmir {
+
+class Globals
+{
+    Q_GADGET
+    Q_ENUMS(SurfaceState)
+    Q_ENUMS(SurfaceType)
+
+public:
+    enum SurfaceState {
+        Unknown = mir_surface_state_unknown,
+        Restored = mir_surface_state_restored,
+        Minimized = mir_surface_state_minimized,
+        Maximized = mir_surface_state_maximized,
+        VertMaximized = mir_surface_state_vertmaximized,
+        /* SemiMaximized = mir_surface_state_semimaximized, // see mircommon/mir_toolbox/common.h*/
+        Fullscreen = mir_surface_state_fullscreen,
+    };
+
+    enum SurfaceType {
+        Normal = mir_surface_type_normal,
+        Utility = mir_surface_type_utility,
+        Dialog = mir_surface_type_dialog,
+        Overlay = mir_surface_type_overlay,
+        Freestyle = mir_surface_type_freestyle,
+        Popover = mir_surface_type_popover,
+        InputMethod = mir_surface_type_inputmethod,
+    };
+
+    enum OrientationAngle {
+        Angle0 = 0,
+        Angle90 = 90,
+        Angle180 = 180,
+        Angle270 = 270
+    };
+
+private:
+    Globals() = default;
+    ~Globals() = default;
+};
+
+
+struct SurfaceParameters
+{
+    QSize geometry;
+    Globals::SurfaceState state;
+};
+
+} // namespace qtmir
+
+Q_DECLARE_METATYPE(qtmir::Globals::OrientationAngle)
+
+#endif // GLOBALS_H

=== modified file 'src/modules/Unity/Application/CMakeLists.txt'
--- src/modules/Unity/Application/CMakeLists.txt	2015-05-21 18:48:59 +0000
+++ src/modules/Unity/Application/CMakeLists.txt	2015-07-13 21:57:32 +0000
@@ -46,9 +46,11 @@
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationManagerInterface.h
 # Feed the automoc monster
+    mirsurfaceiteminterface.h
     session_interface.h
     applicationcontroller.h
     settings_interface.h
+    ../../../common/globals.h
     )
 
 add_library(unityapplicationplugin SHARED

=== modified file 'src/modules/Unity/Application/application.cpp'
--- src/modules/Unity/Application/application.cpp	2015-04-10 14:54:44 +0000
+++ src/modules/Unity/Application/application.cpp	2015-07-13 21:57:32 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 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
@@ -37,25 +37,28 @@
 namespace qtmir
 {
 
-Application::Application(const QSharedPointer<TaskController>& taskController,
-                         const QSharedPointer<SharedWakelock>& sharedWakelock,
+QStringList Application::lifecycleExceptions;
+
+Application::Application(const QSharedPointer<SharedWakelock>& sharedWakelock,
                          DesktopFileReader *desktopFileReader,
-                         State state,
                          const QStringList &arguments,
                          ApplicationManager *parent)
     : ApplicationInfoInterface(desktopFileReader->appId(), parent)
-    , m_taskController(taskController)
     , m_sharedWakelock(sharedWakelock)
     , m_desktopData(desktopFileReader)
     , m_pid(0)
     , m_stage((m_desktopData->stageHint() == "SideStage") ? Application::SideStage : Application::MainStage)
-    , m_state(state)
+    , m_state(InternalState::Starting)
     , m_focused(false)
-    , m_canBeResumed(true)
     , m_arguments(arguments)
     , m_session(nullptr)
+    , m_requestedState(RequestedRunning)
+    , m_processState(ProcessUnknown)
 {
-    qCDebug(QTMIR_APPLICATIONS) << "Application::Application - appId=" << desktopFileReader->appId() << "state=" << state;
+    qCDebug(QTMIR_APPLICATIONS) << "Application::Application - appId=" << desktopFileReader->appId();
+
+    // Because m_state is InternalState::Starting
+    acquireWakelock();
 
     // FIXME(greyback) need to save long appId internally until ubuntu-app-launch can hide it from us
     m_longAppId = desktopFileReader->file().remove(QRegExp(".desktop$")).split('/').last();
@@ -69,10 +72,33 @@
 {
     qCDebug(QTMIR_APPLICATIONS) << "Application::~Application";
 
+    // (ricmm) -- To be on the safe side, better wipe the application QML compile cache if it crashes on startup
+    if (m_processState == Application::ProcessUnknown
+            || state() == Application::Starting
+            || state() == Application::Running) {
+        wipeQMLCache();
+    }
+
     delete m_session;
     delete m_desktopData;
 }
 
+
+void Application::wipeQMLCache()
+{
+    QString path(QDir::homePath() + QStringLiteral("/.cache/QML/Apps/"));
+    QDir dir(path);
+    QStringList apps = dir.entryList();
+    for (int i = 0; i < apps.size(); i++) {
+        if (apps.at(i).contains(appId())) {
+            qCDebug(QTMIR_APPLICATIONS) << "Application appId=" << apps.at(i) << " Wiping QML Cache";
+            dir.cd(apps.at(i));
+            dir.removeRecursively();
+            break;
+        }
+    }
+}
+
 bool Application::isValid() const
 {
     return m_desktopData->loaded();
@@ -159,6 +185,30 @@
     return color;
 }
 
+const char* Application::internalStateToStr(InternalState state)
+{
+    switch (state) {
+    case InternalState::Starting:
+        return "Starting";
+    case InternalState::Running:
+        return "Running";
+    case InternalState::RunningInBackground:
+        return "RunningInBackground";
+    case InternalState::SuspendingWaitSession:
+        return "SuspendingWaitSession";
+    case InternalState::SuspendingWaitProcess:
+        return "SuspendingWaitProcess";
+    case InternalState::Suspended:
+        return "Suspended";
+    case InternalState::StoppedUnexpectedly:
+        return "StoppedUnexpectedly";
+    case InternalState::Stopped:
+        return "Stopped";
+    default:
+        return "???";
+    }
+}
+
 bool Application::splashShowHeader() const
 {
     QString showHeader = m_desktopData->splashShowHeader();
@@ -204,7 +254,104 @@
 
 Application::State Application::state() const
 {
-    return m_state;
+    // The public state is a simplified version of the internal one as our consumers
+    // don't have to know or care about all the nasty details.
+    switch (m_state) {
+    case InternalState::Starting:
+        return Starting;
+    case InternalState::Running:
+    case InternalState::RunningInBackground:
+    case InternalState::SuspendingWaitSession:
+    case InternalState::SuspendingWaitProcess:
+        return Running;
+    case InternalState::Suspended:
+        return Suspended;
+    case InternalState::Stopped:
+    default:
+        return Stopped;
+    }
+}
+
+Application::RequestedState Application::requestedState() const
+{
+    return m_requestedState;
+}
+
+void Application::setRequestedState(RequestedState value)
+{
+    if (m_requestedState == value) {
+        // nothing to do
+        return;
+    }
+
+    qCDebug(QTMIR_APPLICATIONS) << "Application::setRequestedState - appId=" << appId()
+                                << "requestedState=" << applicationStateToStr(value);
+    m_requestedState = value;
+    Q_EMIT requestedStateChanged(m_requestedState);
+
+    applyRequestedState();
+}
+
+void Application::applyRequestedState()
+{
+    if (m_requestedState == RequestedRunning) {
+        applyRequestedRunning();
+    } else {
+        applyRequestedSuspended();
+    }
+}
+
+void Application::applyRequestedRunning()
+{
+    switch (m_state) {
+    case InternalState::Starting:
+        // should leave the app alone until it reaches Running state
+        break;
+    case InternalState::Running:
+        // already where it's wanted to be
+        break;
+    case InternalState::RunningInBackground:
+    case InternalState::SuspendingWaitSession:
+    case InternalState::Suspended:
+        resume();
+        break;
+    case InternalState::SuspendingWaitProcess:
+        // should leave the app alone until it reaches Suspended state
+        break;
+    case InternalState::StoppedUnexpectedly:
+        respawn();
+        break;
+    case InternalState::Stopped:
+        // dead end.
+        break;
+    }
+}
+
+void Application::applyRequestedSuspended()
+{
+    switch (m_state) {
+    case InternalState::Starting:
+        // should leave the app alone until it reaches Running state
+        break;
+    case InternalState::Running:
+        if (m_processState == ProcessRunning) {
+            suspend();
+        } else {
+            // we can't suspend it since we have no information on the app process
+            Q_ASSERT(m_processState == ProcessUnknown);
+        }
+        break;
+    case InternalState::RunningInBackground:
+    case InternalState::SuspendingWaitSession:
+    case InternalState::SuspendingWaitProcess:
+    case InternalState::Suspended:
+        // it's already going where we it's wanted
+        break;
+    case InternalState::StoppedUnexpectedly:
+    case InternalState::Stopped:
+        // the app doesn't have a process in the first place, so there's nothing to suspend
+        break;
+    }
 }
 
 bool Application::focused() const
@@ -219,12 +366,7 @@
 
 bool Application::canBeResumed() const
 {
-    return m_canBeResumed;
-}
-
-void Application::setCanBeResumed(const bool resume)
-{
-    m_canBeResumed = resume;
+    return m_processState != ProcessUnknown;
 }
 
 pid_t Application::pid() const
@@ -242,7 +384,7 @@
     m_arguments = arguments;
 }
 
-void Application::setSession(Session *newSession)
+void Application::setSession(SessionInterface *newSession)
 {
     qCDebug(QTMIR_APPLICATIONS) << "Application::setSession - appId=" << appId() << "session=" << newSession;
 
@@ -261,10 +403,25 @@
     if (m_session) {
         m_session->setParent(this);
         m_session->setApplication(this);
-        m_session->setState(state());
-
-        connect(m_session, &SessionInterface::suspended, this, &Application::onSessionSuspended);
-        connect(m_session, &SessionInterface::resumed, this, &Application::onSessionResumed);
+
+        switch (m_state) {
+        case InternalState::Starting:
+        case InternalState::Running:
+        case InternalState::RunningInBackground:
+            m_session->resume();
+            break;
+        case InternalState::SuspendingWaitSession:
+        case InternalState::SuspendingWaitProcess:
+        case InternalState::Suspended:
+            m_session->suspend();
+            break;
+        case InternalState::Stopped:
+        default:
+            m_session->stop();
+            break;
+        }
+
+        connect(m_session, &SessionInterface::stateChanged, this, &Application::onSessionStateChanged);
         connect(m_session, &SessionInterface::fullscreenChanged, this, &Application::fullscreenChanged);
 
         if (oldFullscreen != fullscreen())
@@ -288,37 +445,53 @@
     }
 }
 
-void Application::setState(Application::State state)
+void Application::setInternalState(Application::InternalState state)
 {
-    qCDebug(QTMIR_APPLICATIONS) << "Application::setState - appId=" << appId() << "state=" << applicationStateToStr(state);
-    if (m_state != state) {
-        if (session()) {
-            session()->setState((Session::State)state);
-        } else {
-            // If we have have no session, we may have to respawn it.
-            switch (state)
-            {
-            case Session::State::Running:
-                if (m_state == Session::State::Stopped) {
-                    respawn();
-                    state = Session::State::Starting;
-                }
-                break;
-            default:
-                break;
-            }
-        }
-        m_state = state;
-        Q_EMIT stateChanged(state);
-    }
+    if (m_state == state) {
+        return;
+    }
+
+    qCDebug(QTMIR_APPLICATIONS) << "Application::setInternalState - appId=" << appId()
+        << "state=" << internalStateToStr(state);
+
+    auto oldPublicState = this->state();
+    m_state = state;
+
+    switch (m_state) {
+        case InternalState::Starting:
+        case InternalState::Running:
+            acquireWakelock();
+            break;
+        case InternalState::RunningInBackground:
+            releaseWakelock();
+            break;
+        case InternalState::Suspended:
+            releaseWakelock();
+            break;
+        case InternalState::StoppedUnexpectedly:
+            releaseWakelock();
+            break;
+        case InternalState::Stopped:
+            Q_EMIT stopped();
+            releaseWakelock();
+            break;
+        case InternalState::SuspendingWaitSession:
+        case InternalState::SuspendingWaitProcess:
+            // transitory states. leave as it is
+        default:
+            break;
+    };
+
+    if (this->state() != oldPublicState) {
+        Q_EMIT stateChanged(this->state());
+    }
+
+    applyRequestedState();
 }
 
 void Application::setFocused(bool focused)
 {
     qCDebug(QTMIR_APPLICATIONS) << "Application::setFocused - appId=" << appId() << "focused=" << focused;
-    if (focused) {
-        holdWakelock(true);
-    }
 
     if (m_focused != focused) {
         m_focused = focused;
@@ -326,25 +499,84 @@
     }
 }
 
-void Application::onSessionSuspended()
-{
-    qCDebug(QTMIR_APPLICATIONS) << "Application::onSessionSuspended - appId=" << appId();
-    m_taskController->suspend(longAppId());
-    holdWakelock(false);
-}
-
-void Application::onSessionResumed()
-{
-    qCDebug(QTMIR_APPLICATIONS) << "Application::onSessionResumed - appId=" << appId();
-    holdWakelock(true);
-    m_taskController->resume(longAppId());
+void Application::setProcessState(ProcessState newProcessState)
+{
+    if (m_processState == newProcessState) {
+        return;
+    }
+
+    m_processState = newProcessState;
+
+    switch (m_processState) {
+    case ProcessUnknown:
+        // it would be a coding error
+        Q_ASSERT(false);
+        break;
+    case ProcessRunning:
+        if (m_state == InternalState::StoppedUnexpectedly) {
+            setInternalState(InternalState::Starting);
+        }
+        break;
+    case ProcessSuspended:
+        Q_ASSERT(m_state == InternalState::SuspendingWaitProcess);
+        setInternalState(InternalState::Suspended);
+        break;
+    case ProcessStopped:
+        // we assume the session always stop before the process
+        Q_ASSERT(!m_session || m_session->state() == Session::Stopped);
+        if (m_state == InternalState::Starting) {
+            setInternalState(InternalState::Stopped);
+        } else {
+            Q_ASSERT(m_state == InternalState::Stopped
+                    || m_state == InternalState::StoppedUnexpectedly);
+        }
+        break;
+    }
+
+    applyRequestedState();
+}
+
+void Application::suspend()
+{
+    Q_ASSERT(m_state == InternalState::Running);
+    Q_ASSERT(m_session != nullptr);
+
+    if (!lifecycleExceptions.filter(appId().section('_',0,0)).empty()) {
+        // Present in exceptions list.
+        // There's no need to keep the wakelock as the process is never suspended
+        // and thus has no cleanup to perform when (for example) the display is
+        // blanked.
+        setInternalState(InternalState::RunningInBackground);
+    } else {
+        setInternalState(InternalState::SuspendingWaitSession);
+        m_session->suspend();
+    }
+}
+
+void Application::resume()
+{
+    if (m_state == InternalState::Suspended) {
+        setInternalState(InternalState::Running);
+        Q_EMIT resumeProcessRequested();
+        if (m_processState == ProcessSuspended) {
+            setProcessState(ProcessRunning); // should we wait for a resumed() signal?
+        }
+        m_session->resume();
+    } else if (m_state == InternalState::SuspendingWaitSession) {
+        setInternalState(InternalState::Running);
+        m_session->resume();
+    } else if (m_state == InternalState::RunningInBackground) {
+        setInternalState(InternalState::Running);
+    }
 }
 
 void Application::respawn()
 {
     qCDebug(QTMIR_APPLICATIONS) << "Application::respawn - appId=" << appId();
-    holdWakelock(true);
-    m_taskController->start(appId(), m_arguments);
+
+    setInternalState(InternalState::Starting);
+
+    Q_EMIT startProcessRequested();
 }
 
 QString Application::longAppId() const
@@ -362,20 +594,60 @@
     return m_rotatesWindowContents;
 }
 
-Session* Application::session() const
+SessionInterface* Application::session() const
 {
     return m_session;
 }
 
-void Application::holdWakelock(bool enable) const
-{
-    if (appId() == "unity8-dash")
-        return;
-
-    if (enable) {
-        m_sharedWakelock->acquire(this);
-    } else {
-        m_sharedWakelock->release(this);
+void Application::acquireWakelock() const
+{
+    if (appId() == "unity8-dash")
+        return;
+
+    m_sharedWakelock->acquire(this);
+}
+
+void Application::releaseWakelock() const
+{
+    if (appId() == "unity8-dash")
+        return;
+
+    m_sharedWakelock->release(this);
+}
+
+void Application::onSessionStateChanged(Session::State sessionState)
+{
+    switch (sessionState) {
+    case Session::Starting:
+        break;
+    case Session::Running:
+        if (m_state == InternalState::Starting) {
+            setInternalState(InternalState::Running);
+        }
+        break;
+    case Session::Suspending:
+        break;
+    case Session::Suspended:
+        Q_ASSERT(m_state == InternalState::SuspendingWaitSession);
+        setInternalState(InternalState::SuspendingWaitProcess);
+        Q_EMIT suspendProcessRequested();
+        break;
+    case Session::Stopped:
+        if (!canBeResumed()
+                || m_state == InternalState::Starting
+                || m_state == InternalState::Running) {
+            /*  1. application is not managed by upstart
+             *  2. application is managed by upstart, but has stopped before it managed
+             *     to create a surface, we can assume it crashed on startup, and thus
+             *     cannot be resumed
+             *  3. application is managed by upstart and is in foreground (i.e. has
+             *     Running state), if Mir reports the application disconnects, it
+             *     either crashed or stopped itself.
+             */
+            setInternalState(InternalState::Stopped);
+        } else {
+            setInternalState(InternalState::StoppedUnexpectedly);
+        }
     }
 }
 

=== modified file 'src/modules/Unity/Application/application.h'
--- src/modules/Unity/Application/application.h	2015-01-19 11:48:32 +0000
+++ src/modules/Unity/Application/application.h	2015-07-13 21:57:32 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 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
@@ -28,6 +28,8 @@
 // Unity API
 #include <unity/shell/application/ApplicationInfoInterface.h>
 
+#include "session_interface.h"
+
 namespace mir {
     namespace scene {
         class Session;
@@ -39,7 +41,6 @@
 
 class ApplicationManager;
 class DesktopFileReader;
-class TaskController;
 class Session;
 class SharedWakelock;
 
@@ -51,15 +52,32 @@
     Q_PROPERTY(QString exec READ exec CONSTANT)
     Q_PROPERTY(bool fullscreen READ fullscreen NOTIFY fullscreenChanged)
     Q_PROPERTY(Stage stage READ stage WRITE setStage NOTIFY stageChanged)
-    Q_PROPERTY(Session* session READ session NOTIFY sessionChanged DESIGNABLE false)
+    Q_PROPERTY(SessionInterface* session READ session NOTIFY sessionChanged DESIGNABLE false)
 
 public:
     Q_DECLARE_FLAGS(Stages, Stage)
 
-    Application(const QSharedPointer<TaskController>& taskController,
-                const QSharedPointer<SharedWakelock>& sharedWakelock,
+    enum ProcessState {
+        ProcessUnknown,
+        ProcessRunning,
+        ProcessSuspended,
+        ProcessStopped
+    };
+
+    enum class InternalState {
+        Starting,
+        Running,
+        RunningInBackground,
+        SuspendingWaitSession,
+        SuspendingWaitProcess,
+        Suspended,
+        StoppedUnexpectedly,
+        Stopped // It closed itself, crashed or it stopped and we can't respawn it
+                // In any case, this is a dead end.
+    };
+
+    Application(const QSharedPointer<SharedWakelock>& sharedWakelock,
                 DesktopFileReader *desktopFileReader,
-                State state,
                 const QStringList &arguments,
                 ApplicationManager *parent);
     virtual ~Application();
@@ -71,6 +89,8 @@
     QUrl icon() const override;
     Stage stage() const override;
     State state() const override;
+    RequestedState requestedState() const override;
+    void setRequestedState(RequestedState) override;
     bool focused() const override;
     QString splashTitle() const override;
     QUrl splashImage() const override;
@@ -82,12 +102,16 @@
     bool rotatesWindowContents() const override;
 
     void setStage(Stage stage);
-    void setState(State state);
-
-    Session* session() const;
+
+
+    void setProcessState(ProcessState value);
+
+    QStringList arguments() const { return m_arguments; }
+
+    SessionInterface* session() const;
+    void setSession(SessionInterface *session);
 
     bool canBeResumed() const;
-    void setCanBeResumed(const bool);
 
     bool isValid() const;
     QString desktopFile() const;
@@ -98,40 +122,58 @@
 
     pid_t pid() const;
 
+    // for tests
+    InternalState internalState() const { return m_state; }
+
+    static QStringList lifecycleExceptions;
+
 Q_SIGNALS:
     void fullscreenChanged(bool fullscreen);
     void stageChanged(Stage stage);
-    void sessionChanged(Session *session);
+    void sessionChanged(SessionInterface *session);
+
+    void startProcessRequested();
+    void suspendProcessRequested();
+    void resumeProcessRequested();
+    void stopped();
 
 private Q_SLOTS:
-    void onSessionSuspended();
-    void onSessionResumed();
+    void onSessionStateChanged(SessionInterface::State sessionState);
 
     void respawn();
 
 private:
+
     QString longAppId() const;
-    void holdWakelock(bool enable) const;
+    void acquireWakelock() const;
+    void releaseWakelock() const;
     void setPid(pid_t pid);
     void setArguments(const QStringList arguments);
     void setFocused(bool focus);
-    void setSession(Session *session);
+    void setInternalState(InternalState state);
+    void wipeQMLCache();
+    void suspend();
+    void resume();
     QColor colorFromString(const QString &colorString, const char *colorName) const;
+    static const char* internalStateToStr(InternalState state);
+    void applyRequestedState();
+    void applyRequestedRunning();
+    void applyRequestedSuspended();
 
-    QSharedPointer<TaskController> m_taskController;
     QSharedPointer<SharedWakelock> m_sharedWakelock;
     DesktopFileReader* m_desktopData;
     QString m_longAppId;
     qint64 m_pid;
     Stage m_stage;
     Stages m_supportedStages;
-    State m_state;
+    InternalState m_state;
     bool m_focused;
-    bool m_canBeResumed;
     QStringList m_arguments;
     Qt::ScreenOrientations m_supportedOrientations;
     bool m_rotatesWindowContents;
-    Session *m_session;
+    SessionInterface *m_session;
+    RequestedState m_requestedState;
+    ProcessState m_processState;
 
     friend class ApplicationManager;
     friend class SessionManager;

=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2015-05-21 18:38:27 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2015-07-13 21:57:32 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013,2014 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
@@ -29,6 +29,7 @@
 
 // mirserver
 #include "mirserver.h"
+#include "mirshell.h"
 #include "nativeinterface.h"
 #include "sessionlistener.h"
 #include "sessionauthorizer.h"
@@ -47,6 +48,8 @@
 #include <QDebug>
 #include <QByteArray>
 #include <QDir>
+#include <QJSEngine>
+#include <QJSValue>
 
 // std
 #include <csignal>
@@ -90,23 +93,31 @@
                      manager, &ApplicationManager::authorizeSession, Qt::BlockingQueuedConnection);
 }
 
+void connectToMirShell(ApplicationManager *manager, MirShell *shell)
+{
+    QObject::connect(shell, &MirShell::sessionAboutToCreateSurface,
+                     manager, &ApplicationManager::onSessionAboutToCreateSurface, Qt::BlockingQueuedConnection);
+}
+
 void connectToTaskController(ApplicationManager *manager, TaskController *controller)
 {
     QObject::connect(controller, &TaskController::processStarting,
                      manager, &ApplicationManager::onProcessStarting);
     QObject::connect(controller, &TaskController::processStopped,
                      manager, &ApplicationManager::onProcessStopped);
+    QObject::connect(controller, &TaskController::processSuspended,
+                     manager, &ApplicationManager::onProcessSuspended);
     QObject::connect(controller, &TaskController::processFailed,
                      manager, &ApplicationManager::onProcessFailed);
-    QObject::connect(controller, &TaskController::requestFocus,
+    QObject::connect(controller, &TaskController::focusRequested,
                      manager, &ApplicationManager::onFocusRequested);
-    QObject::connect(controller, &TaskController::requestResume,
+    QObject::connect(controller, &TaskController::resumeRequested,
                      manager, &ApplicationManager::onResumeRequested);
 }
 
 } // namespace
 
-ApplicationManager* ApplicationManager::Factory::Factory::create()
+ApplicationManager* ApplicationManager::Factory::Factory::create(QJSEngine *jsEngine)
 {
     NativeInterface *nativeInterface = dynamic_cast<NativeInterface*>(QGuiApplication::platformNativeInterface());
 
@@ -139,11 +150,13 @@
                                              sharedWakelock,
                                              fileReaderFactory,
                                              procInfo,
-                                             settings
+                                             settings,
+                                             jsEngine
                                          );
 
     connectToSessionListener(appManager, sessionListener);
     connectToSessionAuthorizer(appManager, sessionAuthorizer);
+    connectToMirShell(appManager, mirServer.lock()->shell());
     connectToTaskController(appManager, taskController.data());
 
     // Emit signal to notify Upstart that Mir is ready to receive client connections
@@ -159,12 +172,12 @@
 }
 
 
-ApplicationManager* ApplicationManager::singleton()
+ApplicationManager* ApplicationManager::singleton(QJSEngine *jsEngine)
 {
     static ApplicationManager* instance;
     if (!instance) {
         Factory appFactory;
-        instance = appFactory.create();
+        instance = appFactory.create(jsEngine);
     }
     return instance;
 }
@@ -176,20 +189,19 @@
         const QSharedPointer<DesktopFileReader::Factory>& desktopFileReaderFactory,
         const QSharedPointer<ProcInfo>& procInfo,
         const QSharedPointer<SettingsInterface>& settings,
+        QJSEngine *jsEngine,
         QObject *parent)
     : ApplicationManagerInterface(parent)
     , m_mirServer(mirServer)
     , m_focusedApplication(nullptr)
-    , m_mainStageApplication(nullptr)
-    , m_sideStageApplication(nullptr)
     , m_dbusWindowStack(new DBusWindowStack(this))
     , m_taskController(taskController)
     , m_desktopFileReaderFactory(desktopFileReaderFactory)
     , m_procInfo(procInfo)
     , m_sharedWakelock(sharedWakelock)
     , m_settings(settings)
-    , m_suspended(false)
-    , m_forceDashActive(false)
+    , m_surfaceAboutToBeCreatedCallback(QJSValue::UndefinedValue)
+    , m_jsEngine(jsEngine)
 {
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::ApplicationManager (this=%p)" << this;
     setObjectName("qtmir::ApplicationManager");
@@ -198,7 +210,7 @@
     m_roleNames.insert(RoleFullscreen, "fullscreen");
 
     if (settings.data()) {
-        m_lifecycleExceptions = m_settings->get("lifecycleExemptAppids").toStringList();
+        Application::lifecycleExceptions = m_settings->get("lifecycleExemptAppids").toStringList();
         connect(m_settings.data(), &Settings::changed, this, &ApplicationManager::onSettingsChanged);
     }
 }
@@ -206,6 +218,7 @@
 ApplicationManager::~ApplicationManager()
 {
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::~ApplicationManager";
+    m_surfaceAboutToBeCreatedCallback = QJSValue::UndefinedValue; //unset immediately to avoid racing on shutdown
 }
 
 int ApplicationManager::rowCount(const QModelIndex &parent) const
@@ -289,96 +302,23 @@
     }
 }
 
-bool ApplicationManager::suspended() const
+QJSValue ApplicationManager::surfaceAboutToBeCreatedCallback() const
 {
-    return m_suspended;
+    return m_surfaceAboutToBeCreatedCallback;
 }
 
-void ApplicationManager::setSuspended(bool suspended)
+void ApplicationManager::setSurfaceAboutToBeCreatedCallback(const QJSValue &callback)
 {
-    if (suspended == m_suspended) {
+    if (m_surfaceAboutToBeCreatedCallback.equals(callback))
         return;
-    }
-    m_suspended = suspended;
-    Q_EMIT suspendedChanged();
 
-    if (m_suspended) {
-        suspendApplication(m_mainStageApplication);
-        suspendApplication(m_sideStageApplication);
-        if (m_focusedApplication) {
-            m_focusedApplication->setFocused(false);
-            m_dbusWindowStack->FocusedWindowChanged(0, QString(), 0);
-        }
+    if (callback.isCallable()) {
+        m_surfaceAboutToBeCreatedCallback = callback;
     } else {
-        resumeApplication(m_mainStageApplication);
-        resumeApplication(m_sideStageApplication);
-        if (m_focusedApplication) {
-            m_focusedApplication->setFocused(true);
-            m_dbusWindowStack->FocusedWindowChanged(0, m_focusedApplication->appId(), m_focusedApplication->stage());
-        }
-    }
-}
-
-bool ApplicationManager::forceDashActive() const
-{
-    return m_forceDashActive;
-}
-
-void ApplicationManager::setForceDashActive(bool forceDashActive)
-{
-    if (m_forceDashActive == forceDashActive) {
-        return;
-    }
-
-    m_forceDashActive = forceDashActive;
-    Q_EMIT forceDashActiveChanged();
-
-    Application *dashApp = findApplication("unity8-dash");
-    if (!dashApp) {
-        qCWarning(QTMIR_APPLICATIONS) << "Dash doesn't seem to be running... Ignoring.";
-        return;
-    }
-
-    if (m_forceDashActive && dashApp->state() != Application::Running) {
-         resumeApplication(dashApp);
-    } else if (!m_forceDashActive && dashApp->state() == Application::Running
-            && m_mainStageApplication != dashApp
-            && m_sideStageApplication != dashApp) {
-        suspendApplication(dashApp);
-    }
-}
-
-bool ApplicationManager::suspendApplication(Application *application)
-{
-    if (application == nullptr)
-        return false;
-    qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::suspendApplication - appId=" << application->appId();
-
-    // Present in exceptions list, explicitly release wakelock and return. There's no need to keep the wakelock
-    // as the process is never suspended and thus has no cleanup to perform when (for example) the display is blanked
-    if (!m_lifecycleExceptions.filter(application->appId().section('_',0,0)).empty()) {
-        m_sharedWakelock->release(application);
-        return false;
-    }
-
-    if (m_forceDashActive && application->appId() == "unity8-dash") {
-        return false;
-    }
-
-    if (application->state() == Application::Running)
-        application->setState(Application::Suspended);
-
-    return true;
-}
-
-void ApplicationManager::resumeApplication(Application *application)
-{
-    if (application == nullptr)
-        return;
-    qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::resumeApplication - appId=" << application->appId();
-
-    if (application->state() == Application::Suspended || application->state() == Application::Stopped)
-        application->setState(Application::Running);
+        qWarning() << "ApplicationManager::setSurfaceAboutToBeCreatedCallback - attempted to register a non-function!";
+        m_surfaceAboutToBeCreatedCallback = QJSValue::UndefinedValue;
+    }
+    Q_EMIT surfaceAboutToBeCreatedCallbackChanged();
 }
 
 bool ApplicationManager::focusApplication(const QString &inputAppId)
@@ -392,27 +332,8 @@
         return false;
     }
 
-    resumeApplication(application);
-
-    // set state of previously focused app to suspended
     if (m_focusedApplication) {
         m_focusedApplication->setFocused(false);
-        Application *lastApplication = applicationForStage(application->stage());
-        if (lastApplication != application) {
-            suspendApplication(lastApplication);
-        }
-    }
-
-    if (application->stage() == Application::MainStage) {
-        m_mainStageApplication = application;
-    } else {
-        m_sideStageApplication = application;
-    }
-
-    if (!m_suspended) {
-        resumeApplication(application); // in case unfocusCurrentApplication() was last called
-    } else {
-        suspendApplication(application); // Make sure we also have this one suspended if everything is suspended
     }
 
     m_focusedApplication = application;
@@ -422,9 +343,6 @@
     Q_EMIT focusedApplicationIdChanged();
     m_dbusWindowStack->FocusedWindowChanged(0, application->appId(), application->stage());
 
-    // FIXME(dandrader): lying here. The operation is async. So we will only know whether
-    // the focusing was successful once the server replies. Maybe the API in unity-api should
-    // reflect that?
     return true;
 }
 
@@ -432,9 +350,6 @@
 {
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::unfocusCurrentApplication";
 
-    suspendApplication(m_sideStageApplication);
-    suspendApplication(m_mainStageApplication);
-
     m_focusedApplication = nullptr;
     Q_EMIT focusedApplicationIdChanged();
 }
@@ -484,10 +399,8 @@
         application->setArguments(arguments);
     } else {
         application = new Application(
-                    m_taskController,
                     m_sharedWakelock,
                     m_desktopFileReaderFactory->createInstance(appId, m_taskController->findDesktopFileForAppId(appId)),
-                    Application::Starting,
                     arguments,
                     this);
 
@@ -514,10 +427,8 @@
     Application *application = findApplication(appId);
     if (!application) { // then shell did not start this application, so ubuntu-app-launch must have - add to list
         application = new Application(
-                    m_taskController,
                     m_sharedWakelock,
                     m_desktopFileReaderFactory->createInstance(appId, m_taskController->findDesktopFileForAppId(appId)),
-                    Application::Starting,
                     QStringList(),
                     this);
 
@@ -530,17 +441,17 @@
         Q_EMIT focusRequested(appId);
     }
     else {
-        // url-dispatcher can relaunch apps which have been OOM-killed - AppMan must accept the newly spawned
-        // application and focus it immediately (as user expects app to still be running).
         if (application->state() == Application::Stopped) {
+            // url-dispatcher can relaunch apps which have been OOM-killed - AppMan must accept the newly spawned
+            // application and focus it immediately (as user expects app to still be running).
             qCDebug(QTMIR_APPLICATIONS) << "Stopped application appId=" << appId << "is being resumed externally";
-            application->setState(Application::Starting);
             Q_EMIT focusRequested(appId);
         } else {
             qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onProcessStarting application already found with appId"
                                         << appId;
         }
     }
+    application->setProcessState(Application::ProcessRunning);
 }
 
 /**
@@ -559,14 +470,7 @@
         return false;
     }
 
-    if (application == m_focusedApplication) {
-        // unfocus, and let shell decide what next to focus
-        m_focusedApplication = nullptr;
-        Q_EMIT focusedApplicationIdChanged();
-    }
-
     remove(application);
-    m_dbusWindowStack->WindowDestroyed(0, appId);
 
     bool result = m_taskController->stop(application->longAppId());
 
@@ -583,10 +487,7 @@
 
 void ApplicationManager::onProcessFailed(const QString &appId, const bool duringStartup)
 {
-    /* Applications fail if they fail to launch, crash or are killed. If failed to start, must
-     * immediately remove from list of applications. If crash or kill, instead we set flag on the
-     * Application to indicate it can be resumed.
-     */
+    // Applications fail if they fail to launch, crash or are killed.
 
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onProcessFailed - appId=" << appId << "duringStartup=" << duringStartup;
 
@@ -598,20 +499,8 @@
     }
 
     Q_UNUSED(duringStartup); // FIXME(greyback) upstart reports app that fully started up & crashes as failing during startup??
-    if (application->state() == Application::Starting) {
-        if (application == m_focusedApplication) {
-            m_focusedApplication = nullptr;
-            Q_EMIT focusedApplicationIdChanged();
-        }
-        remove(application);
-        m_dbusWindowStack->WindowDestroyed(0, application->appId());
-        delete application;
-    } else {
-        // We need to set flags on the Application to say the app can be resumed, and thus should not be removed
-        // from the list by onProcessStopped.
-        application->setCanBeResumed(true);
-        application->setPid(0);
-    }
+    application->setProcessState(Application::ProcessStopped);
+    application->setPid(0);
 }
 
 void ApplicationManager::onProcessStopped(const QString &appId)
@@ -626,29 +515,15 @@
         return;
     }
 
-    // if shell did not stop the application, but ubuntu-app-launch says it died, we assume the process has been
-    // killed, so it can be respawned later. Only exception is if that application is focused or running
-    // as then it most likely crashed. Update this logic when ubuntu-app-launch gives some failure info.
-    bool removeApplication = true;
-
-    if (application == m_focusedApplication) {
-        // Very bad case where focused application dies. Remove from list. Should give error message
-        m_focusedApplication = nullptr;
-        Q_EMIT focusedApplicationIdChanged();
-    }
-
-    // The following scenario is the only time that we do NOT remove the application from the app list:
-    if ((application->state() == Application::Suspended || application->state() == Application::Stopped)
-            && application->pid() == 0 // i.e. onProcessFailed was called, which resets the PID of this application
-            && application->canBeResumed()) {
-        removeApplication = false;
-    }
-
-    if (removeApplication) {
-        qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onProcessStopped - removing appId=" << appId;
-        remove(application);
-        m_dbusWindowStack->WindowDestroyed(0, application->appId());
-        delete application;
+    application->setProcessState(Application::ProcessStopped);
+    application->setPid(0);
+}
+
+void ApplicationManager::onProcessSuspended(const QString &appId)
+{
+    Application *application = findApplication(appId);
+    if (application) {
+        application->setProcessState(Application::ProcessSuspended);
     }
 }
 
@@ -670,10 +545,10 @@
         return;
     }
 
-    // If app Stopped, trust that ubuntu-app-launch respawns it itself, and AppManager will
-    // be notified of that through the onProcessStartReportReceived slot. Else resume.
+    // We interpret this as a focus request for a suspended app.
+    // Shell will have this app resumed if it complies with the focus request
     if (application->state() == Application::Suspended) {
-        application->setState(Application::Running);
+        Q_EMIT focusRequested(appId);
     }
 }
 
@@ -693,7 +568,7 @@
 void ApplicationManager::onSettingsChanged(const QString &key)
 {
     if (key == "lifecycleExemptAppids") {
-        m_lifecycleExceptions = m_settings->get("lifecycleExemptAppids").toStringList();
+        Application::lifecycleExceptions = m_settings->get("lifecycleExemptAppids").toStringList();
     }
 }
 
@@ -732,7 +607,6 @@
 
     if (info->startsWith("maliit-server") || info->contains("qt5/libexec/QtWebProcess")) {
         authorized = true;
-        m_hiddenPIDs << pid;
         return;
     }
 
@@ -792,15 +666,12 @@
 
     QStringList arguments(info->asStringList());
     application = new Application(
-        m_taskController,
         m_sharedWakelock,
         desktopData,
-        Application::Starting,
         arguments,
         this);
     application->setPid(pid);
     application->setStage(stage);
-    application->setCanBeResumed(false);
     add(application);
     authorized = true;
 }
@@ -812,66 +683,56 @@
 
 void ApplicationManager::onSessionStopping(std::shared_ptr<ms::Session> const& session)
 {
-    qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onSessionStopping - sessionName=" << session->name().c_str();
-
-    // in case application closed not by hand of shell, check again here:
     Application* application = findApplicationWithSession(session);
     if (application) {
-        /* Can remove the application from the running apps list immediately in these curcumstances:
-         *  1. application is not managed by upstart (this message from Mir is only notice the app has stopped, must do
-         *     it here)
-         *  2. application is managed by upstart, but has stopped before it managed to create a surface, we can assume
-         *     it crashed on startup, and thus cannot be resumed - so remove it.
-         *  3. application is managed by upstart and is in foreground (i.e. has Running state), if Mir reports the
-         *     application disconnects, it either crashed or stopped itself. Either case, remove it.
-         */
-        if (!application->canBeResumed()
-                || application->state() == Application::Starting
-                || application->state() == Application::Running) {
-            m_dbusWindowStack->WindowDestroyed(0, application->appId());
-            remove(application);
-           
-            // (ricmm) -- To be on the safe side, better wipe the application QML compile cache if it crashes on startup
-            QString path(QDir::homePath() + QStringLiteral("/.cache/QML/Apps/"));
-            QDir dir(path);
-            QStringList apps = dir.entryList();
-            for (int i = 0; i < apps.size(); i++) {
-                if (apps.at(i).contains(application->appId())) {
-                    qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onSessionStopping appId=" << apps.at(i) << " Wiping QML Cache";
-                    dir.cd(apps.at(i));
-                    dir.removeRecursively();
-                    break;
-                }
-            }
-
-            delete application;
-
-            if (application == m_focusedApplication) {
-                m_focusedApplication = nullptr;
-                Q_EMIT focusedApplicationIdChanged();
-            }
+        m_dbusWindowStack->WindowDestroyed(0, application->appId());
+    }
+}
+
+void ApplicationManager::onSessionAboutToCreateSurface(const std::shared_ptr<mir::scene::Session> &session,
+                                                       qtmir::SurfaceParameters &params)
+{
+    qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onSessionAboutToCreateSurface - sessionName="
+                                << session->name().c_str() << "geometry=" << params.geometry
+                                << "state" << params.state;
+
+    if (m_surfaceAboutToBeCreatedCallback.isCallable()) {
+        QJSValue argument = m_jsEngine->newObject();
+        argument.setProperty("width", params.geometry.width());
+        argument.setProperty("height", params.geometry.height());
+        argument.setProperty("state", params.state);
+
+        Application* application = findApplicationWithSession(session.get());
+        if (application)
+            argument.setProperty("appId", application->appId());
+
+        QJSValue output = m_surfaceAboutToBeCreatedCallback.call(QJSValueList() << argument);
+        if (output.isObject()) {
+            QJSValue width = output.property("width");
+            QJSValue height = output.property("height");
+            QJSValue state = output.property("state");
+            if (width.isNumber())
+                params.geometry.setWidth(width.toInt());
+            if (height.isNumber())
+                params.geometry.setHeight(height.toInt());
+            if (state.isNumber())
+                params.state = static_cast<Globals::SurfaceState>(state.toInt());
         } else {
-            // otherwise, we do not have enough information to make any changes to the model, so await events from
-            // upstart to go further, but set the app state
-            application->setState(Application::Stopped);
+            qWarning() << "ApplicationManager::onSessionAboutToCreateSurface - unrecognised object returned from JS callback!!"
+                       << "Surface size has *not* been overridden by shell!";
         }
     }
-    m_hiddenPIDs.removeOne(session->process_id());
 }
 
-void ApplicationManager::onSessionCreatedSurface(ms::Session const* session,
-                                               std::shared_ptr<ms::Surface> const& surface)
+void ApplicationManager::onSessionCreatedSurface(const ms::Session *session,
+                                                 const std::shared_ptr<ms::Surface> &surface)
 {
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onSessionCreatedSurface - sessionName=" << session->name().c_str();
     Q_UNUSED(surface);
 
     Application* application = findApplicationWithSession(session);
-    if (application && application->state() == Application::Starting) {
+    if (application) {
         m_dbusWindowStack->WindowCreated(0, application->appId());
-        application->setState(Application::Running);
-        if ((application != m_mainStageApplication && application != m_sideStageApplication) || m_suspended) {
-            suspendApplication(application);
-        }
     }
 }
 
@@ -900,16 +761,6 @@
     return nullptr;
 }
 
-Application* ApplicationManager::applicationForStage(Application::Stage stage)
-{
-    qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::focusedApplicationForStage" << stage;
-
-    if (stage == Application::MainStage)
-        return m_mainStageApplication;
-    else
-        return m_sideStageApplication;
-}
-
 void ApplicationManager::add(Application* application)
 {
     Q_ASSERT(application != nullptr);
@@ -920,6 +771,28 @@
     connect(application, &Application::stateChanged, this, [this](Application::State) { onAppDataChanged(RoleState); });
     connect(application, &Application::stageChanged, this, [this](Application::Stage) { onAppDataChanged(RoleStage); });
 
+    QString appId = application->appId();
+    QString longAppId = application->longAppId();
+    QStringList arguments = application->arguments();
+
+    // The connection is queued as a workaround an issue in the PhoneStage animation that
+    // happens when you tap on a killed app in the spread to bring it to foreground, causing
+    // a Application::respawn() to take place.
+    // In any case, it seems like in general QML works better when don't do too many things
+    // in the same event loop iteration.
+    connect(application, &Application::startProcessRequested,
+            this, [=]() { m_taskController->start(appId, arguments); },
+            Qt::QueuedConnection);
+
+    connect(application, &Application::suspendProcessRequested, this, [=]() { m_taskController->suspend(longAppId); } );
+    connect(application, &Application::resumeProcessRequested, this, [=]() { m_taskController->resume(longAppId); } );
+
+    connect(application, &Application::stopped, this, [=]() {
+        remove(application);
+        application->deleteLater();
+    });
+
+
     beginInsertRows(QModelIndex(), m_applications.count(), m_applications.count());
     m_applications.append(application);
     endInsertRows();
@@ -935,11 +808,6 @@
     Q_ASSERT(application != nullptr);
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::remove - appId=" << application->appId();
 
-    if (application == m_sideStageApplication)
-        m_sideStageApplication = nullptr;
-    if (application == m_mainStageApplication)
-        m_mainStageApplication = nullptr;
-
     application->disconnect(this);
 
     int i = m_applications.indexOf(application);
@@ -953,6 +821,11 @@
             Q_EMIT emptyChanged();
         }
     }
+
+    if (application == m_focusedApplication) {
+        m_focusedApplication = nullptr;
+        Q_EMIT focusedApplicationIdChanged();
+    }
 }
 
 void ApplicationManager::move(int from, int to) {

=== modified file 'src/modules/Unity/Application/application_manager.h'
--- src/modules/Unity/Application/application_manager.h	2015-03-24 23:38:33 +0000
+++ src/modules/Unity/Application/application_manager.h	2015-07-13 21:57:32 +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
@@ -21,6 +21,7 @@
 #include <memory>
 
 // Qt
+#include <QJSEngine>
 #include <QObject>
 #include <QStringList>
 
@@ -28,6 +29,7 @@
 #include <unity/shell/application/ApplicationManagerInterface.h>
 
 // local
+#include "globals.h"
 #include "application.h"
 #include "desktopfilereader.h"
 
@@ -40,6 +42,7 @@
 }
 
 class MirServer;
+class QJSValue;
 
 namespace qtmir {
 
@@ -63,7 +66,7 @@
     class Factory
     {
     public:
-        ApplicationManager* create();
+        ApplicationManager* create(QJSEngine *jsEngine);
     };
 
     // FIXME: these roles should be added to unity-api and removed from here
@@ -79,7 +82,7 @@
     };
     Q_DECLARE_FLAGS(ExecFlags, Flag)
 
-    static ApplicationManager* singleton();
+    static ApplicationManager* singleton(QJSEngine *jsEngine);
 
     explicit ApplicationManager(
             const QSharedPointer<MirServer> &mirServer,
@@ -88,15 +91,16 @@
             const QSharedPointer<DesktopFileReader::Factory> &desktopFileReaderFactory,
             const QSharedPointer<ProcInfo> &processInfo,
             const QSharedPointer<SettingsInterface> &settings,
+            QJSEngine *jsEngine,
             QObject *parent = 0);
     virtual ~ApplicationManager();
 
     // ApplicationManagerInterface
     QString focusedApplicationId() const override;
-    bool suspended() const override;
-    void setSuspended(bool suspended) override;
-    bool forceDashActive() const override;
-    void setForceDashActive(bool forceDashActive) override;
+
+    QJSValue surfaceAboutToBeCreatedCallback() const override;
+    void setSurfaceAboutToBeCreatedCallback(const QJSValue &callback) override;
+
     Q_INVOKABLE qtmir::Application* get(int index) const override;
     Q_INVOKABLE qtmir::Application* findApplication(const QString &appId) const override;
     Q_INVOKABLE bool requestFocusApplication(const QString &appId) override;
@@ -110,7 +114,7 @@
     QVariant data(const QModelIndex & index, int role) const override;
 
     Q_INVOKABLE qtmir::Application *startApplication(const QString &appId, ExecFlags flags,
-                                              const QStringList &arguments = QStringList());
+                                                     const QStringList &arguments = QStringList());
     Q_INVOKABLE void move(int from, int to);
 
     bool isEmpty() const { return rowCount() == 0; }
@@ -121,20 +125,24 @@
 public Q_SLOTS:
     void authorizeSession(const quint64 pid, bool &authorized);
 
-    void onSessionStarting(std::shared_ptr<mir::scene::Session> const& session);
-    void onSessionStopping(std::shared_ptr<mir::scene::Session> const& session);
+    void onSessionStarting(const std::shared_ptr<mir::scene::Session> &session);
+    void onSessionStopping(const std::shared_ptr<mir::scene::Session> &session);
 
-    void onSessionCreatedSurface(mir::scene::Session const*, std::shared_ptr<mir::scene::Surface> const&);
+    void onSessionAboutToCreateSurface(const std::shared_ptr<mir::scene::Session> &session,
+                                       SurfaceParameters &surfaceParameters);
+    void onSessionCreatedSurface(const mir::scene::Session *session,
+                                 const std::shared_ptr<mir::scene::Surface> &surface);
 
     void onProcessStarting(const QString& appId);
     void onProcessStopped(const QString& appId);
+    void onProcessSuspended(const QString& appId);
     void onProcessFailed(const QString& appId, const bool duringStartup);
     void onFocusRequested(const QString& appId);
     void onResumeRequested(const QString& appId);
 
 Q_SIGNALS:
-    void focusRequested(const QString &appId);
     void emptyChanged();
+    void surfaceAboutToBeCreatedCallbackChanged();
 
 private Q_SLOTS:
     void onAppDataChanged(const int role);
@@ -146,9 +154,7 @@
     void remove(Application* application);
     Application* findApplicationWithSession(const std::shared_ptr<mir::scene::Session> &session);
     Application* findApplicationWithSession(const mir::scene::Session *session);
-    Application* applicationForStage(Application::Stage stage);
     QModelIndex findIndex(Application* application);
-    bool suspendApplication(Application *application);
     void resumeApplication(Application *application);
     QString toString() const;
 
@@ -158,19 +164,15 @@
 
     QList<Application*> m_applications;
     Application* m_focusedApplication;
-    Application* m_mainStageApplication;
-    Application* m_sideStageApplication;
-    QStringList m_lifecycleExceptions;
     DBusWindowStack* m_dbusWindowStack;
     QSharedPointer<TaskController> m_taskController;
     QSharedPointer<DesktopFileReader::Factory> m_desktopFileReaderFactory;
     QSharedPointer<ProcInfo> m_procInfo;
     QSharedPointer<SharedWakelock> m_sharedWakelock;
     QSharedPointer<SettingsInterface> m_settings;
+    QJSValue m_surfaceAboutToBeCreatedCallback;
+    QJSEngine *m_jsEngine;
     static ApplicationManager* the_application_manager;
-    QList<pid_t> m_hiddenPIDs;
-    bool m_suspended;
-    bool m_forceDashActive;
 
     friend class Application;
     friend class DBusWindowStack;

=== modified file 'src/modules/Unity/Application/applicationcontroller.h'
--- src/modules/Unity/Application/applicationcontroller.h	2014-09-18 22:03:02 +0000
+++ src/modules/Unity/Application/applicationcontroller.h	2015-07-13 21:57:32 +0000
@@ -57,8 +57,9 @@
     void applicationAboutToBeStarted(const QString &appId);
     void applicationStarted(const QString &appId);
     void applicationStopped(const QString &appId);
+    void applicationPaused(const QString &appId);
     void applicationFocusRequest(const QString &appId);
-    void applicationResumeRequest(const QString &appId);
+    void applicationResumeRequested(const QString &appId);
 
     void applicationError(const QString &appId, ApplicationController::Error error);
 

=== modified file 'src/modules/Unity/Application/applicationscreenshotprovider.cpp'
--- src/modules/Unity/Application/applicationscreenshotprovider.cpp	2014-09-18 09:38:41 +0000
+++ src/modules/Unity/Application/applicationscreenshotprovider.cpp	2015-07-13 21:57:32 +0000
@@ -55,7 +55,7 @@
 
     // TODO: if app not ready, return an app-provided splash image. If app has been stopped with saved state
     // return the screenshot that was saved to disk.
-    Session* session = app->session();
+    SessionInterface* session = app->session();
     if (!session || !session->session() || !session->session()->default_surface()) {
         qWarning() << "ApplicationScreenshotProvider - app session not found - asking for screenshot too early";
         return QImage();

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.cpp'
--- src/modules/Unity/Application/mirsurfaceitem.cpp	2015-05-21 18:38:27 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.cpp	2015-07-13 21:57:32 +0000
@@ -190,13 +190,13 @@
                                MirShell *shell,
                                std::shared_ptr<SurfaceObserver> observer,
                                QQuickItem *parent)
-    : QQuickItem(parent)
+    : MirSurfaceItemInterface(parent)
     , m_surface(surface)
     , m_session(session)
     , m_shell(shell)
     , m_firstFrameDrawn(false)
     , m_live(true)
-    , m_orientationAngle(Angle0)
+    , m_orientationAngle(Globals::Angle0)
     , m_textureProvider(nullptr)
     , m_lastTouchEvent(nullptr)
 {
@@ -296,22 +296,22 @@
     return m_session.data();
 }
 
-MirSurfaceItem::Type MirSurfaceItem::type() const
-{
-    return static_cast<MirSurfaceItem::Type>(m_surface->type());
-}
-
-MirSurfaceItem::State MirSurfaceItem::state() const
-{
-    return static_cast<MirSurfaceItem::State>(m_surface->state());
-}
-
-MirSurfaceItem::OrientationAngle MirSurfaceItem::orientationAngle() const
+Globals::SurfaceType MirSurfaceItem::type() const
+{
+    return static_cast<Globals::SurfaceType>(m_surface->type());
+}
+
+Globals::SurfaceState MirSurfaceItem::state() const
+{
+    return static_cast<Globals::SurfaceState>(m_surface->state());
+}
+
+Globals::OrientationAngle MirSurfaceItem::orientationAngle() const
 {
     return m_orientationAngle;
 }
 
-void MirSurfaceItem::setOrientationAngle(MirSurfaceItem::OrientationAngle angle)
+void MirSurfaceItem::setOrientationAngle(Globals::OrientationAngle angle)
 {
     qCDebug(QTMIR_SURFACES, "MirSurfaceItem::setOrientationAngle(%d)", angle);
 
@@ -321,16 +321,16 @@
     MirOrientation mirOrientation;
 
     switch (angle) {
-    case Angle0:
+    case Globals::Angle0:
         mirOrientation = mir_orientation_normal;
         break;
-    case Angle90:
+    case Globals::Angle90:
         mirOrientation = mir_orientation_right;
         break;
-    case Angle180:
+    case Globals::Angle180:
         mirOrientation = mir_orientation_inverted;
         break;
-    case Angle270:
+    case Globals::Angle270:
         mirOrientation = mir_orientation_left;
         break;
     default:
@@ -375,7 +375,7 @@
 {
     if (!m_firstFrameDrawn) {
         m_firstFrameDrawn = true;
-        Q_EMIT firstFrameDrawn(this);
+        Q_EMIT firstFrameDrawn();
     }
 
     scheduleTextureUpdate();
@@ -456,7 +456,7 @@
 
 void MirSurfaceItem::mousePressEvent(QMouseEvent *event)
 {
-    if (type() == InputMethod) {
+    if (type() == Globals::SurfaceType::InputMethod) {
         // FIXME: Hack to get the VKB use case working while we don't have the proper solution in place.
         if (isMouseInsideUbuntuKeyboard(event)) {
             auto ev = makeMirEvent(event, mir_pointer_action_button_down);
@@ -562,7 +562,7 @@
 
         touchEvent.updateTouchPointStatesAndType();
 
-        auto ev = makeMirEvent(touchEvent.modifiers, touchEvent.touchPoints, 
+        auto ev = makeMirEvent(touchEvent.modifiers, touchEvent.touchPoints,
                                touchEvent.touchPointStates, touchEvent.timestamp);
         m_surface->consume(*ev);
 
@@ -615,7 +615,7 @@
         Qt::TouchPointStates touchPointStates)
 {
     bool accepted = true;
-    if (type() == InputMethod && eventType == QEvent::TouchBegin) {
+    if (type() == Globals::SurfaceType::InputMethod && eventType == QEvent::TouchBegin) {
         // FIXME: Hack to get the VKB use case working while we don't have the proper solution in place.
         if (hasTouchInsideUbuntuKeyboard(touchPoints)) {
             validateAndDeliverTouchEvent(eventType, timestamp, mods, touchPoints, touchPointStates);
@@ -659,21 +659,21 @@
         && pos.y() <= (ubuntuKeyboardInfo->y() + ubuntuKeyboardInfo->height());
 }
 
-void MirSurfaceItem::setType(const Type &type)
+void MirSurfaceItem::setType(const Globals::SurfaceType &type)
 {
     if (this->type() != type) {
         m_shell->set_surface_attribute(m_session->session(), m_surface, mir_surface_attrib_type, static_cast<int>(type));
     }
 }
 
-void MirSurfaceItem::setState(const State &state)
+void MirSurfaceItem::setState(const Globals::SurfaceState &state)
 {
     if (this->state() != state) {
         m_shell->set_surface_attribute(m_session->session(), m_surface, mir_surface_attrib_state, static_cast<int>(state));
     }
 }
 
-void MirSurfaceItem::setLive(const bool live)
+void MirSurfaceItem::setLive(bool live)
 {
     if (m_live != live) {
         m_live = live;

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.h'
--- src/modules/Unity/Application/mirsurfaceitem.h	2015-05-13 17:18:45 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.h	2015-07-13 21:57:32 +0000
@@ -22,15 +22,13 @@
 // Qt
 #include <QMutex>
 #include <QPointer>
-#include <QSet>
-#include <QQuickItem>
 #include <QTimer>
 #include <QQmlListProperty>
 
 // mir
 #include <mir/scene/surface.h>
-#include <mir_toolkit/common.h>
 
+#include "mirsurfaceiteminterface.h"
 #include "session_interface.h"
 
 class SurfaceObserver;
@@ -41,24 +39,10 @@
 class MirSurfaceManager;
 class QSGMirSurfaceNode;
 class QMirSurfaceTextureProvider;
-class Application;
 
-class MirSurfaceItem : public QQuickItem
+class MirSurfaceItem : public MirSurfaceItemInterface
 {
     Q_OBJECT
-    Q_ENUMS(Type)
-    Q_ENUMS(State)
-    Q_ENUMS(OrientationAngle)
-
-    Q_PROPERTY(Type type READ type NOTIFY typeChanged)
-    Q_PROPERTY(State state READ state NOTIFY stateChanged)
-    Q_PROPERTY(QString name READ name NOTIFY nameChanged)
-    Q_PROPERTY(bool live READ live NOTIFY liveChanged)
-
-    // How many degrees, clockwise, the UI in the surface has to rotate to match with the
-    // shell UI orientation
-    Q_PROPERTY(OrientationAngle orientationAngle READ orientationAngle WRITE setOrientationAngle
-               NOTIFY orientationAngleChanged DESIGNABLE false)
 
 public:
     explicit MirSurfaceItem(std::shared_ptr<mir::scene::Surface> surface,
@@ -66,57 +50,29 @@
                             MirShell *shell,
                             std::shared_ptr<SurfaceObserver> observer,
                             QQuickItem *parent = 0);
-    ~MirSurfaceItem();
-
-    enum Type {
-        Normal = mir_surface_type_normal,
-        Utility = mir_surface_type_utility,
-        Dialog = mir_surface_type_dialog,
-        Overlay = mir_surface_type_overlay,
-        Freestyle = mir_surface_type_freestyle,
-        Popover = mir_surface_type_popover,
-        InputMethod = mir_surface_type_inputmethod,
-        };
-
-    enum State {
-        Unknown = mir_surface_state_unknown,
-        Restored = mir_surface_state_restored,
-        Minimized = mir_surface_state_minimized,
-        Maximized = mir_surface_state_maximized,
-        VertMaximized = mir_surface_state_vertmaximized,
-        /* SemiMaximized = mir_surface_state_semimaximized, // see mircommon/mir_toolbox/common.h*/
-        Fullscreen = mir_surface_state_fullscreen,
-    };
-
-    enum OrientationAngle {
-        Angle0 = 0,
-        Angle90 = 90,
-        Angle180 = 180,
-        Angle270 = 270
-    };
+    virtual ~MirSurfaceItem();
 
     //getters
-    Type type() const;
-    State state() const;
-    QString name() const;
-    bool live() const;
-    SessionInterface *session() const;
+    Globals::SurfaceType type() const override;
+    Globals::SurfaceState state() const override;
+    QString name() const override;
+    bool live() const override;
+    SessionInterface *session() const override;
+    Globals::OrientationAngle orientationAngle() const override;
 
-    Q_INVOKABLE void release();
+    Q_INVOKABLE void release() override;
 
     // Item surface/texture management
     bool isTextureProvider() const { return true; }
     QSGTextureProvider *textureProvider() const;
 
-    void stopFrameDropper();
-    void startFrameDropper();
-
-    bool isFirstFrameDrawn() const { return m_firstFrameDrawn; }
-
-    OrientationAngle orientationAngle() const;
-    void setOrientationAngle(OrientationAngle angle);
-
-    void setSession(SessionInterface *app);
+    void stopFrameDropper() override;
+    void startFrameDropper() override;
+
+    bool isFirstFrameDrawn() const override { return m_firstFrameDrawn; }
+
+    void setOrientationAngle(Globals::OrientationAngle angle) override;
+    void setSession(SessionInterface *app) override;
 
     // to allow easy touch event injection from tests
     bool processTouchEvent(int eventType,
@@ -125,14 +81,6 @@
             const QList<QTouchEvent::TouchPoint> &touchPoints,
             Qt::TouchPointStates touchPointStates);
 
-Q_SIGNALS:
-    void typeChanged();
-    void stateChanged();
-    void nameChanged();
-    void orientationAngleChanged(OrientationAngle angle);
-    void liveChanged(bool live);
-    void firstFrameDrawn(MirSurfaceItem *item);
-
 protected Q_SLOTS:
     void onSessionStateChanged(SessionInterface::State state);
 
@@ -167,9 +115,9 @@
     bool updateTexture();
     void ensureProvider();
 
-    void setType(const Type&);
-    void setState(const State&);
-    void setLive(const bool);
+    void setType(const Globals::SurfaceType&);
+    void setState(const Globals::SurfaceState&);
+    void setLive(bool) override;
 
     // called by MirSurfaceManager
     void setSurfaceValid(const bool);
@@ -197,7 +145,7 @@
     bool m_live;
 
     //FIXME -  have to save the state as Mir has no getter for it (bug:1357429)
-    OrientationAngle m_orientationAngle;
+    Globals::OrientationAngle m_orientationAngle;
 
     QMirSurfaceTextureProvider *m_textureProvider;
 
@@ -226,13 +174,8 @@
         QList<QTouchEvent::TouchPoint> touchPoints;
         Qt::TouchPointStates touchPointStates;
     } *m_lastTouchEvent;
-
-    friend class MirSurfaceManager;
 };
 
 } // namespace qtmir
 
-Q_DECLARE_METATYPE(qtmir::MirSurfaceItem*)
-Q_DECLARE_METATYPE(qtmir::MirSurfaceItem::OrientationAngle)
-
 #endif // MIRSURFACEITEM_H

=== added file 'src/modules/Unity/Application/mirsurfaceiteminterface.h'
--- src/modules/Unity/Application/mirsurfaceiteminterface.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/mirsurfaceiteminterface.h	2015-07-13 21:57:32 +0000
@@ -0,0 +1,89 @@
+/*
+ * 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 MIRSURFACEITEMINTERFACE_H
+#define MIRSURFACEITEMINTERFACE_H
+
+// Qt
+#include <QQuickItem>
+
+// mir
+#include <mir_toolkit/common.h>
+
+#include "session_interface.h"
+#include "globals.h"
+
+namespace qtmir {
+
+class MirSurfaceItemInterface : public QQuickItem
+{
+    Q_OBJECT
+    Q_ENUMS(Type)
+    Q_ENUMS(State)
+    Q_ENUMS(OrientationAngle)
+
+    Q_PROPERTY(qtmir::Globals::SurfaceType type READ type NOTIFY typeChanged)
+    Q_PROPERTY(qtmir::Globals::SurfaceState state READ state NOTIFY stateChanged)
+    Q_PROPERTY(QString name READ name NOTIFY nameChanged)
+    Q_PROPERTY(bool live READ live NOTIFY liveChanged)
+
+    // How many degrees, clockwise, the UI in the surface has to rotate to match with the
+    // shell UI orientation
+    Q_PROPERTY(qtmir::Globals::OrientationAngle orientationAngle READ orientationAngle WRITE setOrientationAngle
+               NOTIFY orientationAngleChanged DESIGNABLE false)
+
+public:
+    MirSurfaceItemInterface(QQuickItem *parent) : QQuickItem(parent) {}
+    virtual ~MirSurfaceItemInterface() {}
+
+    //getters
+    virtual Globals::SurfaceType type() const = 0;
+    virtual Globals::SurfaceState state() const = 0;
+    virtual QString name() const = 0;
+    virtual bool live() const = 0;
+    virtual SessionInterface *session() const = 0;
+    virtual Globals::OrientationAngle orientationAngle() const = 0;
+
+    virtual Q_INVOKABLE void release() = 0;
+
+    virtual void stopFrameDropper() = 0;
+    virtual void startFrameDropper() = 0;
+
+    virtual bool isFirstFrameDrawn() const = 0;
+
+    virtual void setOrientationAngle(Globals::OrientationAngle angle) = 0;
+    virtual void setSession(SessionInterface *app) = 0;
+
+Q_SIGNALS:
+    void typeChanged();
+    void stateChanged();
+    void nameChanged();
+    void orientationAngleChanged(Globals::OrientationAngle angle);
+    void liveChanged(bool live);
+    void firstFrameDrawn();
+
+private:
+    virtual void setLive(bool) = 0;
+
+    friend class MirSurfaceManager;
+};
+
+} // namespace qtmir
+
+Q_DECLARE_METATYPE(qtmir::MirSurfaceItemInterface*)
+
+#endif // MIRSURFACEITEMINTERFACE_H
+

=== modified file 'src/modules/Unity/Application/mirsurfaceitemmodel.h'
--- src/modules/Unity/Application/mirsurfaceitemmodel.h	2014-08-29 11:15:51 +0000
+++ src/modules/Unity/Application/mirsurfaceitemmodel.h	2015-07-13 21:57:32 +0000
@@ -22,8 +22,8 @@
 
 namespace qtmir {
 
-class MirSurfaceItem;
-typedef ObjectListModel<MirSurfaceItem> MirSurfaceItemModel;
+class MirSurfaceItemInterface;
+typedef ObjectListModel<MirSurfaceItemInterface> MirSurfaceItemModel;
 
 } // namespace qtmir
 

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.cpp'
--- src/modules/Unity/Application/mirsurfacemanager.cpp	2015-03-11 10:10:49 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.cpp	2015-07-13 21:57:32 +0000
@@ -51,7 +51,7 @@
                      manager, &MirSurfaceManager::onSessionDestroyingSurface);
 }
 
-MirSurfaceManager* MirSurfaceManager::singleton()
+MirSurfaceManager* MirSurfaceManager::singleton(QJSEngine *jsEngine)
 {
     if (!the_surface_manager) {
 
@@ -66,7 +66,7 @@
         SessionListener *sessionListener = static_cast<SessionListener*>(nativeInterface->nativeResourceForIntegration("SessionListener"));
         MirShell *shell = static_cast<MirShell*>(nativeInterface->nativeResourceForIntegration("Shell"));
 
-        the_surface_manager = new MirSurfaceManager(nativeInterface->m_mirServer, shell, SessionManager::singleton());
+        the_surface_manager = new MirSurfaceManager(nativeInterface->m_mirServer, shell, SessionManager::singleton(jsEngine));
 
         connectToSessionListener(the_surface_manager, sessionListener);
     }
@@ -112,11 +112,11 @@
         session->setSurface(qmlSurface);
 
     // Only notify QML of surface creation once it has drawn its first frame.
-    connect(qmlSurface, &MirSurfaceItem::firstFrameDrawn, this, [&](MirSurfaceItem *item) {
+    connect(qmlSurface, &MirSurfaceItemInterface::firstFrameDrawn, this, [=]() {
         tracepoint(qtmir, firstFrameDrawn);
-        Q_EMIT surfaceCreated(item);
+        Q_EMIT surfaceCreated(qmlSurface);
 
-        insert(0, item);
+        insert(0, qmlSurface);
     });
 
     // clean up after MirSurfaceItem is destroyed
@@ -139,7 +139,7 @@
     qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::onSessionDestroyingSurface - session=" << session
                             << "surface=" << surface.get() << "surface.name=" << surface->name().c_str();
 
-    MirSurfaceItem* item = nullptr;
+    MirSurfaceItemInterface* item = nullptr;
     {
         QMutexLocker lock(&m_mutex);
         auto it = m_mirSurfaceToItemHash.find(surface.get());

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.h'
--- src/modules/Unity/Application/mirsurfacemanager.h	2015-03-11 10:10:49 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.h	2015-07-13 21:57:32 +0000
@@ -61,11 +61,11 @@
     );
     ~MirSurfaceManager();
 
-    static MirSurfaceManager* singleton();
+    static MirSurfaceManager* singleton(QJSEngine *jsEngine);
 
 Q_SIGNALS:
-    void surfaceCreated(MirSurfaceItem* surface);
-    void surfaceDestroyed(MirSurfaceItem* surface);
+    void surfaceCreated(MirSurfaceItemInterface* surface);
+    void surfaceDestroyed(MirSurfaceItemInterface* surface);
 //    void surfaceResized(MirSurface*);
 //    void fullscreenSurfaceChanged();
 
@@ -74,7 +74,7 @@
     void onSessionDestroyingSurface(const mir::scene::Session *, const std::shared_ptr<mir::scene::Surface> &);
 
 protected:
-    QHash<const mir::scene::Surface *, MirSurfaceItem *> m_mirSurfaceToItemHash;
+    QHash<const mir::scene::Surface *, MirSurfaceItemInterface *> m_mirSurfaceToItemHash;
     QMutex m_mutex;
 
 private:

=== modified file 'src/modules/Unity/Application/plugin.cpp'
--- src/modules/Unity/Application/plugin.cpp	2015-02-05 10:28:31 +0000
+++ src/modules/Unity/Application/plugin.cpp	2015-07-13 21:57:32 +0000
@@ -28,41 +28,36 @@
 
 // qtmir
 #include "logging.h"
-
-using namespace qtmir;
-
-static QObject* applicationManagerSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {
-    Q_UNUSED(engine);
-    Q_UNUSED(scriptEngine);
-    qCDebug(QTMIR_APPLICATIONS) << "applicationManagerSingleton - engine=" << engine << "scriptEngine=" << scriptEngine;
-
-    return qtmir::ApplicationManager::singleton();
-}
-
-static QObject* surfaceManagerSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {
-    Q_UNUSED(engine);
-    Q_UNUSED(scriptEngine);
-    qCDebug(QTMIR_APPLICATIONS) << "surfaceManagerSingleton - engine=" << engine << "scriptEngine=" << scriptEngine;
-
-    return qtmir::MirSurfaceManager::singleton();
-}
-
-static QObject* sessionManagerSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {
-    Q_UNUSED(engine);
-    Q_UNUSED(scriptEngine);
-    return qtmir::SessionManager::singleton();
-}
+#include "globals.h"
 
 namespace {
-QObject* ubuntuKeyboardInfoSingleton(QQmlEngine* /*engine*/, QJSEngine* /*scriptEngine*/) {
-    if (!UbuntuKeyboardInfo::instance()) {
-        new UbuntuKeyboardInfo;
+
+QObject* applicationManagerSingleton(QQmlEngine* /*engine*/, QJSEngine* jsEngine)
+{
+    return qtmir::ApplicationManager::singleton(jsEngine);
+}
+
+QObject* surfaceManagerSingleton(QQmlEngine* /*engine*/, QJSEngine* jsEngine)
+{
+    return qtmir::MirSurfaceManager::singleton(jsEngine);
+}
+
+QObject* sessionManagerSingleton(QQmlEngine* /*engine*/, QJSEngine* jsEngine)
+{
+    return qtmir::SessionManager::singleton(jsEngine);
+}
+
+QObject* ubuntuKeyboardInfoSingleton(QQmlEngine* /*engine*/, QJSEngine* /*scriptEngine*/)
+{
+    if (!qtmir::UbuntuKeyboardInfo::instance()) {
+        new qtmir::UbuntuKeyboardInfo;
     }
-    return UbuntuKeyboardInfo::instance();
+    return qtmir::UbuntuKeyboardInfo::instance();
 }
 } // anonymous namespace
 
-class UnityApplicationPlugin : public QQmlExtensionPlugin {
+class UnityApplicationPlugin : public QQmlExtensionPlugin
+{
     Q_OBJECT
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface/1.0")
 
@@ -71,9 +66,12 @@
         qCDebug(QTMIR_APPLICATIONS) << "UnityApplicationPlugin::registerTypes - this=" << this << "uri=" << uri;
         Q_ASSERT(QLatin1String(uri) == QLatin1String("Unity.Application"));
 
+        qmlRegisterUncreatableType<qtmir::Globals>(
+                    uri, 0, 1, "QtMir", "QtMir provides enum values, it can't be instantiated");
+
         qRegisterMetaType<qtmir::ApplicationManager*>("ApplicationManager*"); //need for queueing signals
         qRegisterMetaType<qtmir::Application*>("Application*");
-        qRegisterMetaType<qtmir::MirSurfaceItem*>("MirSurfaceItem*");
+        qRegisterMetaType<qtmir::MirSurfaceItemInterface*>("MirSurfaceItemInterface*");
         qRegisterMetaType<qtmir::MirSurfaceItemModel*>("MirSurfaceItemModel*");
         qRegisterMetaType<qtmir::Session*>("Session*");
         qRegisterMetaType<qtmir::SessionInterface*>("SessionInterface*");
@@ -92,7 +90,7 @@
                     uri, 0, 1, "SurfaceManager", surfaceManagerSingleton);
         qmlRegisterSingletonType<qtmir::SessionManager>(
                     uri, 0, 1, "SessionManager", sessionManagerSingleton);
-        qmlRegisterUncreatableType<qtmir::MirSurfaceItem>(
+        qmlRegisterUncreatableType<qtmir::MirSurfaceItemInterface>(
                     uri, 0, 1, "MirSurfaceItem", "MirSurfaceItem can't be instantiated from QML");
         qmlRegisterUncreatableType<qtmir::Session>(
                     uri, 0, 1, "Session", "Session can't be instantiated from QML");
@@ -105,7 +103,7 @@
         QQmlExtensionPlugin::initializeEngine(engine, uri);
 
         qtmir::ApplicationManager* appManager
-                = static_cast<qtmir::ApplicationManager*>(applicationManagerSingleton(engine, nullptr));
+                = static_cast<qtmir::ApplicationManager*>(applicationManagerSingleton(engine, engine));
         engine->addImageProvider(QLatin1String("application"), new qtmir::ApplicationScreenshotProvider(appManager));
     }
 };

=== modified file 'src/modules/Unity/Application/session.cpp'
--- src/modules/Unity/Application/session.cpp	2015-01-15 15:19:26 +0000
+++ src/modules/Unity/Application/session.cpp	2015-07-13 21:57:32 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014,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
@@ -60,14 +60,7 @@
     QQmlEngine::setObjectOwnership(this, QQmlEngine::CppOwnership);
 
     m_suspendTimer->setSingleShot(true);
-    connect(m_suspendTimer, &QTimer::timeout, this, [this]() {
-        if (m_surface) {
-            m_surface->stopFrameDropper();
-        } else {
-            qDebug() << "Application::suspend - no surface to call stopFrameDropper() on!";
-        }
-        Q_EMIT suspended();
-    });
+    connect(m_suspendTimer, &QTimer::timeout, this, &Session::doSuspend);
 }
 
 Session::~Session()
@@ -89,6 +82,17 @@
     delete m_children; m_children = nullptr;
 }
 
+void Session::doSuspend()
+{
+    Q_ASSERT(m_state == Session::Suspending);
+    if (m_surface) {
+        m_surface->stopFrameDropper();
+    } else {
+        qDebug() << "Application::suspend - no surface to call stopFrameDropper() on!";
+    }
+    setState(Suspended);
+}
+
 void Session::release()
 {
     qCDebug(QTMIR_SESSIONS) << "Session::release " << name();
@@ -120,7 +124,7 @@
     return m_application;
 }
 
-MirSurfaceItem* Session::surface() const
+MirSurfaceItemInterface* Session::surface() const
 {
     // Only notify QML of surface creation once it has drawn its first frame.
     if (m_surface && m_surface->isFirstFrameDrawn()) {
@@ -140,6 +144,13 @@
     return m_state;
 }
 
+void Session::setState(State state) {
+    if (state != m_state) {
+        m_state = state;
+        Q_EMIT stateChanged(m_state);
+    }
+}
+
 bool Session::fullscreen() const
 {
     return m_fullscreen;
@@ -159,7 +170,7 @@
     Q_EMIT applicationChanged(application);
 }
 
-void Session::setSurface(MirSurfaceItem *newSurface)
+void Session::setSurface(MirSurfaceItemInterface *newSurface)
 {
     qCDebug(QTMIR_SESSIONS) << "Session::setSurface - session=" << name() << "surface=" << newSurface;
 
@@ -173,34 +184,46 @@
         m_surface->setParent(nullptr);
     }
 
-    MirSurfaceItem *previousSurface = surface();
+    MirSurfaceItemInterface *previousSurface = surface();
     m_surface = newSurface;
 
     if (newSurface) {
         m_surface->setParent(this);
         m_surface->setSession(this);
 
+        connect(newSurface, &MirSurfaceItemInterface::stateChanged,
+            this, &Session::updateFullscreenProperty);
+
         // Only notify QML of surface creation once it has drawn its first frame.
-        if (!surface()) {
-            connect(newSurface, &MirSurfaceItem::firstFrameDrawn,
-                    this, [this] { Q_EMIT surfaceChanged(m_surface); });
+        if (m_surface->isFirstFrameDrawn()) {
+            setState(Running);
+        } else {
+            connect(newSurface, &MirSurfaceItemInterface::firstFrameDrawn,
+                    this, &Session::onFirstSurfaceFrameDrawn);
         }
-
-        connect(newSurface, &MirSurfaceItem::stateChanged,
-            this, &Session::updateFullscreenProperty);
     }
 
     if (previousSurface != surface()) {
+        qCDebug(QTMIR_SESSIONS).nospace() << "Session::surfaceChanged - session=" << this
+            << " surface=" << m_surface;
         Q_EMIT surfaceChanged(m_surface);
     }
 
     updateFullscreenProperty();
 }
 
+void Session::onFirstSurfaceFrameDrawn()
+{
+    qCDebug(QTMIR_SESSIONS).nospace() << "Session::surfaceChanged - session=" << this
+        << " surface=" << m_surface;
+    Q_EMIT surfaceChanged(m_surface);
+    setState(Running);
+}
+
 void Session::updateFullscreenProperty()
 {
     if (m_surface) {
-        setFullscreen(m_surface->state() == MirSurfaceItem::Fullscreen);
+        setFullscreen(m_surface->state() == Globals::SurfaceState::Fullscreen);
     } else {
         // Keep the current value of the fullscreen property until we get a new
         // surface
@@ -216,59 +239,71 @@
     }
 }
 
-void Session::setState(State state)
-{
-    qCDebug(QTMIR_SESSIONS) << "Session::setState - session=" << this << "state=" << applicationStateToStr(state);
-    if (m_state != state) {
-        switch (state)
-        {
-        case Session::State::Suspended:
-            if (m_state == Session::State::Running) {
-                session()->set_lifecycle_state(mir_lifecycle_state_will_suspend);
-                m_suspendTimer->start(1500);
-            }
-            break;
-        case Session::State::Running:
-            if (m_suspendTimer->isActive())
-                m_suspendTimer->stop();
-
-            if (m_state == Session::State::Suspended) {
-                if (m_surface)
-                    m_surface->startFrameDropper();
-                Q_EMIT resumed();
-                session()->set_lifecycle_state(mir_lifecycle_state_resumed);
-            }
-            break;
-        case Session::State::Stopped:
-            stopPromptSessions();
-            if (m_suspendTimer->isActive())
-                m_suspendTimer->stop();
-            if (m_surface)
-                m_surface->stopFrameDropper();
-            break;
-        default:
-            break;
-        }
-
-        m_state = state;
-        Q_EMIT stateChanged(state);
-
-        foreachPromptSession([this, state](const std::shared_ptr<ms::PromptSession>& promptSession) {
-            switch (state) {
-                case Session::State::Suspended:
-                    m_promptSessionManager->suspend_prompt_session(promptSession);
-                    break;
-                case Session::State::Running:
-                    m_promptSessionManager->resume_prompt_session(promptSession);
-                    break;
-                default:
-                    break;
-            }
-        });
-
-        foreachChildSession([state](SessionInterface* session) {
-            session->setState(state);
-        });
+void Session::suspend()
+{
+    qCDebug(QTMIR_SESSIONS) << "Session::suspend - session=" << this << "state=" << applicationStateToStr(m_state);
+    if (m_state == Running) {
+        session()->set_lifecycle_state(mir_lifecycle_state_will_suspend);
+        m_suspendTimer->start(1500);
+
+        foreachPromptSession([this](const std::shared_ptr<ms::PromptSession>& promptSession) {
+            m_promptSessionManager->suspend_prompt_session(promptSession);
+        });
+
+        foreachChildSession([](SessionInterface* session) {
+            session->suspend();
+        });
+
+        setState(Suspending);
+    }
+}
+
+void Session::resume()
+{
+    qCDebug(QTMIR_SESSIONS) << "Session::resume - session=" << this << "state=" << applicationStateToStr(m_state);
+
+    if (m_state == Suspending || m_state == Suspended) {
+        doResume();
+    }
+}
+
+void Session::doResume()
+{
+    if (m_state == Suspending) {
+        Q_ASSERT(m_suspendTimer->isActive());
+        m_suspendTimer->stop();
+    } else if (m_state == Suspended) {
+        Q_ASSERT(m_surface);
+        m_surface->startFrameDropper();
+    }
+
+    session()->set_lifecycle_state(mir_lifecycle_state_resumed);
+
+    foreachPromptSession([this](const std::shared_ptr<ms::PromptSession>& promptSession) {
+        m_promptSessionManager->resume_prompt_session(promptSession);
+    });
+
+    foreachChildSession([](SessionInterface* session) {
+        session->resume();
+    });
+
+    setState(Running);
+}
+
+void Session::stop()
+{
+    if (m_state != Stopped) {
+        stopPromptSessions();
+        if (m_suspendTimer->isActive())
+            m_suspendTimer->stop();
+        if (m_surface)
+            m_surface->stopFrameDropper();
+
+        foreachChildSession([](SessionInterface* session) {
+            session->stop();
+        });
+
+        setState(Stopped);
     }
 }
 
@@ -277,6 +312,9 @@
     if (m_live != live) {
         m_live = live;
         Q_EMIT liveChanged(m_live);
+        if (!live) {
+            setState(Stopped);
+        }
     }
 }
 
@@ -302,7 +340,19 @@
     static_cast<Session*>(session)->setParentSession(this);
     m_children->insert(index, session);
 
-    session->setState(state());
+    switch (m_state) {
+        case Starting:
+        case Running:
+            session->resume();
+            break;
+        case Suspending:
+        case Suspended:
+            session->suspend();
+            break;
+        case Stopped:
+            session->stop();
+            break;
+    }
 }
 
 void Session::removeChildSession(SessionInterface* session)

=== modified file 'src/modules/Unity/Application/session.h'
--- src/modules/Unity/Application/session.h	2014-09-11 16:18:40 +0000
+++ src/modules/Unity/Application/session.h	2015-07-13 21:57:32 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014-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
@@ -52,15 +52,18 @@
     //getters
     QString name() const override;
     unity::shell::application::ApplicationInfoInterface* application() const override;
-    MirSurfaceItem* surface() const override;
+    MirSurfaceItemInterface* surface() const override;
     SessionInterface* parentSession() const override;
     State state() const override;
     bool fullscreen() const override;
     bool live() const override;
 
     void setApplication(unity::shell::application::ApplicationInfoInterface* item) override;
-    void setSurface(MirSurfaceItem* surface) override;
-    void setState(State state) override;
+    void setSurface(MirSurfaceItemInterface* surface) override;
+
+    void suspend() override;
+    void resume() override;
+    void stop() override;
 
     void addChildSession(SessionInterface* session) override;
     void insertChildSession(uint index, SessionInterface* session) override;
@@ -74,23 +77,29 @@
 
     SessionModel* childSessions() const override;
 
-protected:
     void setFullscreen(bool fullscreen) override;
     void setLive(const bool) override;
     void appendPromptSession(const std::shared_ptr<mir::scene::PromptSession>& session) override;
     void removePromptSession(const std::shared_ptr<mir::scene::PromptSession>& session) override;
 
+public Q_SLOTS:
+    // it's public to ease testing
+    void doSuspend();
+
 private Q_SLOTS:
     void updateFullscreenProperty();
+    void onFirstSurfaceFrameDrawn();
 
 private:
     void setParentSession(Session* session);
+    void setState(State state);
+    void doResume();
 
     void stopPromptSessions();
 
     std::shared_ptr<mir::scene::Session> m_session;
     Application* m_application;
-    MirSurfaceItem* m_surface;
+    MirSurfaceItemInterface* m_surface;
     SessionInterface* m_parentSession;
     SessionModel* m_children;
     bool m_fullscreen;
@@ -103,6 +112,4 @@
 
 } // namespace qtmir
 
-Q_DECLARE_METATYPE(qtmir::Session*)
-
 #endif // SESSION_H

=== modified file 'src/modules/Unity/Application/session_interface.h'
--- src/modules/Unity/Application/session_interface.h	2014-09-22 18:06:58 +0000
+++ src/modules/Unity/Application/session_interface.h	2015-07-13 21:57:32 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014,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
@@ -35,11 +35,11 @@
 
 namespace qtmir {
 
-class MirSurfaceItem;
+class MirSurfaceItemInterface;
 
 class SessionInterface : public QObject {
     Q_OBJECT
-    Q_PROPERTY(MirSurfaceItem* surface READ surface NOTIFY surfaceChanged)
+    Q_PROPERTY(MirSurfaceItemInterface* surface READ surface NOTIFY surfaceChanged)
     Q_PROPERTY(unity::shell::application::ApplicationInfoInterface* application READ application NOTIFY applicationChanged DESIGNABLE false)
     Q_PROPERTY(SessionInterface* parentSession READ parentSession NOTIFY parentSessionChanged DESIGNABLE false)
     Q_PROPERTY(SessionModel* childSessions READ childSessions DESIGNABLE false CONSTANT)
@@ -49,58 +49,66 @@
     SessionInterface(QObject *parent = 0) : QObject(parent) {}
     virtual ~SessionInterface() {}
 
-    // Session State
-    typedef unity::shell::application::ApplicationInfoInterface::State State;
+    enum State {
+        Starting,
+        Running,
+        Suspending,
+        Suspended,
+        Stopped
+    };
 
     Q_INVOKABLE virtual void release() = 0;
 
     //getters
     virtual QString name() const = 0;
     virtual unity::shell::application::ApplicationInfoInterface* application() const = 0;
-    virtual MirSurfaceItem* surface() const = 0;
+    virtual MirSurfaceItemInterface* surface() const = 0;
     virtual SessionInterface* parentSession() const = 0;
+    virtual SessionModel* childSessions() const = 0;
     virtual State state() const = 0;
     virtual bool fullscreen() const = 0;
     virtual bool live() const = 0;
 
+    virtual std::shared_ptr<mir::scene::Session> session() const = 0;
+
+    // For MirSurfaceItem and MirSurfaceManager use
+
+    virtual void setSurface(MirSurfaceItemInterface* surface) = 0;
+
+    // For Application use
+
     virtual void setApplication(unity::shell::application::ApplicationInfoInterface* item) = 0;
-    virtual void setSurface(MirSurfaceItem* surface) = 0;
-    virtual void setState(State state) = 0;
+    virtual void suspend() = 0;
+    virtual void resume() = 0;
+    virtual void stop() = 0;
+
+    // For SessionManager use
 
     virtual void addChildSession(SessionInterface* session) = 0;
     virtual void insertChildSession(uint index, SessionInterface* session) = 0;
     virtual void removeChildSession(SessionInterface* session) = 0;
     virtual void foreachChildSession(std::function<void(SessionInterface* session)> f) const = 0;
 
-    virtual std::shared_ptr<mir::scene::Session> session() const = 0;
-
     virtual std::shared_ptr<mir::scene::PromptSession> activePromptSession() const = 0;
     virtual void foreachPromptSession(std::function<void(const std::shared_ptr<mir::scene::PromptSession>&)> f) const = 0;
 
-    virtual SessionModel* childSessions() const = 0;
+    virtual void setFullscreen(bool fullscreen) = 0;
+    virtual void setLive(const bool) = 0;
+    virtual void appendPromptSession(const std::shared_ptr<mir::scene::PromptSession>& session) = 0;
+    virtual void removePromptSession(const std::shared_ptr<mir::scene::PromptSession>& session) = 0;
 
 Q_SIGNALS:
-    void surfaceChanged(MirSurfaceItem*);
+    void surfaceChanged(MirSurfaceItemInterface*);
     void parentSessionChanged(SessionInterface*);
     void applicationChanged(unity::shell::application::ApplicationInfoInterface* application);
     void aboutToBeDestroyed();
     void stateChanged(State state);
     void fullscreenChanged(bool fullscreen);
     void liveChanged(bool live);
-
-    void suspended();
-    void resumed();
-
-protected:
-    virtual void setFullscreen(bool fullscreen) = 0;
-    virtual void setLive(const bool) = 0;
-    virtual void appendPromptSession(const std::shared_ptr<mir::scene::PromptSession>& session) = 0;
-    virtual void removePromptSession(const std::shared_ptr<mir::scene::PromptSession>& session) = 0;
-
-    friend class SessionManager;
 };
 
 } // namespace qtmir
 
+Q_DECLARE_METATYPE(qtmir::SessionInterface*)
 
 #endif // SESSION_INTERFACE_H

=== modified file 'src/modules/Unity/Application/sessionmanager.cpp'
--- src/modules/Unity/Application/sessionmanager.cpp	2015-01-28 14:25:36 +0000
+++ src/modules/Unity/Application/sessionmanager.cpp	2015-07-13 21:57:32 +0000
@@ -63,7 +63,7 @@
                      manager, &SessionManager::onPromptProviderRemoved);
 }
 
-SessionManager* SessionManager::singleton()
+SessionManager* SessionManager::singleton(QJSEngine *jsEngine)
 {
     if (!the_session_manager) {
 
@@ -78,7 +78,7 @@
         SessionListener *sessionListener = static_cast<SessionListener*>(nativeInterface->nativeResourceForIntegration("SessionListener"));
         PromptSessionListener *promptSessionListener = static_cast<PromptSessionListener*>(nativeInterface->nativeResourceForIntegration("PromptSessionListener"));
 
-        the_session_manager = new SessionManager(nativeInterface->m_mirServer, ApplicationManager::singleton());
+        the_session_manager = new SessionManager(nativeInterface->m_mirServer, ApplicationManager::singleton(jsEngine));
 
         connectToSessionListener(the_session_manager, sessionListener);
         connectToPromptSessionListener(the_session_manager, promptSessionListener);

=== modified file 'src/modules/Unity/Application/sessionmanager.h'
--- src/modules/Unity/Application/sessionmanager.h	2014-12-01 11:05:01 +0000
+++ src/modules/Unity/Application/sessionmanager.h	2015-07-13 21:57:32 +0000
@@ -38,6 +38,8 @@
     }
 }
 
+class QJSEngine;
+
 class MirServer;
 
 namespace qtmir {
@@ -57,7 +59,7 @@
     );
     ~SessionManager();
 
-    static SessionManager* singleton();
+    static SessionManager* singleton(QJSEngine *jsEngine);
 
     SessionInterface *findSession(const mir::scene::Session* session) const;
 

=== modified file 'src/modules/Unity/Application/taskcontroller.cpp'
--- src/modules/Unity/Application/taskcontroller.cpp	2014-10-20 18:48:53 +0000
+++ src/modules/Unity/Application/taskcontroller.cpp	2015-07-13 21:57:32 +0000
@@ -50,14 +50,19 @@
             &TaskController::processStopped);
 
     connect(m_appController.data(),
+            &ApplicationController::applicationPaused,
+            this,
+            &TaskController::processSuspended);
+
+    connect(m_appController.data(),
             &ApplicationController::applicationFocusRequest,
             this,
-            &TaskController::onApplicationFocusRequest);
+            &TaskController::focusRequested);
 
     connect(m_appController.data(),
-            &ApplicationController::applicationResumeRequest,
+            &ApplicationController::applicationResumeRequested,
             this,
-            &TaskController::onApplicationResumeRequest);
+            &TaskController::resumeRequested);
 
     connect(m_appController.data(),
             &ApplicationController::applicationError,
@@ -108,16 +113,6 @@
     return m_appController->resumeApplicationWithAppId(appId);
 }
 
-void TaskController::onApplicationFocusRequest(const QString& id)
-{
-    Q_EMIT requestFocus(id);
-}
-
-void TaskController::onApplicationResumeRequest(const QString& id)
-{
-    Q_EMIT requestResume(id);
-}
-
 void TaskController::onApplicationError(const QString& id, ApplicationController::Error error)
 {
     Q_EMIT processFailed(id, (error == ApplicationController::Error::APPLICATION_FAILED_TO_START) );

=== modified file 'src/modules/Unity/Application/taskcontroller.h'
--- src/modules/Unity/Application/taskcontroller.h	2014-10-07 03:21:30 +0000
+++ src/modules/Unity/Application/taskcontroller.h	2015-07-13 21:57:32 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 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
@@ -48,14 +48,12 @@
 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 requestFocus(const QString &appId);
-    void requestResume(const QString &appId);
+    void focusRequested(const QString &appId);
+    void resumeRequested(const QString &appId);
 
 private Q_SLOTS:
-    void onApplicationFocusRequest(const QString &id);
-    void onApplicationResumeRequest(const QString &id);
-
     void onApplicationError(const QString &id, ApplicationController::Error error);
 
 private:

=== modified file 'src/modules/Unity/Application/upstart/applicationcontroller.cpp'
--- src/modules/Unity/Application/upstart/applicationcontroller.cpp	2014-11-13 15:47:30 +0000
+++ src/modules/Unity/Application/upstart/applicationcontroller.cpp	2015-07-13 21:57:32 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014,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
@@ -40,6 +40,7 @@
     UbuntuAppLaunchAppObserver stopCallback = nullptr;
     UbuntuAppLaunchAppObserver focusCallback = nullptr;
     UbuntuAppLaunchAppObserver resumeCallback = nullptr;
+    UbuntuAppLaunchAppPausedResumedObserver pausedCallback = nullptr;
     UbuntuAppLaunchAppFailedObserver failureCallback = nullptr;
 };
 
@@ -125,7 +126,12 @@
 
     impl->resumeCallback = [](const gchar * appId, gpointer userData) {
         auto thiz = static_cast<ApplicationController*>(userData);
-        Q_EMIT(thiz->applicationResumeRequest(toShortAppIdIfPossible(appId)));
+        Q_EMIT(thiz->applicationResumeRequested(toShortAppIdIfPossible(appId)));
+    };
+
+    impl->pausedCallback = [](const gchar * appId, GPid *, gpointer userData) {
+        auto thiz = static_cast<ApplicationController*>(userData);
+        Q_EMIT(thiz->applicationPaused(toShortAppIdIfPossible(appId)));
     };
 
     impl->failureCallback = [](const gchar * appId, UbuntuAppLaunchAppFailed failureType, gpointer userData) {
@@ -145,6 +151,7 @@
     ubuntu_app_launch_observer_add_app_stop(impl->stopCallback, this);
     ubuntu_app_launch_observer_add_app_focus(impl->focusCallback, this);
     ubuntu_app_launch_observer_add_app_resume(impl->resumeCallback, this);
+    ubuntu_app_launch_observer_add_app_paused(impl->pausedCallback, this);
     ubuntu_app_launch_observer_add_app_failed(impl->failureCallback, this);
 }
 
@@ -155,6 +162,7 @@
     ubuntu_app_launch_observer_delete_app_stop(impl->stopCallback, this);
     ubuntu_app_launch_observer_delete_app_focus(impl->focusCallback, this);
     ubuntu_app_launch_observer_delete_app_resume(impl->resumeCallback, this);
+    ubuntu_app_launch_observer_delete_app_paused(impl->pausedCallback, this);
     ubuntu_app_launch_observer_delete_app_failed(impl->failureCallback, this);
 }
 

=== modified file 'src/platforms/mirserver/CMakeLists.txt'
--- src/platforms/mirserver/CMakeLists.txt	2015-05-19 15:10:48 +0000
+++ src/platforms/mirserver/CMakeLists.txt	2015-07-13 21:57:32 +0000
@@ -31,6 +31,8 @@
     ${QT5PLATFORM_SUPPORT_INCLUDE_DIRS}
     ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
     ${QT5_PLATFORMSUPPORT_INCLUDE_DIRS}
+
+    ${APPLICATION_API_INCLUDE_DIRS}
 )
 
 # We have to remove -pedantic for tracepoints.c

=== modified file 'src/platforms/mirserver/mirserver.cpp'
--- src/platforms/mirserver/mirserver.cpp	2015-02-09 16:28:40 +0000
+++ src/platforms/mirserver/mirserver.cpp	2015-07-13 21:57:32 +0000
@@ -92,8 +92,7 @@
                 the_input_targeter(),
                 the_surface_coordinator(),
                 the_session_coordinator(),
-                the_prompt_session_manager(),
-                the_shell_display_layout());
+                the_prompt_session_manager());
 
             m_shell = shell;
             return shell;

=== modified file 'src/platforms/mirserver/mirshell.cpp'
--- src/platforms/mirserver/mirshell.cpp	2015-05-13 09:40:03 +0000
+++ src/platforms/mirserver/mirshell.cpp	2015-07-13 21:57:32 +0000
@@ -71,37 +71,42 @@
     const std::shared_ptr<mir::shell::InputTargeter> &inputTargeter,
     const std::shared_ptr<mir::scene::SurfaceCoordinator> &surfaceCoordinator,
     const std::shared_ptr<mir::scene::SessionCoordinator> &sessionCoordinator,
-    const std::shared_ptr<mir::scene::PromptSessionManager> &promptSessionManager,
-    const std::shared_ptr<mir::shell::DisplayLayout> &displayLayout) :
+    const std::shared_ptr<mir::scene::PromptSessionManager> &promptSessionManager) :
     AbstractShell(inputTargeter, surfaceCoordinator, sessionCoordinator, promptSessionManager,
-        [](mir::shell::FocusController*) { return std::make_shared<NullWindowManager>(); }),
-    m_displayLayout{displayLayout}
+        [](mir::shell::FocusController*) { return std::make_shared<NullWindowManager>(); })
 {
     qCDebug(QTMIR_MIR_MESSAGES) << "MirShell::MirShell";
 }
 
-mir::frontend::SurfaceId MirShell::create_surface(const std::shared_ptr<ms::Session> &session, const ms::SurfaceCreationParameters &requestParameters)
+mir::frontend::SurfaceId MirShell::create_surface(const std::shared_ptr<ms::Session> &session,
+                                                  const ms::SurfaceCreationParameters &requestParameters)
 {
+    using namespace mir::geometry;
+    using namespace qtmir;
     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.
-
-     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;
-
-     qCDebug(QTMIR_MIR_MESSAGES) << "MirShell::create_surface(): size requested ("
-         << requestParameters.size.width.as_int() << "," << requestParameters.size.height.as_int() << ") and placed ("
-         << placedParameters.size.width.as_int() << "," << placedParameters.size.height.as_int() << ")";
-
-     tracepoint(qtmirserver, surfacePlacementEnd);
-
-     return AbstractShell::create_surface(session, placedParameters);
+    SurfaceParameters params;
+    params.geometry.setWidth(requestParameters.size.width.as_int());
+    params.geometry.setHeight(requestParameters.size.height.as_int());
+    if (requestParameters.state.is_set()) {
+        params.state = static_cast<Globals::SurfaceState>(requestParameters.state.value());
+    } else {
+        params.state = Globals::SurfaceState::Unknown;
+    }
+
+    Q_EMIT sessionAboutToCreateSurface(session, params); // can be connected to via Qt::BlockingQueuedConnection
+                                                         // to alter surface initial geometry and state
+
+    ms::SurfaceCreationParameters placedParameters = requestParameters;
+    placedParameters.size = Size{ Width{params.geometry.width()}, Height{params.geometry.height()} };
+
+    qCDebug(QTMIR_MIR_MESSAGES) << "MirPlacementStrategy: requested ("
+        << requestParameters.size.width.as_int() << "," << requestParameters.size.height.as_int() << ") and returned ("
+        << placedParameters.size.width.as_int() << "," << placedParameters.size.height.as_int() << ")";
+
+    tracepoint(qtmirserver, surfacePlacementEnd);
+
+    return AbstractShell::create_surface(session, placedParameters);
 }
 
 void NullWindowManager::add_session(std::shared_ptr<ms::Session> const& /*session*/)

=== modified file 'src/platforms/mirserver/mirshell.h'
--- src/platforms/mirserver/mirshell.h	2015-03-11 10:10:49 +0000
+++ src/platforms/mirserver/mirshell.h	2015-07-13 21:57:32 +0000
@@ -17,14 +17,15 @@
 #ifndef QPAMIRSERVER_SHELL_H
 #define QPAMIRSERVER_SHELL_H
 
+// Mir
 #include <mir/shell/abstract_shell.h>
+
+// Qt
 #include <QObject>
 
-namespace mir {
-    namespace shell {
-        class DisplayLayout;
-    }
-}
+// local
+#include "globals.h"
+
 
 class MirShell : public QObject, public mir::shell::AbstractShell
 {
@@ -35,13 +36,16 @@
         const std::shared_ptr<mir::shell::InputTargeter> &inputTargeter,
         const std::shared_ptr<mir::scene::SurfaceCoordinator> &surfaceCoordinator,
         const std::shared_ptr<mir::scene::SessionCoordinator> &sessionCoordinator,
-        const std::shared_ptr<mir::scene::PromptSessionManager> &promptSessionManager,
-        const std::shared_ptr<mir::shell::DisplayLayout> &displayLayout);
-
-    virtual mir::frontend::SurfaceId create_surface(const std::shared_ptr<mir::scene::Session>& session, const mir::scene::SurfaceCreationParameters &params);
-
-private:
-    std::shared_ptr<mir::shell::DisplayLayout> const m_displayLayout;
+        const std::shared_ptr<mir::scene::PromptSessionManager> &promptSessionManager);
+
+    virtual mir::frontend::SurfaceId create_surface(const std::shared_ptr<mir::scene::Session> &session,
+                                                    const mir::scene::SurfaceCreationParameters &params);
+
+Q_SIGNALS:
+    void sessionAboutToCreateSurface(const std::shared_ptr<mir::scene::Session> &session,
+                                     qtmir::SurfaceParameters &params); // requires Qt::BlockingQueuedConnection!!
+
+    void surfaceAttributeChanged(mir::scene::Surface const*, const MirSurfaceAttrib, const int);
 };
 
 #endif /* QPAMIRSERVER_SHELL_H */

=== modified file 'tests/modules/Application/CMakeLists.txt'
--- tests/modules/Application/CMakeLists.txt	2015-05-21 18:48:59 +0000
+++ tests/modules/Application/CMakeLists.txt	2015-07-13 21:57:32 +0000
@@ -1,9 +1,12 @@
 set(
   APPLICATION_TEST_SOURCES
   application_test.cpp
+  ${CMAKE_SOURCE_DIR}/tests/modules/common/qtmir_test.cpp
 )
 
 include_directories(
+  ${APPLICATION_API_INCLUDE_DIRS}
+  ${CMAKE_SOURCE_DIR}/src/common
   ${CMAKE_SOURCE_DIR}/src/platforms/mirserver
   ${CMAKE_SOURCE_DIR}/src/modules
   ${CMAKE_SOURCE_DIR}/tests/modules/common
@@ -18,6 +21,8 @@
   unityapplicationplugin
   qpa-mirserver
 
+  Qt5::Test
+
   ${GTEST_BOTH_LIBRARIES}
   ${GMOCK_LIBRARIES}
 )

=== modified file 'tests/modules/Application/application_test.cpp'
--- tests/modules/Application/application_test.cpp	2015-03-04 22:13:06 +0000
+++ tests/modules/Application/application_test.cpp	2015-07-13 21:57:32 +0000
@@ -20,6 +20,10 @@
 
 #include "qtmir_test.h"
 
+#include <mock_session.h>
+
+#include <QScopedPointer>
+#include <QSignalSpy>
 
 using namespace qtmir;
 
@@ -30,93 +34,163 @@
     {}
 };
 
-TEST_F(ApplicationTests, checkFocusAcquiresWakeLock)
-{
-    using namespace ::testing;
-
-    EXPECT_CALL(sharedWakelock, acquire(_)).Times(1);
-
-    startApplication(123, "app");
-    applicationManager.focusApplication("app");
-}
-
-TEST_F(ApplicationTests, checkSuspendReleasesWakeLock)
-{
-    using namespace ::testing;
-
-    auto app = startApplication(123, "app");
-    auto session = app->session();
-
-    applicationManager.focusApplication("app");
-
-    Q_EMIT session->suspended();
+TEST_F(ApplicationTests, acquiresWakelockWhenRunningAndReleasesWhenSuspended)
+{
+    using namespace ::testing;
+    QString appId("foo-app");
+
+    auto desktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*desktopFileReader, loaded()).WillByDefault(Return(true));
+
+    QScopedPointer<Application> application(new Application(
+            QSharedPointer<MockSharedWakelock>(&sharedWakelock, [](MockSharedWakelock *){}),
+            desktopFileReader, QStringList(), nullptr));
+
+    application->setProcessState(Application::ProcessRunning);
+
+    NiceMock<MockSession> *session = new NiceMock<MockSession>;
+
+    EXPECT_CALL(*session, setApplication(_));
+    EXPECT_CALL(*session, fullscreen()).WillRepeatedly(Return(false));
+
+    application->setSession(session);
+
+    ASSERT_EQ(Application::InternalState::Starting, application->internalState());
+
+    session->setState(SessionInterface::Running);
+
+    EXPECT_TRUE(sharedWakelock.enabled());
+
+    ASSERT_EQ(Application::InternalState::Running, application->internalState());
+
+    application->setRequestedState(Application::RequestedSuspended);
+
+    ASSERT_EQ(SessionInterface::Suspending, session->state());
+    ASSERT_EQ(Application::InternalState::SuspendingWaitSession, application->internalState());
+
+    session->setState(SessionInterface::Suspended);
+
+    ASSERT_EQ(Application::InternalState::SuspendingWaitProcess, application->internalState());
+
+    application->setProcessState(Application::ProcessSuspended);
+
+    ASSERT_EQ(Application::InternalState::Suspended, application->internalState());
+
     EXPECT_FALSE(sharedWakelock.enabled());
 }
 
 TEST_F(ApplicationTests, checkResumeAcquiresWakeLock)
 {
     using namespace ::testing;
-
-    EXPECT_CALL(sharedWakelock, acquire(_)).Times(1);
-
-    auto app = startApplication(123, "app");
-    auto session = app->session();
-
-    Q_EMIT session->resumed();
+    QString appId("foo-app");
+
+    auto desktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*desktopFileReader, loaded()).WillByDefault(Return(true));
+
+    QScopedPointer<Application> application(new Application(
+            QSharedPointer<MockSharedWakelock>(&sharedWakelock, [](MockSharedWakelock *){}),
+            desktopFileReader, QStringList(), nullptr));
+    NiceMock<MockSession> *session = new NiceMock<MockSession>;
+
+    // Get it running and then suspend it
+    application->setProcessState(Application::ProcessRunning);
+    application->setSession(session);
+    session->setState(SessionInterface::Running);
+    application->setRequestedState(Application::RequestedSuspended);
+    session->setState(SessionInterface::Suspended);
+    application->setProcessState(Application::ProcessSuspended);
+    ASSERT_EQ(Application::InternalState::Suspended, application->internalState());
+
+    EXPECT_FALSE(sharedWakelock.enabled());
+
+    application->setRequestedState(Application::RequestedRunning);
+
+    ASSERT_EQ(Application::InternalState::Running, application->internalState());
+
+    EXPECT_TRUE(sharedWakelock.enabled());
 }
 
 TEST_F(ApplicationTests, checkRespawnAcquiresWakeLock)
 {
     using namespace ::testing;
-
-    EXPECT_CALL(sharedWakelock, acquire(_)).Times(1);
-    const QString appId = "app";
-
-    auto app = startApplication(123, "app");
-
-    // as respawn fires startApplicationWithAppIdAndArgs again, keep gmock quiet about another call
-    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
-            .Times(1)
-            .WillRepeatedly(Return(true));
-
-    // respawn by setting app state as Stopped, delete the Session associated, then set to Running state
-    app->setState(Session::State::Stopped);
-    delete app->session();
-    app->setState(Session::State::Running);
-}
-
-TEST_F(ApplicationTests, checkDashFocusDoesNotAcquireWakeLock)
-{
-    using namespace ::testing;
-
-    EXPECT_CALL(sharedWakelock, acquire(_)).Times(0);
-
-    startApplication(123, "unity8-dash");
-    applicationManager.focusApplication("unity8-dash");
-}
-
-TEST_F(ApplicationTests, checkDashSuspendDoesNotImpactWakeLock)
-{
-    using namespace ::testing;
-
-    auto app = startApplication(123, "unity8-dash");
-    auto session = app->session();
-
-    applicationManager.focusApplication("unity8-dash");
-
-    Q_EMIT session->suspended();
+    QString appId("foo-app");
+
+    auto desktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*desktopFileReader, loaded()).WillByDefault(Return(true));
+
+    QScopedPointer<Application> application(new Application(
+            QSharedPointer<MockSharedWakelock>(&sharedWakelock, [](MockSharedWakelock *){}),
+            desktopFileReader, QStringList(), nullptr));
+    NiceMock<MockSession> *session = new NiceMock<MockSession>;
+
+    // Get it running, suspend it, and finally stop it
+    application->setProcessState(Application::ProcessRunning);
+    application->setSession(session);
+    session->setState(SessionInterface::Running);
+    application->setRequestedState(Application::RequestedSuspended);
+    session->setState(SessionInterface::Suspended);
+    application->setProcessState(Application::ProcessSuspended);
+    ASSERT_EQ(Application::InternalState::Suspended, application->internalState());
+    session->setState(SessionInterface::Stopped);
+    application->setProcessState(Application::ProcessStopped);
+    ASSERT_EQ(Application::InternalState::StoppedUnexpectedly, application->internalState());
+
     EXPECT_FALSE(sharedWakelock.enabled());
+
+    QSignalSpy spyStartProcess(application.data(), SIGNAL(startProcessRequested()));
+    application->setRequestedState(Application::RequestedRunning);
+    ASSERT_EQ(1, spyStartProcess.count());
+    application->setProcessState(Application::ProcessRunning);
+
+    ASSERT_EQ(Application::InternalState::Starting, application->internalState());
+
+    EXPECT_TRUE(sharedWakelock.enabled());
 }
 
-TEST_F(ApplicationTests, checkDashResumeDoesNotAcquireWakeLock)
+TEST_F(ApplicationTests, checkDashDoesNotImpactWakeLock)
 {
     using namespace ::testing;
+    QString appId("unity8-dash");
 
     EXPECT_CALL(sharedWakelock, acquire(_)).Times(0);
-
-    auto app = startApplication(123, "unity8-dash");
-    auto session = app->session();
-
-    Q_EMIT session->resumed();
+    EXPECT_CALL(sharedWakelock, release(_)).Times(0);
+
+    auto desktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*desktopFileReader, loaded()).WillByDefault(Return(true));
+
+    QScopedPointer<Application> application(new Application(
+            QSharedPointer<MockSharedWakelock>(&sharedWakelock, [](MockSharedWakelock *){}),
+            desktopFileReader, QStringList(), nullptr));
+
+    application->setProcessState(Application::ProcessRunning);
+
+    NiceMock<MockSession> *session = new NiceMock<MockSession>;
+
+    EXPECT_CALL(*session, setApplication(_));
+    EXPECT_CALL(*session, fullscreen()).WillRepeatedly(Return(false));
+
+    application->setSession(session);
+
+    ASSERT_EQ(Application::InternalState::Starting, application->internalState());
+
+    session->setState(SessionInterface::Running);
+
+    ASSERT_EQ(Application::InternalState::Running, application->internalState());
+
+    application->setRequestedState(Application::RequestedSuspended);
+
+    ASSERT_EQ(SessionInterface::Suspending, session->state());
+    ASSERT_EQ(Application::InternalState::SuspendingWaitSession, application->internalState());
+
+    session->setState(SessionInterface::Suspended);
+
+    ASSERT_EQ(Application::InternalState::SuspendingWaitProcess, application->internalState());
+
+    application->setProcessState(Application::ProcessSuspended);
+
+    ASSERT_EQ(Application::InternalState::Suspended, application->internalState());
+
+    application->setRequestedState(Application::RequestedRunning);
+
+    ASSERT_EQ(Application::InternalState::Running, application->internalState());
 }
-

=== modified file 'tests/modules/ApplicationManager/CMakeLists.txt'
--- tests/modules/ApplicationManager/CMakeLists.txt	2015-05-21 18:48:59 +0000
+++ tests/modules/ApplicationManager/CMakeLists.txt	2015-07-13 21:57:32 +0000
@@ -2,9 +2,13 @@
   APPLICATION_MANAGER_TEST_SOURCES
   application_manager_test.cpp
   ${CMAKE_SOURCE_DIR}/src/common/debughelpers.cpp
+  ${CMAKE_SOURCE_DIR}/tests/modules/common/qtmir_test.cpp
+  ../common/fake_mirsurfaceitem.h
 )
 
 include_directories(
+  ${APPLICATION_API_INCLUDE_DIRS}
+  ${CMAKE_SOURCE_DIR}/src/common
   ${CMAKE_SOURCE_DIR}/src/platforms/mirserver
   ${CMAKE_SOURCE_DIR}/src/modules
   ${CMAKE_SOURCE_DIR}/tests/modules/common
@@ -15,7 +19,7 @@
 
 target_link_libraries(
   applicationmanager_test
-  
+
   qpa-mirserver
   unityapplicationplugin
 

=== modified file 'tests/modules/ApplicationManager/application_manager_test.cpp'
--- tests/modules/ApplicationManager/application_manager_test.cpp	2015-05-13 17:18:45 +0000
+++ tests/modules/ApplicationManager/application_manager_test.cpp	2015-07-13 21:57:32 +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
@@ -23,8 +23,9 @@
 
 #include <Unity/Application/applicationscreenshotprovider.h>
 
- #include "mock_surface.h"
- #include "qtmir_test.h"
+#include "fake_mirsurfaceitem.h"
+#include "mock_surface.h"
+#include "qtmir_test.h"
 
 using namespace qtmir;
 using mir::scene::MockSession;
@@ -45,100 +46,41 @@
         applicationManager.onSessionStopping(session);
         sessionManager.onSessionStopping(session);
     }
+    inline void onSessionCreatedSurface(const mir::scene::Session *mirSession,
+            MirSurfaceItemInterface *qmlSurface) {
+
+        SessionInterface* qmlSession = sessionManager.findSession(mirSession);
+        if (qmlSession) {
+            qmlSession->setSurface(qmlSurface);
+        }
+
+        // I assume that applicationManager ignores the mirSurface parameter, so sending
+        // a null shared pointer must suffice
+        std::shared_ptr<mir::scene::Surface> mirSurface(nullptr);
+        applicationManager.onSessionCreatedSurface(mirSession, mirSurface);
+    }
+
+    inline void suspend(Application *application) {
+        application->setRequestedState(Application::RequestedSuspended);
+        ASSERT_EQ(Application::InternalState::SuspendingWaitSession, application->internalState());
+        static_cast<qtmir::Session*>(application->session())->doSuspend();
+        ASSERT_EQ(Application::InternalState::SuspendingWaitProcess, application->internalState());
+        applicationManager.onProcessSuspended(application->appId());
+        ASSERT_EQ(Application::InternalState::Suspended, application->internalState());
+    }
 };
 
-TEST_F(ApplicationManagerTests, SuspendingAndResumingARunningApplicationResultsInOomScoreAdjustment)
-{
-    using namespace ::testing;
-
-    const QString appId("com.canonical.does.not.exist");
-
-    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(_, _)).Times(1);
-    EXPECT_CALL(appController, findDesktopFileForAppId(appId)).Times(1);
-
-    EXPECT_CALL(desktopFileReaderFactory, createInstance(_, _)).Times(1);
-
-    auto application = applicationManager.startApplication(
-                appId,
-                ApplicationManager::NoFlag,
-                QStringList());
-
-    // FIXME - this is doesn't really excerise the actualt behaviour since suspend/resume should be
-    // controlled by state changes. Requires using suspend timer.
-    QMetaObject::invokeMethod(application, "onSessionSuspended");
-    QMetaObject::invokeMethod(application, "onSessionResumed");
-}
-
-TEST_F(ApplicationManagerTests, SuspendingAndResumingDashResultsInOomScoreAdjustment)
-{
-    using namespace ::testing;
-
-    quint64 procId = 5921;
-    std::shared_ptr<mir::scene::Surface> aSurface(nullptr);
-    QByteArray cmdLine( "/usr/bin/app1 --desktop_file_hint=unity8-dash");
-
-    EXPECT_CALL(procInfo,command_line(procId))
-        .Times(1)
-        .WillOnce(Return(cmdLine));
-
-    ON_CALL(appController,appIdHasProcessId(_,_)).WillByDefault(Return(false));
-
-    bool authed = true;
-
-    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("Oo", procId);
-    applicationManager.authorizeSession(procId, authed);
-    onSessionStarting(session);
-
-    auto application = applicationManager.findApplication("unity8-dash");
-    applicationManager.onSessionCreatedSurface(session.get(), aSurface);
-
-    // FIXME - this is doesn't really excerise the actualt behaviour since suspend/resume should be
-    // controlled by state changes. Requires using suspend timer.
-    QMetaObject::invokeMethod(application, "onSessionSuspended");
-    QMetaObject::invokeMethod(application, "onSessionResumed");
-}
-
-// Currently disabled as we need to make sure that we have a corresponding mir session, too.
-TEST_F(ApplicationManagerTests, DISABLED_FocusingRunningApplicationResultsInOomScoreAdjustment)
-{
-    using namespace ::testing;
-
-    const QString appId("com.canonical.does.not.exist");
-
-    QSet<QString> appIds;
-
-    for (unsigned int i = 0; i < 50; i++)
-    {
-        QString appIdFormat("%1.does.not.exist");
-        auto appId = appIdFormat.arg(i);
-
-        auto application = applicationManager.startApplication(
-                    appId,
-                    ApplicationManager::NoFlag,
-                    QStringList());
-
-        std::shared_ptr<mir::scene::Session> mirSession = std::make_shared<MockSession>(appIdFormat.toStdString(), i);
-        onSessionStarting( mirSession );
-
-        EXPECT_NE(nullptr, application);
-    }
-
-    for (auto appId : appIds)
-    {
-        applicationManager.focusApplication(appId);
-    }
-}
-
 TEST_F(ApplicationManagerTests,bug_case_1240400_second_dialer_app_fails_to_authorize_and_gets_mixed_up_with_first_one)
 {
     using namespace ::testing;
-    std::shared_ptr<mir::scene::Surface> aSurface(nullptr);
     quint64 firstProcId = 5921;
     quint64 secondProcId = 5922;
     const char dialer_app_id[] = "dialer-app";
     QByteArray cmdLine( "/usr/bin/dialer-app --desktop_file_hint=dialer-app");
     QByteArray secondcmdLine( "/usr/bin/dialer-app");
 
+    FakeMirSurfaceItem *surface = new FakeMirSurfaceItem;
+
     EXPECT_CALL(procInfo,command_line(firstProcId))
         .Times(1)
         .WillOnce(Return(cmdLine));
@@ -150,18 +92,20 @@
 
     std::shared_ptr<mir::scene::Session> mirSession = std::make_shared<MockSession>(dialer_app_id, firstProcId);
     applicationManager.authorizeSession(firstProcId, authed);
-    EXPECT_EQ(true, authed);
+    ASSERT_EQ(true, authed);
     onSessionStarting(mirSession);
-    applicationManager.onSessionCreatedSurface(mirSession.get(),aSurface);
-    Application * app = applicationManager.findApplication(dialer_app_id);
-    EXPECT_NE(nullptr,app);
+    onSessionCreatedSurface(mirSession.get(), surface);
+    surface->drawFirstFrame();
+    Application * application = applicationManager.findApplication(dialer_app_id);
+    ASSERT_NE(nullptr,application);
+    ASSERT_EQ(Application::InternalState::Running, application->internalState());
 
     // now a second session without desktop file is launched:
     applicationManager.authorizeSession(secondProcId, authed);
     applicationManager.onProcessStarting(dialer_app_id);
 
     EXPECT_FALSE(authed);
-    EXPECT_EQ(app,applicationManager.findApplication(dialer_app_id));
+    EXPECT_EQ(application, applicationManager.findApplication(dialer_app_id));
 }
 
 TEST_F(ApplicationManagerTests,application_dies_while_starting)
@@ -182,6 +126,7 @@
     onSessionStarting(mirSession);
     Application * beforeFailure = applicationManager.findApplication(app_id);
     applicationManager.onProcessStarting(app_id);
+    onSessionStopping(mirSession);
     applicationManager.onProcessFailed(app_id, true);
     Application * afterFailure = applicationManager.findApplication(app_id);
 
@@ -190,34 +135,6 @@
     EXPECT_EQ(nullptr, afterFailure);
 }
 
-TEST_F(ApplicationManagerTests,application_start_failure_after_starting)
-{
-    using namespace ::testing;
-    quint64 procId = 5921;
-    std::shared_ptr<mir::scene::Surface> aSurface(nullptr);
-    const char app_id[] = "my-app";
-    QByteArray cmdLine( "/usr/bin/my-app --desktop_file_hint=my-app");
-
-    EXPECT_CALL(procInfo,command_line(procId))
-        .Times(1)
-        .WillOnce(Return(cmdLine));
-
-    bool authed = true;
-
-    std::shared_ptr<mir::scene::Session> mirSession = std::make_shared<MockSession>(app_id, procId);
-    applicationManager.authorizeSession(procId, authed);
-    onSessionStarting(mirSession);
-    Application * beforeFailure = applicationManager.findApplication(app_id);
-    applicationManager.onSessionCreatedSurface(mirSession.get(), aSurface);
-    applicationManager.onProcessStarting(app_id);
-    applicationManager.onProcessFailed(app_id, false);
-    Application * afterFailure = applicationManager.findApplication(app_id);
-
-    EXPECT_EQ(true, authed);
-    EXPECT_NE(nullptr, beforeFailure);
-    EXPECT_EQ(beforeFailure, afterFailure);
-}
-
 TEST_F(ApplicationManagerTests,startApplicationSupportsShortAppId)
 {
     using namespace ::testing;
@@ -400,7 +317,7 @@
     quint64 a_procId = 5921;
     const char an_app_id[] = "some_app";
     QByteArray a_cmd( "/usr/bin/app1 --desktop_file_hint=some_app");
-    std::shared_ptr<mir::scene::Surface> aSurface(nullptr);
+    FakeMirSurfaceItem *aSurface = new FakeMirSurfaceItem;
 
     ON_CALL(procInfo,command_line(_)).WillByDefault(Return(a_cmd));
 
@@ -413,8 +330,8 @@
     applicationManager.authorizeSession(a_procId, authed);
 
     onSessionStarting(first_session);
-    applicationManager.focusApplication(an_app_id);
-    applicationManager.onSessionCreatedSurface(first_session.get(), aSurface);
+    onSessionCreatedSurface(first_session.get(), aSurface);
+    aSurface->drawFirstFrame();
     onSessionStarting(second_session);
 
     Application * the_app = applicationManager.findApplication(an_app_id);
@@ -430,211 +347,62 @@
     quint64 a_procId = 5921;
     const char an_app_id[] = "some_app";
     QByteArray a_cmd("/usr/bin/app1 --desktop_file_hint=some_app");
-    std::shared_ptr<mir::scene::Surface> aSurface(nullptr);
+    FakeMirSurfaceItem *aSurface = new FakeMirSurfaceItem;
 
     ON_CALL(procInfo, command_line(_)).WillByDefault(Return(a_cmd));
     ON_CALL(appController, appIdHasProcessId(_,_)).WillByDefault(Return(false));
-    
+
     bool authed = true;
 
     std::shared_ptr<mir::scene::Session> a_session = std::make_shared<MockSession>("Oo", a_procId);
-   
+
     applicationManager.authorizeSession(a_procId, authed);
     onSessionStarting(a_session);
-    applicationManager.onSessionCreatedSurface(a_session.get(), aSurface);
-
-    Application * the_app = applicationManager.findApplication(an_app_id);
-    applicationManager.focusApplication(an_app_id);
-
-    EXPECT_EQ(Application::Running, the_app->state());
-    EXPECT_EQ(true, the_app->focused());
-
-    applicationManager.focusApplication(an_app_id);
-    EXPECT_EQ(true, the_app->focused());
-}
-
-TEST_F(ApplicationManagerTests,suspended_suspends_focused_app_and_marks_it_unfocused_in_the_model)
-{
-    using namespace ::testing;
-    quint64 a_procId = 5921;
-    const char an_app_id[] = "some_app";
-    QByteArray a_cmd( "/usr/bin/app1 --desktop_file_hint=some_app");
-    std::shared_ptr<mir::scene::Surface> aSurface(nullptr);
-
-    ON_CALL(procInfo,command_line(_)).WillByDefault(Return(a_cmd));
-
-    ON_CALL(appController,appIdHasProcessId(_,_)).WillByDefault(Return(false));
-
-    bool authed = true;
-
-    std::shared_ptr<mir::scene::Session> first_session = std::make_shared<MockSession>("Oo", a_procId);
-    std::shared_ptr<mir::scene::Session> second_session = std::make_shared<MockSession>("oO", a_procId);
-    applicationManager.authorizeSession(a_procId, authed);
-
-    onSessionStarting(first_session);
-    applicationManager.onSessionCreatedSurface(first_session.get(), aSurface);
-    onSessionStarting(second_session);
-
-    Application * the_app = applicationManager.findApplication(an_app_id);
-    applicationManager.focusApplication(an_app_id);
-
-    EXPECT_EQ(Application::Running, the_app->state());
-
-    applicationManager.setSuspended(true);
-
-    EXPECT_EQ(Application::Suspended, the_app->state());
-    EXPECT_FALSE(the_app->focused());
-
-    applicationManager.setSuspended(false);
-
-    EXPECT_EQ(Application::Running, the_app->state());
-    EXPECT_EQ(true, the_app->focused());
-}
-
-TEST_F(ApplicationManagerTests,suspended_suspends_starting_app_when_it_gets_ready)
-{
-    using namespace ::testing;
-    quint64 a_procId = 5921;
-    const char an_app_id[] = "some_app";
-    QByteArray a_cmd( "/usr/bin/app1 --desktop_file_hint=some_app");
-    std::shared_ptr<mir::scene::Surface> aSurface(nullptr);
-
-    ON_CALL(procInfo,command_line(_)).WillByDefault(Return(a_cmd));
-
-    ON_CALL(appController,appIdHasProcessId(_,_)).WillByDefault(Return(false));
-
-    bool authed = true;
-
-    std::shared_ptr<mir::scene::Session> first_session = std::make_shared<MockSession>("Oo", a_procId);
-    applicationManager.authorizeSession(a_procId, authed);
-
-    onSessionStarting(first_session);
-
-    Application * the_app = applicationManager.findApplication(an_app_id);
-    applicationManager.focusApplication(an_app_id);
-    EXPECT_EQ(Application::Starting, the_app->state());
-
-    applicationManager.setSuspended(true);
-
-    // Not suspending yet, as it's still starting
-    EXPECT_EQ(Application::Starting, the_app->state());
-
-    // This signals the app is ready now
-    applicationManager.onSessionCreatedSurface(first_session.get(), aSurface);
-
-    // And given that the AppManager is suspended now, this should go to suspended too
-    EXPECT_EQ(Application::Suspended, the_app->state());
-    EXPECT_FALSE(the_app->focused());
-
-    applicationManager.setSuspended(false);
-
-    EXPECT_EQ(Application::Running, the_app->state());
-    EXPECT_EQ(true, the_app->focused());
-}
-
-TEST_F(ApplicationManagerTests,focus_change_suspends_starting_app_when_it_gets_ready)
-{
-    using namespace ::testing;
-    quint64 first_procId = 5921;
-    quint64 second_procId = 5922;
-    std::shared_ptr<mir::scene::Surface> aSurface(nullptr);
-    QByteArray first_cmdLine( "/usr/bin/app1 --desktop_file_hint=app1");
-    QByteArray second_cmdLine( "/usr/bin/app2--desktop_file_hint=app2");
-
-    EXPECT_CALL(procInfo,command_line(first_procId))
-        .Times(1)
-        .WillOnce(Return(first_cmdLine));
-
-    ON_CALL(appController,appIdHasProcessId(_,_)).WillByDefault(Return(false));
-
-    EXPECT_CALL(procInfo,command_line(second_procId))
-        .Times(1)
-        .WillOnce(Return(second_cmdLine));
-
-    bool authed = true;
-
-    std::shared_ptr<mir::scene::Session> first_session = std::make_shared<MockSession>("Oo", first_procId);
-    std::shared_ptr<mir::scene::Session> second_session = std::make_shared<MockSession>("oO", second_procId);
-    applicationManager.authorizeSession(first_procId, authed);
-    applicationManager.authorizeSession(second_procId, authed);
-    onSessionStarting(first_session);
-
-    Application * app1 = applicationManager.findApplication("app1");
-    applicationManager.focusApplication("app1");
+    onSessionCreatedSurface(a_session.get(), aSurface);
+    aSurface->drawFirstFrame();
+
+    Application * the_app = applicationManager.findApplication(an_app_id);
+    applicationManager.focusApplication(an_app_id);
+
+    EXPECT_EQ(Application::Running, the_app->state());
+    EXPECT_EQ(true, the_app->focused());
+
+    applicationManager.focusApplication(an_app_id);
+    EXPECT_EQ(true, the_app->focused());
+}
+
+TEST_F(ApplicationManagerTests,starting_app_is_suspended_when_it_gets_ready_if_requested)
+{
+    using namespace ::testing;
+    quint64 procId = 5921;
+    FakeMirSurfaceItem *aSurface = new FakeMirSurfaceItem;
+    QByteArray cmdLine( "/usr/bin/app --desktop_file_hint=app");
+
+    EXPECT_CALL(procInfo,command_line(procId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    ON_CALL(appController,appIdHasProcessId(_,_)).WillByDefault(Return(false));
+
+    bool authed = true;
+
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("Oo", procId);
+    applicationManager.authorizeSession(procId, authed);
+    onSessionStarting(session);
+
+    Application * app = applicationManager.findApplication("app");
+    app->setRequestedState(Application::RequestedSuspended);
 
     // First app starting...
-    EXPECT_EQ(Application::Starting, app1->state());
-
-    onSessionStarting(second_session);
-    Application * app2 = applicationManager.findApplication("app2");
-    applicationManager.focusApplication("app2");
-
-    // Second app starting...
-    EXPECT_EQ(Application::Starting, app2->state());
-
-    // Make sure first one is still in starting state
-    EXPECT_EQ(Application::Starting, app1->state());
-
-    // Signal app1 is ready now
-    applicationManager.onSessionCreatedSurface(first_session.get(), aSurface);
-
-    // Make sure AppMan suspended it now that its ready
-    EXPECT_EQ(Application::Suspended, app1->state());
-}
-
-TEST_F(ApplicationManagerTests,forceDashActive_activates_dash_while_not_focused)
-{
-    using namespace ::testing;
-    quint64 first_procId = 5921;
-    quint64 second_procId = 5922;
-    std::shared_ptr<mir::scene::Surface> aSurface(nullptr);
-    QByteArray first_cmdLine( "/usr/bin/app1 --desktop_file_hint=unity8-dash");
-    QByteArray second_cmdLine( "/usr/bin/app2--desktop_file_hint=app2");
-
-    EXPECT_CALL(procInfo,command_line(first_procId))
-        .Times(1)
-        .WillOnce(Return(first_cmdLine));
-
-    ON_CALL(appController,appIdHasProcessId(_,_)).WillByDefault(Return(false));
-
-    EXPECT_CALL(procInfo,command_line(second_procId))
-        .Times(1)
-        .WillOnce(Return(second_cmdLine));
-
-    bool authed = true;
-
-    std::shared_ptr<mir::scene::Session> first_session = std::make_shared<MockSession>("Oo", first_procId);
-    std::shared_ptr<mir::scene::Session> second_session = std::make_shared<MockSession>("oO", second_procId);
-    applicationManager.authorizeSession(first_procId, authed);
-    applicationManager.authorizeSession(second_procId, authed);
-    onSessionStarting(first_session);
-
-    Application * dashApp = applicationManager.findApplication("unity8-dash");
-    applicationManager.onSessionCreatedSurface(first_session.get(), aSurface);
-    applicationManager.focusApplication("unity8-dash");
-
-    // Dash app should be ready now...
-    EXPECT_EQ(Application::Running, dashApp->state());
-
-    // Launch second app
-    onSessionStarting(second_session);
-    applicationManager.onSessionCreatedSurface(second_session.get(), aSurface);
-    applicationManager.focusApplication("app2");
-    EXPECT_EQ(applicationManager.focusedApplicationId(), "app2");
-
-    // Make sure the dash is suspended
-    EXPECT_EQ(dashApp->state(), Application::Suspended);
-
-    // Now set the dashactive flag
-    applicationManager.setForceDashActive(true);
-
-    // And make sure the dash is woken up but not focused
-    EXPECT_EQ(applicationManager.focusedApplicationId(), "app2");
-    EXPECT_EQ(dashApp->state(), Application::Running);
-
-    // Unset the dashactive flag
-    applicationManager.setForceDashActive(false);
-    EXPECT_EQ(dashApp->state(), Application::Suspended);
+    EXPECT_EQ(Application::Starting, app->state());
+
+    // Signal app is ready now
+    applicationManager.onProcessStarting("app");
+    onSessionCreatedSurface(session.get(), aSurface);
+    aSurface->drawFirstFrame();
+
+    // now that its ready, suspend process should have begun
+    EXPECT_EQ(Application::InternalState::SuspendingWaitSession, app->internalState());
 }
 
 TEST_F(ApplicationManagerTests,requestFocusApplication)
@@ -713,20 +481,20 @@
     Application *theApp = applicationManager.startApplication(appId, ApplicationManager::NoFlag);
 
     // check application data
-    EXPECT_EQ(theApp->state(), Application::Starting);
-    EXPECT_EQ(theApp->appId(), appId);
-    EXPECT_EQ(theApp->name(), name);
-    EXPECT_EQ(theApp->canBeResumed(), true);
+    EXPECT_EQ(Application::Starting, theApp->state());
+    EXPECT_EQ(appId, theApp->appId());
+    EXPECT_EQ(name, theApp->name());
+    EXPECT_FALSE(theApp->canBeResumed());
 
     // check signals were emitted
-    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
-    EXPECT_EQ(applicationManager.count(), 1);
-    EXPECT_EQ(addedSpy.count(), 1);
-    EXPECT_EQ(addedSpy.takeFirst().at(0).toString(), appId);
+    EXPECT_EQ(2, countSpy.count()); //FIXME(greyback)
+    EXPECT_EQ(1, applicationManager.count());
+    EXPECT_EQ(1, addedSpy.count());
+    EXPECT_EQ(appId, addedSpy.takeFirst().at(0).toString());
 
     // check application in list of apps
     Application *theAppAgain = applicationManager.findApplication(appId);
-    EXPECT_EQ(theAppAgain, theApp);
+    EXPECT_EQ(theApp, theAppAgain);
 }
 
 /*
@@ -757,18 +525,18 @@
     Application *theApp = applicationManager.findApplication(appId);
 
     // check application data
-    EXPECT_EQ(theApp->state(), Application::Starting);
-    EXPECT_EQ(theApp->appId(), appId);
-    EXPECT_EQ(theApp->name(), name);
-    EXPECT_EQ(theApp->canBeResumed(), true);
+    EXPECT_EQ(Application::Starting, theApp->state());
+    EXPECT_EQ(appId, theApp->appId());
+    EXPECT_EQ(name, theApp->name());
+    EXPECT_EQ(true, theApp->canBeResumed());
 
     // check signals were emitted
-    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
-    EXPECT_EQ(applicationManager.count(), 1);
-    EXPECT_EQ(addedSpy.count(), 1);
-    EXPECT_EQ(addedSpy.takeFirst().at(0).toString(), appId);
-    EXPECT_EQ(focusSpy.count(), 1);
-    EXPECT_EQ(focusSpy.takeFirst().at(0).toString(), appId);
+    EXPECT_EQ(2, countSpy.count()); //FIXME(greyback)
+    EXPECT_EQ(1, applicationManager.count());
+    EXPECT_EQ(1, addedSpy.count());
+    EXPECT_EQ(appId, addedSpy.takeFirst().at(0).toString());
+    EXPECT_EQ(1, focusSpy.count());
+    EXPECT_EQ(appId, focusSpy.takeFirst().at(0).toString());
 }
 
 /*
@@ -1067,7 +835,6 @@
 
     applicationManager.startApplication(appId, ApplicationManager::NoFlag);
     applicationManager.onProcessStarting(appId);
-    applicationManager.focusApplication(appId);
 
     std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
 
@@ -1075,9 +842,10 @@
     applicationManager.authorizeSession(procId, authed);
     onSessionStarting(session);
 
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    FakeMirSurfaceItem *surface = new FakeMirSurfaceItem;
 
-    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    onSessionCreatedSurface(session.get(), surface);
+    surface->drawFirstFrame();
 
     // Check application state is correctly set
     Application *theApp = applicationManager.findApplication(appId);
@@ -1124,7 +892,7 @@
 }
 
 /*
- * Test that the foreground application is stopped correctly (is in Running state, has surface)
+ * Test that a running application is stopped correctly (is in Running state, has surface)
  */
 TEST_F(ApplicationManagerTests,shellStopsForegroundAppCorrectly)
 {
@@ -1150,100 +918,61 @@
     applicationManager.authorizeSession(procId, authed);
     onSessionStarting(session);
 
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
-    applicationManager.onSessionCreatedSurface(session.get(), surface);
-    applicationManager.focusApplication(appId);
-    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
-
-    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
-    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
-
-    // Stop app
-    applicationManager.stopApplication(appId);
-
-    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
-    EXPECT_EQ(applicationManager.count(), 0);
-    EXPECT_EQ(removedSpy.count(), 1);
-    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
-}
-
-/*
- * Test that the background application is stopped correctly
- */
-TEST_F(ApplicationManagerTests,shellStopsBackgroundAppCorrectly)
-{
-    using namespace ::testing;
-    const QString appId("testAppId");
-    quint64 procId = 5551;
-
-    // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
-
-    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
-    applicationManager.onProcessStarting(appId);
-    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
-    bool authed = true;
-    applicationManager.authorizeSession(procId, authed);
-    onSessionStarting(session);
-
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
-    applicationManager.onSessionCreatedSurface(session.get(), surface);
-    applicationManager.unfocusCurrentApplication();
-
-    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
-
-    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
-    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
-
-    // Stop app
-    applicationManager.stopApplication(appId);
-
-    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
-    EXPECT_EQ(applicationManager.count(), 0);
-    EXPECT_EQ(removedSpy.count(), 1);
-    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
-}
-
-/*
- * Test that if an application is stopped by upstart, before it has created a surface, AppMan cleans up after it ok
- */
-TEST_F(ApplicationManagerTests,upstartNotificationOfStartingAppBeingStopped)
-{
-    using namespace ::testing;
-    const QString appId("testAppId");
-    quint64 procId = 5551;
-
-    // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
-
-    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
-    applicationManager.onProcessStarting(appId);
-    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
-    bool authed = true;
-    applicationManager.authorizeSession(procId, authed);
-    onSessionStarting(session);
-
-    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
-    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
-
-    // Upstart notifies of stopping app
-    applicationManager.onProcessStopped(appId);
+    FakeMirSurfaceItem *surface = new FakeMirSurfaceItem;
+    onSessionCreatedSurface(session.get(), surface);
+    surface->drawFirstFrame();
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Stop app
+    applicationManager.stopApplication(appId);
+
+    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
+    EXPECT_EQ(applicationManager.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 1);
+    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
+}
+
+/*
+ * Test that a suspended application is stopped correctly
+ */
+TEST_F(ApplicationManagerTests,shellStopsSuspendedAppCorrectly)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    quint64 procId = 5551;
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    Application *application = applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    onSessionStarting(session);
+    applicationManager.onProcessStarting(appId);
+
+    FakeMirSurfaceItem *surface = new FakeMirSurfaceItem;
+    onSessionCreatedSurface(session.get(), surface);
+    surface->drawFirstFrame();
+
+    suspend(application);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Stop app
+    applicationManager.stopApplication(appId);
 
     EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
     EXPECT_EQ(applicationManager.count(), 0);
@@ -1278,28 +1007,28 @@
     applicationManager.authorizeSession(procId, authed);
     onSessionStarting(session);
 
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
-    applicationManager.onSessionCreatedSurface(session.get(), surface);
-    applicationManager.focusApplication(appId);
-    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
+    FakeMirSurfaceItem *surface = new FakeMirSurfaceItem;
+    onSessionCreatedSurface(session.get(), surface);
+    surface->drawFirstFrame();
 
     QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
     QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
 
+    onSessionStopping(session);
     // Upstart notifies of stopping app
     applicationManager.onProcessStopped(appId);
 
-    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
-    EXPECT_EQ(applicationManager.count(), 0);
-    EXPECT_EQ(removedSpy.count(), 1);
-    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
+    EXPECT_EQ(2, countSpy.count()); //FIXME(greyback)
+    EXPECT_EQ(0, applicationManager.count());
+    EXPECT_EQ(1, removedSpy.count());
+    EXPECT_EQ(appId, removedSpy.takeFirst().at(0).toString());
 }
 
 /*
- * Test that if the foreground Running application is reported to unexpectedly stop by upstart, AppMan
- * cleans up after it ok (as was not in background, had not lifecycle saved its state, so cannot be resumed)
+ * Test that if a running application is reported to have stopped unexpectedly by upstart, AppMan
+ * cleans up after it ok (as was not suspended, had not lifecycle saved its state, so cannot be resumed)
  */
-TEST_F(ApplicationManagerTests,upstartNotifiesOfUnexpectedStopOfForegroundApp)
+TEST_F(ApplicationManagerTests,upstartNotifiesOfUnexpectedStopOfRunningApp)
 {
     using namespace ::testing;
     const QString appId("testAppId");
@@ -1323,14 +1052,15 @@
     applicationManager.authorizeSession(procId, authed);
     onSessionStarting(session);
 
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
-    applicationManager.onSessionCreatedSurface(session.get(), surface);
-    applicationManager.focusApplication(appId);
-    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
+    FakeMirSurfaceItem *surface = new FakeMirSurfaceItem;
+    onSessionCreatedSurface(session.get(), surface);
+    surface->drawFirstFrame();
 
     QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
     QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
 
+    onSessionStopping(session);
+
     // Upstart notifies of crashing / OOM killed app
     applicationManager.onProcessFailed(appId, false);
 
@@ -1344,53 +1074,6 @@
 }
 
 /*
- * Test that if a background application is stopped by upstart, AppMan removes it from the app list
- * as the event is a result of direct user interaction
- */
-TEST_F(ApplicationManagerTests,upstartNotifiesOfStoppingBackgroundApp)
-{
-    using namespace ::testing;
-    const QString appId("testAppId");
-    quint64 procId = 5551;
-
-    // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
-
-    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
-    applicationManager.onProcessStarting(appId);
-    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
-    bool authed = true;
-    applicationManager.authorizeSession(procId, authed);
-    onSessionStarting(session);
-
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
-    applicationManager.onSessionCreatedSurface(session.get(), surface);
-    applicationManager.unfocusCurrentApplication();
-    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
-
-    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
-    QSignalSpy focusSpy(&applicationManager, SIGNAL(focusedApplicationIdChanged()));
-    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
-
-    // Upstart notifies of stopping app
-    applicationManager.onProcessStopped(appId);
-
-    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
-    EXPECT_EQ(applicationManager.count(), 0);
-    EXPECT_EQ(focusSpy.count(), 0);
-    EXPECT_EQ(removedSpy.count(), 1);
-    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
-}
-
-/*
  * Test that if a background application is reported to unexpectedly stop by upstart, AppMan does not remove
  * it from the app lists but instead considers it Stopped, ready to be resumed. This is due to the fact the
  * app should have saved its state, so can be resumed. This situation can occur due to the OOM killer, or
@@ -1413,18 +1096,18 @@
         .Times(1)
         .WillOnce(Return(true));
 
-    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    Application *app = applicationManager.startApplication(appId, ApplicationManager::NoFlag);
     applicationManager.onProcessStarting(appId);
     std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
     bool authed = true;
     applicationManager.authorizeSession(procId, authed);
     onSessionStarting(session);
 
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
-    applicationManager.onSessionCreatedSurface(session.get(), surface);
-    applicationManager.focusApplication(appId);
-    applicationManager.unfocusCurrentApplication();
-    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
+    FakeMirSurfaceItem *surface = new FakeMirSurfaceItem;
+    onSessionCreatedSurface(session.get(), surface);
+    surface->drawFirstFrame();
+
+    suspend(app);
 
     QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
     QSignalSpy focusSpy(&applicationManager, SIGNAL(focusedApplicationIdChanged()));
@@ -1436,14 +1119,14 @@
     // Upstart notifies of crashing / OOM-killed app
     applicationManager.onProcessFailed(appId, false);
 
-    EXPECT_EQ(focusSpy.count(), 0);
+    EXPECT_EQ(0, focusSpy.count());
 
     // Upstart finally notifies the app stopped
     applicationManager.onProcessStopped(appId);
 
-    EXPECT_EQ(countSpy.count(), 0);
-    EXPECT_EQ(applicationManager.count(), 1);
-    EXPECT_EQ(removedSpy.count(), 0);
+    EXPECT_EQ(0, countSpy.count());
+    EXPECT_EQ(1, applicationManager.count());
+    EXPECT_EQ(0, removedSpy.count());
 }
 
 /*
@@ -1471,18 +1154,18 @@
         .Times(1)
         .WillOnce(Return(true));
 
-    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    Application *app = applicationManager.startApplication(appId, ApplicationManager::NoFlag);
     applicationManager.onProcessStarting(appId);
     std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
     bool authed = true;
     applicationManager.authorizeSession(procId, authed);
     onSessionStarting(session);
 
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
-    applicationManager.onSessionCreatedSurface(session.get(), surface);
-    applicationManager.focusApplication(appId);
-    applicationManager.unfocusCurrentApplication();
-    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
+    FakeMirSurfaceItem *surface = new FakeMirSurfaceItem;
+    onSessionCreatedSurface(session.get(), surface);
+    surface->drawFirstFrame();
+
+    suspend(app);
 
     QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
     QSignalSpy focusSpy(&applicationManager, SIGNAL(focusedApplicationIdChanged()));
@@ -1571,10 +1254,9 @@
     onSessionStarting(session);
 
     // Associate a surface so AppMan considers app Running, check focused
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
-    applicationManager.onSessionCreatedSurface(session.get(), surface);
-    applicationManager.focusApplication(appId);
-    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
+    FakeMirSurfaceItem *surface = new FakeMirSurfaceItem;
+    onSessionCreatedSurface(session.get(), surface);
+    surface->drawFirstFrame();
 
     QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
     QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
@@ -1589,10 +1271,10 @@
 }
 
 /*
- * Test that if a foreground application (one launched via desktop_file_hint) is reported to be stopping by
+ * Test that if an application (one launched via desktop_file_hint) is reported to be stopping by
  * Mir, AppMan removes it from the model immediately
  */
-TEST_F(ApplicationManagerTests,mirNotifiesOfStoppingForegroundAppLaunchedWithDesktopFileHint)
+TEST_F(ApplicationManagerTests,mirNotifiesOfStoppingAppLaunchedWithDesktopFileHint)
 {
     using namespace ::testing;
     const QString appId("testAppId");
@@ -1621,10 +1303,9 @@
     onSessionStarting(session);
 
     // Associate a surface so AppMan considers app Running, check focused
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
-    applicationManager.onSessionCreatedSurface(session.get(), surface);
-    applicationManager.focusApplication(appId);
-    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
+    FakeMirSurfaceItem *surface = new FakeMirSurfaceItem;
+    onSessionCreatedSurface(session.get(), surface);
+    surface->drawFirstFrame();
 
     QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
     QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
@@ -1661,86 +1342,43 @@
         .Times(1)
         .WillOnce(Return(true));
 
-    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    Application *app = applicationManager.startApplication(appId, ApplicationManager::NoFlag);
     applicationManager.onProcessStarting(appId);
     std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
     bool authed = true;
     applicationManager.authorizeSession(procId, authed);
     onSessionStarting(session);
-
-    // Associate a surface so AppMan considers app Running, check in background
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
-    applicationManager.onSessionCreatedSurface(session.get(), surface);
-    applicationManager.focusApplication(appId);
-    applicationManager.unfocusCurrentApplication();
-    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
-
-    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
-    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
-
-    // Mir notifies of stopping app
-    onSessionStopping(session);
-
-    EXPECT_EQ(countSpy.count(), 0);
-    EXPECT_EQ(applicationManager.count(), 1);
-    EXPECT_EQ(removedSpy.count(), 0);
-
-    Application * app = applicationManager.findApplication(appId);
-    EXPECT_NE(nullptr,app);
-    EXPECT_EQ(app->state(), Application::Stopped);
-}
-
-/*
- * Test that if a background application (one launched via desktop_file_hint) is reported to be stopping by
- * Mir, AppMan removes it from the model immediately
- */
-TEST_F(ApplicationManagerTests,mirNotifiesOfStoppingBackgroundAppLaunchedWithDesktopFileHint)
-{
-    using namespace ::testing;
-    const QString appId("testAppId");
-    const QString name("Test App");
-    quint64 procId = 5551;
-    QByteArray cmdLine("/usr/bin/testApp --desktop_file_hint=");
-    cmdLine = cmdLine.append(appId);
-
-    // Set up Mocks & signal watcher
-    EXPECT_CALL(procInfo,command_line(procId))
-        .Times(1)
-        .WillOnce(Return(cmdLine));
-
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-    ON_CALL(*mockDesktopFileReader, name()).WillByDefault(Return(name));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
-
-    // Mir requests authentication for an application that was started
-    bool authed = true;
-    applicationManager.authorizeSession(procId, authed);
-    EXPECT_EQ(authed, true);
-    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
-    onSessionStarting(session);
-
-    // Associate a surface so AppMan considers app Running, check in background
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
-    applicationManager.onSessionCreatedSurface(session.get(), surface);
-    applicationManager.focusApplication(appId);
-    applicationManager.unfocusCurrentApplication();
-    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
-
-    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
-    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
-
-    // Mir notifies of stopping app
-    onSessionStopping(session);
-
-    EXPECT_EQ(countSpy.count(), 2); //FIXME(greyback)
-    EXPECT_EQ(applicationManager.count(), 0);
-    EXPECT_EQ(removedSpy.count(), 1);
-
-    Application * app = applicationManager.findApplication(appId);
-    EXPECT_EQ(nullptr,app);
+    EXPECT_EQ(Application::Starting, app->state());
+
+    app->setRequestedState(Application::RequestedSuspended);
+
+    // should not suspend an app that`s still starting up
+    ASSERT_EQ(Application::InternalState::Starting, app->internalState());
+
+    // Associate a surface so AppMan considers app Running
+    FakeMirSurfaceItem *surface = new FakeMirSurfaceItem;
+    onSessionCreatedSurface(session.get(), surface);
+    surface->drawFirstFrame();
+
+    ASSERT_EQ(Application::InternalState::SuspendingWaitSession, app->internalState());
+
+    static_cast<qtmir::Session*>(app->session())->doSuspend();
+    ASSERT_EQ(Application::InternalState::SuspendingWaitProcess, app->internalState());
+
+    applicationManager.onProcessSuspended(app->appId());
+    ASSERT_EQ(Application::InternalState::Suspended, app->internalState());
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app
+    onSessionStopping(session);
+
+    EXPECT_EQ(0, countSpy.count());
+    EXPECT_EQ(1, applicationManager.count());
+    EXPECT_EQ(0, removedSpy.count());
+
+    EXPECT_EQ(Application::Stopped, app->state());
 }
 
 /*
@@ -1822,45 +1460,6 @@
 }
 
 /*
- * Test that if an application is stopped by upstart, the Mir stopping event is ignored
- */
-TEST_F(ApplicationManagerTests,appStoppedByUpstart_mirSessionStoppingEventIgnored)
-{
-    using namespace ::testing;
-    const QString appId("testAppId");
-    quint64 procId = 5551;
-
-    // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
-
-    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
-    applicationManager.onProcessStarting(appId);
-    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
-    bool authed = true;
-    applicationManager.authorizeSession(procId, authed);
-    onSessionStarting(session);
-
-    applicationManager.onProcessStopped(appId);
-
-    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
-    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
-
-    // Mir notifies of stopping app
-    onSessionStopping(session);
-
-    EXPECT_EQ(countSpy.count(), 0);
-    EXPECT_EQ(removedSpy.count(), 0);
-}
-
-/*
  * Webapps have multiple sessions, but only one is linked to the application (other is considered a hidden session).
  * If webapp in foreground stops unexpectedly, remove it and it alone from app list
  */
@@ -1903,8 +1502,9 @@
     applicationManager.authorizeSession(procId2, authed);
     onSessionStarting(session2);
     EXPECT_EQ(authed, true);
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
-    applicationManager.onSessionCreatedSurface(session2.get(), surface);
+    FakeMirSurfaceItem *surface = new FakeMirSurfaceItem;
+    onSessionCreatedSurface(session2.get(), surface);
+    surface->drawFirstFrame();
 
     QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
     QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
@@ -1950,7 +1550,7 @@
         .Times(1)
         .WillOnce(Return(true));
 
-    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    Application *app = applicationManager.startApplication(appId, ApplicationManager::NoFlag);
     applicationManager.onProcessStarting(appId);
     std::shared_ptr<mir::scene::Session> session1 = std::make_shared<MockSession>("", procId1);
     std::shared_ptr<mir::scene::Session> session2 = std::make_shared<MockSession>("", procId2);
@@ -1958,19 +1558,20 @@
     bool authed = false;
     applicationManager.authorizeSession(procId1, authed);
     onSessionStarting(session1);
-    EXPECT_EQ(authed, true);
+    EXPECT_EQ(true, authed);
     applicationManager.authorizeSession(procId2, authed);
     onSessionStarting(session2);
-    EXPECT_EQ(authed, true);
+    EXPECT_EQ(true, authed);
 
-    // both sessions create surfaces, then unfocus everything.
-    std::shared_ptr<mir::scene::Surface> surface1(nullptr);
-    applicationManager.onSessionCreatedSurface(session1.get(), surface1);
-    std::shared_ptr<mir::scene::Surface> surface2(nullptr);
-    applicationManager.onSessionCreatedSurface(session2.get(), surface2);
-    applicationManager.focusApplication(appId);
-    applicationManager.unfocusCurrentApplication();
-    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
+    // both sessions create surfaces, then get them all suspended
+    FakeMirSurfaceItem *surface1 = new FakeMirSurfaceItem;
+    onSessionCreatedSurface(session1.get(), surface1);
+    surface1->drawFirstFrame();
+    FakeMirSurfaceItem *surface2 = new FakeMirSurfaceItem;
+    onSessionCreatedSurface(session2.get(), surface2);
+    surface2->drawFirstFrame();
+    suspend(app);
+    EXPECT_EQ(Application::Suspended, app->state());
 
     QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
     QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
@@ -1979,8 +1580,104 @@
     onSessionStopping(session2);
     onSessionStopping(session1);
 
-    EXPECT_EQ(countSpy.count(), 0);
-    EXPECT_EQ(removedSpy.count(), 0);
+    EXPECT_EQ(0, countSpy.count());
+    EXPECT_EQ(0, removedSpy.count());
+}
+
+/*
+ * Test requested surface size unchanged if no surfaceSizer registered
+ */
+TEST_F(ApplicationManagerTests, registerSurfaceSizeUnchangedWhenNoSizerCallbackRegistered)
+{
+    using namespace ::testing;
+    quint64 procId = 5551;
+    SurfaceParameters params;
+    params.geometry = {400, 250}; // can be overridden
+
+    const auto session = std::make_shared<MockSession>("", procId);
+    applicationManager.onSessionAboutToCreateSurface(session, params);
+
+    EXPECT_EQ(params.geometry, QSize(400, 250));
+}
+
+/*
+ * Test registerSurfaceSizerCallback functionality
+ */
+TEST_F(ApplicationManagerTests, registerSurfaceSizerFunctional)
+{
+    using namespace ::testing;
+    quint64 procId = 5551;
+    SurfaceParameters params;
+    params.geometry = {400, 250}; // can be overridden
+
+    QJSValue callback = jsEngine->evaluate("(function(surface) { surface.width = 111; return surface; })");
+    applicationManager.setSurfaceAboutToBeCreatedCallback(callback);
+
+    const auto session = std::make_shared<MockSession>("", procId);
+    applicationManager.onSessionAboutToCreateSurface(session, params);
+
+    EXPECT_EQ(params.geometry, QSize(111, 250));
+}
+
+/*
+ * Test deregisterSurfaceSizerCallback correctly removes the callback
+ */
+TEST_F(ApplicationManagerTests, deregisterSurfaceSizerWorks)
+{
+    using namespace ::testing;
+    quint64 procId = 5551;
+    SurfaceParameters params;
+    params.geometry = {400, 250}; // can be overridden
+
+    QJSValue callback = jsEngine->evaluate("(function(surface) { surface.width = 111; return surface; })");
+    applicationManager.setSurfaceAboutToBeCreatedCallback(callback);
+
+    const auto session = std::make_shared<MockSession>("", procId);
+
+    applicationManager.setSurfaceAboutToBeCreatedCallback(false);
+    applicationManager.onSessionAboutToCreateSurface(session, params);
+
+    EXPECT_EQ(params.geometry, QSize(400, 250)); // should be unchanged
+}
+
+/*
+ * Test registerSurfaceSizerCallback rejects an uncallable QJSValue (i.e. something that's not a function was passed)
+ */
+TEST_F(ApplicationManagerTests, registerSurfaceSizerRejectsNonCallableJSValues)
+{
+    using namespace ::testing;
+
+    QJSValue callback = jsEngine->evaluate("21");
+    applicationManager.setSurfaceAboutToBeCreatedCallback(callback);
+
+    callback = jsEngine->evaluate("true");
+    applicationManager.setSurfaceAboutToBeCreatedCallback(callback);
+
+    callback = jsEngine->evaluate("{}");
+    applicationManager.setSurfaceAboutToBeCreatedCallback(callback);
+
+    callback = jsEngine->evaluate("new Array()");
+    applicationManager.setSurfaceAboutToBeCreatedCallback(callback);
+}
+
+/*
+ * Test in case that registered SurfaceSizerCallback does not return a type with a 'width' (or 'height') property,
+ * we return the requested surface width/height unchanged
+ */
+TEST_F(ApplicationManagerTests, registeredSurfaceSizerDealswithBadReturns)
+{
+    using namespace ::testing;
+    quint64 procId = 5551;
+    SurfaceParameters params;
+    params.geometry = {400, 250}; // can be overridden
+
+    QJSValue callback = jsEngine->evaluate("(function(s) { var out = new Object(); out.height = 333; return out; })");
+    applicationManager.setSurfaceAboutToBeCreatedCallback(callback);
+
+    const auto session = std::make_shared<MockSession>("", procId);
+    applicationManager.onSessionAboutToCreateSurface(session, params);
+
+    EXPECT_EQ(params.geometry, QSize(400, 333));
 }
 
 /*
@@ -2007,34 +1704,33 @@
         .Times(1)
         .WillOnce(Return(true));
 
-    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    Application *app = applicationManager.startApplication(appId, ApplicationManager::NoFlag);
     applicationManager.onProcessStarting(appId);
     std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
     bool authed = true;
     applicationManager.authorizeSession(procId, authed);
     onSessionStarting(session);
 
-    // App creates surface, focuses it, puts it in background, then is OOM killed.
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
-    applicationManager.onSessionCreatedSurface(session.get(), surface);
-    applicationManager.focusApplication(appId);
-    applicationManager.unfocusCurrentApplication();
+    // App creates surface, puts it in background, then is OOM killed.
+    FakeMirSurfaceItem *surface = new FakeMirSurfaceItem;
+    onSessionCreatedSurface(session.get(), surface);
+    surface->drawFirstFrame();
+    suspend(app);
 
     onSessionStopping(session);
     applicationManager.onProcessFailed(appId, false);
     applicationManager.onProcessStopped(appId);
 
-    Application *app = applicationManager.findApplication(appId);
-    EXPECT_EQ(app->state(), Application::Stopped);
+    EXPECT_EQ(Application::Stopped, app->state());
 
     QSignalSpy focusRequestSpy(&applicationManager, SIGNAL(focusRequested(const QString &)));
 
     // Upstart re-launches app
     applicationManager.onProcessStarting(appId);
 
-    EXPECT_EQ(app->state(), Application::Starting);
-    EXPECT_EQ(focusRequestSpy.count(), 1);
-    EXPECT_EQ(applicationManager.count(), 1);
+    EXPECT_EQ(Application::Starting, app->state());
+    EXPECT_EQ(1, focusRequestSpy.count());
+    EXPECT_EQ(1, applicationManager.count());
 }
 
 /*
@@ -2138,142 +1834,61 @@
     }
 }
 
-/*
-   1 - launch and focus a main stage app
-     * main stage app is running and focused
-   2 - launch and focus a side stage app
-     * main stage app is running but is not focused
-     * side stage app is running and has focus
-   3 - focus the main stage app
-     * main stage app is running and has focus
-     * side stage app is running but is not focused
-
-   This is a regression test for the bug where on step 3, the main stage app was momentarily
-   suspended and then resumed again.
- */
-TEST_F(ApplicationManagerTests, focusMainStageAfterSideStage)
-{
-    using namespace testing;
-
-    QString webbrowserAppId("webbrowser-app");
-    quint64 webbrowserPID = 123;
-    std::shared_ptr<mir::scene::Surface> webbrowserSurface(nullptr);
-
-    QString dialerAppId("dialer-app");
-    quint64 dialerPID = 456;
-    std::shared_ptr<mir::scene::Surface> dialerSurface(nullptr);
-
-    /*** Start webbrowser-app (main stage) ***/
-
-    ON_CALL(appController,appIdHasProcessId(webbrowserPID, webbrowserAppId)).WillByDefault(Return(true));
-
-    {
-        auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(webbrowserAppId, QFileInfo());
-        ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-        ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(webbrowserAppId));
-        ON_CALL(*mockDesktopFileReader, stageHint()).WillByDefault(Return("MainStage"));
-
-        ON_CALL(desktopFileReaderFactory, createInstance(webbrowserAppId, _))
-            .WillByDefault(Return(mockDesktopFileReader));
-    }
-
-    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(webbrowserAppId, _))
-            .Times(1)
-            .WillOnce(Return(true));
-
-    /*auto application =*/ applicationManager.startApplication(webbrowserAppId, ApplicationManager::NoFlag);
-    applicationManager.onProcessStarting(webbrowserAppId);
-
-    {
-        bool authed = false;
-        applicationManager.authorizeSession(webbrowserPID, authed);
-        EXPECT_EQ(authed, true);
-    }
-
-    auto webbrowserSession = std::make_shared<mir::scene::MockSession>(webbrowserAppId.toStdString(), webbrowserPID);
-    sessionManager.onSessionStarting(webbrowserSession);
-    applicationManager.focusApplication(webbrowserAppId);
-    applicationManager.onSessionCreatedSurface(webbrowserSession.get(), webbrowserSurface);
-
-    /*** Start dialer-app (side stage) ***/
-
-    ON_CALL(appController, appIdHasProcessId(dialerPID, dialerAppId)).WillByDefault(Return(true));
-
-    {
-        auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(dialerAppId, QFileInfo());
-        ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-        ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(dialerAppId));
-        ON_CALL(*mockDesktopFileReader, stageHint()).WillByDefault(Return("SideStage"));
-
-        ON_CALL(desktopFileReaderFactory, createInstance(dialerAppId, _))
-            .WillByDefault(Return(mockDesktopFileReader));
-    }
-
-    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(dialerAppId, _))
-            .Times(1)
-            .WillOnce(Return(true));
-
-    /*auto application =*/ applicationManager.startApplication(dialerAppId, ApplicationManager::NoFlag);
-    applicationManager.onProcessStarting(dialerAppId);
-
-    {
-        bool authed = false;
-        applicationManager.authorizeSession(dialerPID, authed);
-        EXPECT_EQ(authed, true);
-    }
-
-    auto dialerSession = std::make_shared<mir::scene::MockSession>(dialerAppId.toStdString(), dialerPID);
-    sessionManager.onSessionStarting(dialerSession);
-    applicationManager.focusApplication(dialerAppId);
-    applicationManager.onSessionCreatedSurface(dialerSession.get(), dialerSurface);
-
-    /*** Focus webbrowser ***/
-
-    // Nothing should happen as it's already the running main stage app
-    EXPECT_CALL(*webbrowserSession.get(), set_lifecycle_state(_))
-            .Times(0);
-    applicationManager.focusApplication(webbrowserAppId);
-}
-
 TEST_F(ApplicationManagerTests,lifecycle_exempt_appId_is_not_suspended)
 {
     using namespace ::testing;
     quint64 a_procId = 5921;
-    const char an_app_id[] = "some_app";
-    QByteArray a_cmd( "/usr/bin/app1 --desktop_file_hint=some_app");
-    std::shared_ptr<mir::scene::Surface> aSurface(nullptr);
+    const QString appId("some_app");
+    QByteArray a_cmd("/usr/bin/app1");
 
     ON_CALL(procInfo,command_line(_)).WillByDefault(Return(a_cmd));
 
-    ON_CALL(appController,appIdHasProcessId(_,_)).WillByDefault(Return(false));
-
-    bool authed = true;
+    ON_CALL(appController,appIdHasProcessId(a_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));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+
+    Application *the_app = applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(appId);
 
     std::shared_ptr<mir::scene::Session> first_session = std::make_shared<MockSession>("Oo", a_procId);
     std::shared_ptr<mir::scene::Session> second_session = std::make_shared<MockSession>("oO", a_procId);
-    applicationManager.authorizeSession(a_procId, authed);
+    {
+        bool authed = false;
+        applicationManager.authorizeSession(a_procId, authed);
+        ASSERT_EQ(authed, true);
+    }
 
     onSessionStarting(first_session);
-    applicationManager.onSessionCreatedSurface(first_session.get(), aSurface);
+    FakeMirSurfaceItem *aSurface = new FakeMirSurfaceItem;
+    onSessionCreatedSurface(first_session.get(), aSurface);
+    aSurface->drawFirstFrame();
     onSessionStarting(second_session);
 
-    Application * the_app = applicationManager.findApplication(an_app_id);
-    applicationManager.focusApplication(an_app_id);
-
     // Add to other apps to the list (Not "some_app")
     QVariantList lifecycleExemptAppIds;
     lifecycleExemptAppIds << "one_app" << "another_app";
     ON_CALL(settings,get(_)).WillByDefault(Return(lifecycleExemptAppIds));
     settings.changed("lifecycleExemptAppids");
 
-    EXPECT_EQ(Application::Running, the_app->state());
-
-    applicationManager.setSuspended(true);
-
-    // And expect "some_app" to get suspended
-    EXPECT_EQ(Application::Suspended, the_app->state());
-
-    applicationManager.setSuspended(false);
+    ASSERT_EQ(Application::InternalState::Running, the_app->internalState());
+
+    EXPECT_CALL(*(mir::scene::MockSession*)first_session.get(), set_lifecycle_state(mir_lifecycle_state_will_suspend));
+    the_app->setRequestedState(Application::RequestedSuspended);
+    ASSERT_EQ(Application::InternalState::SuspendingWaitSession, the_app->internalState());
+
+    static_cast<qtmir::Session*>(the_app->session())->doSuspend();
+    ASSERT_EQ(Application::InternalState::SuspendingWaitProcess, the_app->internalState());
+    applicationManager.onProcessSuspended(the_app->appId());
+    ASSERT_EQ(Application::InternalState::Suspended, the_app->internalState());
+
+    EXPECT_CALL(*(mir::scene::MockSession*)first_session.get(), set_lifecycle_state(mir_lifecycle_state_resumed));
+    the_app->setRequestedState(Application::RequestedRunning);
 
     EXPECT_EQ(Application::Running, the_app->state());
 
@@ -2284,14 +1899,16 @@
 
     EXPECT_EQ(Application::Running, the_app->state());
 
-    applicationManager.setSuspended(true);
+    EXPECT_CALL(*(mir::scene::MockSession*)first_session.get(), set_lifecycle_state(_)).Times(0);
+    the_app->setRequestedState(Application::RequestedSuspended);
 
     // And expect it to be running still
-    EXPECT_EQ(Application::Running, the_app->state());
-
-    applicationManager.setSuspended(false);
-
-    EXPECT_EQ(Application::Running, the_app->state());
+    ASSERT_EQ(Application::InternalState::RunningInBackground, the_app->internalState());
+
+    the_app->setRequestedState(Application::RequestedRunning);
+
+    EXPECT_EQ(Application::Running, the_app->state());
+    ASSERT_EQ(Application::InternalState::Running, the_app->internalState());
 }
 
 /*
@@ -2323,51 +1940,13 @@
     onSessionStarting(session);
 
     // App creates surface, focuses it so state is running
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
-    applicationManager.onSessionCreatedSurface(session.get(), surface);
-    applicationManager.focusApplication(appId);
-
-    applicationManager.unfocusCurrentApplication();
-
-    EXPECT_FALSE(sharedWakelock.enabled());
-    EXPECT_EQ(application->state(), Application::Running);
-}
-
-/*
- * Test lifecycle exempt applications have their wakelocks released on suspend
- */
-TEST_F(ApplicationManagerTests,lifecycleExemptAppsHaveWakelockReleasedOnUnSuspend)
-{
-    using namespace ::testing;
-
-    const QString appId("com.ubuntu.music"); // member of lifecycle exemption list
-    const quint64 procId = 12345;
-
-    // Set up Mocks & signal watcher
-    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
-    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
-    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
-
-    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
-
-    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
-            .Times(1)
-            .WillOnce(Return(true));
-
-    auto application = applicationManager.startApplication(appId, ApplicationManager::NoFlag);
-    applicationManager.onProcessStarting(appId);
-    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
-    bool authed = true;
-    applicationManager.authorizeSession(procId, authed);
-    onSessionStarting(session);
-
-    // App creates surface, focuses it so state is running
-    std::shared_ptr<mir::scene::Surface> surface(nullptr);
-    applicationManager.onSessionCreatedSurface(session.get(), surface);
-    applicationManager.focusApplication(appId);
-
-    applicationManager.setSuspended(true);
-
-    EXPECT_FALSE(sharedWakelock.enabled());
-    EXPECT_EQ(application->state(), Application::Running);
+    FakeMirSurfaceItem *surface = new FakeMirSurfaceItem;
+    onSessionCreatedSurface(session.get(), surface);
+    surface->drawFirstFrame();
+
+    application->setRequestedState(Application::RequestedSuspended);
+
+    EXPECT_FALSE(sharedWakelock.enabled());
+    ASSERT_EQ(Application::InternalState::RunningInBackground, application->internalState());
+    EXPECT_EQ(Application::Running, application->state());
 }

=== modified file 'tests/modules/MirSurfaceItem/CMakeLists.txt'
--- tests/modules/MirSurfaceItem/CMakeLists.txt	2014-12-03 08:56:35 +0000
+++ tests/modules/MirSurfaceItem/CMakeLists.txt	2015-07-13 21:57:32 +0000
@@ -5,7 +5,9 @@
 )
 
 include_directories(
-  ${CMAKE_SOURCE_DIR}/src/modules/Unity/Application
+  ${CMAKE_SOURCE_DIR}/src/common
+#  ${CMAKE_SOURCE_DIR}/src/modules/Unity/Application
+  ${CMAKE_SOURCE_DIR}/src/modules
   ${CMAKE_SOURCE_DIR}/tests/modules/common
   ${MIRSERVER_INCLUDE_DIRS}
 )

=== modified file 'tests/modules/MirSurfaceItem/mirsurfaceitem_test.cpp'
--- tests/modules/MirSurfaceItem/mirsurfaceitem_test.cpp	2015-05-01 13:37:03 +0000
+++ tests/modules/MirSurfaceItem/mirsurfaceitem_test.cpp	2015-07-13 21:57:32 +0000
@@ -23,7 +23,7 @@
 #include <QTest>
 
 // the test subject
-#include <mirsurfaceitem.h>
+#include <Unity/Application/mirsurfaceitem.h>
 
 // mocks
 #include <mock_surface.h>

=== modified file 'tests/modules/SessionManager/CMakeLists.txt'
--- tests/modules/SessionManager/CMakeLists.txt	2015-05-21 18:48:59 +0000
+++ tests/modules/SessionManager/CMakeLists.txt	2015-07-13 21:57:32 +0000
@@ -3,9 +3,13 @@
   session_manager_test.cpp
   session_test.cpp
   ${CMAKE_SOURCE_DIR}/src/common/debughelpers.cpp
+  ${CMAKE_SOURCE_DIR}/tests/modules/common/qtmir_test.cpp
+  ${CMAKE_SOURCE_DIR}/tests/modules/common/fake_mirsurfaceitem.h
 )
 
 include_directories(
+  ${APPLICATION_API_INCLUDE_DIRS}
+  ${CMAKE_SOURCE_DIR}/src/common
   ${CMAKE_SOURCE_DIR}/src/platforms/mirserver
   ${CMAKE_SOURCE_DIR}/src/modules
   ${CMAKE_SOURCE_DIR}/tests/modules/common

=== modified file 'tests/modules/SessionManager/session_manager_test.cpp'
--- tests/modules/SessionManager/session_manager_test.cpp	2014-12-01 11:05:01 +0000
+++ tests/modules/SessionManager/session_manager_test.cpp	2015-07-13 21:57:32 +0000
@@ -21,7 +21,7 @@
 
 #include <Unity/Application/session.h>
 
- #include "qtmir_test.h"
+#include "qtmir_test.h"
 
 using namespace qtmir;
 using mir::scene::MockSession;

=== modified file 'tests/modules/SessionManager/session_test.cpp'
--- tests/modules/SessionManager/session_test.cpp	2015-01-09 15:13:29 +0000
+++ tests/modules/SessionManager/session_test.cpp	2015-07-13 21:57:32 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014,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,16 +15,17 @@
  *
  */
 
+#include <qtmir_test.h>
+#include <fake_mirsurfaceitem.h>
+
 #include <Unity/Application/application.h>
 #include <Unity/Application/mirsurfaceitem.h>
 
-#include "qtmir_test.h"
 #include "stub_scene_surface.h"
 
 using namespace qtmir;
 using mir::scene::MockSession;
 
-
 namespace ms = mir::scene;
 namespace mtd = mir::test::doubles;