Merge lp:unity-mir/devel-mir-next into lp:unity-mir

[Gerry Boland]

Merge devel at rev 222. (Fix crash on shell shutdown; Refactor app shutdown)

2014-05-06 Gerry Boland <email address hidden>

        [220] Fix crash on Mir-initiated shutdown, where stop() was being
        called on an already shutting-down server.

        Mir initiates shutdown on SIGINT & SIGTERM, need to distinguish that
        shutdown from a client-initiated shutdown. Do this by installing a
        custom signal handler that is run after Mir's initiate-shutdown
        handler is called, so that we only call server.stop() on a client-
        initiated shutdown. Fixes: https://bugs.launchpad.net/bugs/1315251.

        Approved by Michał Sawicz, PS Jenkins bot.

2014-05-20 Gerry Boland <email address hidden>

        [222] Refactoring to have app shutdown handled correctly.

        Involves adding a canBeResumed flag to Application and using it to
        determine if AppMan should remove the application from the lists.
        Also add a big bunch of unit tests for AppMan. Fixes:
        https://bugs.launchpad.net/bugs/1305128.

        Approved by PS Jenkins bot, Michał Sawicz.

Refactoring to have app shutdown handled correctly.

Involves adding a canBeResumed flag to Application and using it to determine if AppMan should remove the application from the lists. Also add a big bunch of unit tests for AppMan. Fixes: https://bugs.launchpad.net/bugs/1305128.

Checklist:
 * Are there any related MPs required for this MP to build/function as expected? Please list.
N
 * 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

[Michał Sawicz (saviq)]

Yup.

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:222
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/346/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-utopic-amd64-ci/10
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-utopic-armhf-ci/10
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-utopic-armhf-ci/10/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-utopic-i386-ci/10

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/346/rebuild

review: Approve (continuous-integration)

[lp:unity-mir/devel-mir-next]

222. By Tarmac on 2014-05-20

Merge devel at rev 222. (Fix crash on shell shutdown; Refactor app shutdown)

2014-05-06 Gerry Boland <email address hidden>

        [220] Fix crash on Mir-initiated shutdown, where stop() was being
        called on an already shutting-down server.

        Mir initiates shutdown on SIGINT & SIGTERM, need to distinguish that
        shutdown from a client-initiated shutdown. Do this by installing a
        custom signal handler that is run after Mir's initiate-shutdown
        handler is called, so that we only call server.stop() on a client-
        initiated shutdown. Fixes: https://bugs.launchpad.net/bugs/1315251.

        Approved by Michał Sawicz, PS Jenkins bot.

2014-05-20 Gerry Boland <email address hidden>

        [222] Refactoring to have app shutdown handled correctly.

        Involves adding a canBeResumed flag to Application and using it to
        determine if AppMan should remove the application from the lists.
        Also add a big bunch of unit tests for AppMan. Fixes:
        https://bugs.launchpad.net/bugs/1305128.

        Approved by PS Jenkins bot, Michał Sawicz.

=== modified file 'src/modules/Unity/Application/application.cpp'
--- src/modules/Unity/Application/application.cpp	2014-05-14 16:44:55 +0000
+++ src/modules/Unity/Application/application.cpp	2014-05-20 12:42:58 +0000
@@ -42,6 +42,7 @@
     , m_stage((m_desktopData->stageHint() == "SideStage") ? Application::SideStage : Application::MainStage)
     , m_state(state)
     , m_focused(false)
+    , m_canBeResumed(true)
     , m_fullscreen(false)
     , m_visible(false)
     , m_arguments(arguments)
@@ -142,6 +143,16 @@
     return m_visible;
 }
 
+bool Application::canBeResumed() const
+{
+    return m_canBeResumed;
+}
+
+void Application::setCanBeResumed(const bool resume)
+{
+    m_canBeResumed = resume;
+}
+
 pid_t Application::pid() const
 {
     return m_pid;

=== modified file 'src/modules/Unity/Application/application.h'
--- src/modules/Unity/Application/application.h	2014-05-14 16:44:55 +0000
+++ src/modules/Unity/Application/application.h	2014-05-20 12:42:58 +0000
@@ -71,6 +71,9 @@
     QImage screenshotImage() const;
     void updateScreenshot();
 
+    bool canBeResumed() const;
+    void setCanBeResumed(const bool);
+
     bool isValid() const;
     QString desktopFile() const;
     QString exec() const;
@@ -106,6 +109,7 @@
     bool m_focused;
     QUrl m_screenshot;
     QImage m_screenshotImage;
+    bool m_canBeResumed;
     bool m_fullscreen;
     bool m_visible; // duplicating internal Mir data :(
     std::shared_ptr<::mir::scene::Session> m_session;
@@ -114,7 +118,6 @@
     QTimer* m_suspendTimer;
 
     friend class ApplicationManager;
-    friend class ApplicationListModel;
     friend class MirSurfaceManager;
 };
 

=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2014-05-16 12:19:52 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2014-05-20 12:42:58 +0000
@@ -113,22 +113,22 @@
 {
     QObject::connect(strategy, &InitialSurfacePlacementStrategy::requestPlacementForSession,
                      manager, &ApplicationManager::placeSession, Qt::DirectConnection);
-
 }
 
 void connectToTaskController(ApplicationManager * manager, TaskController * controller)
 {
-    QObject::connect(controller, &TaskController::processStartReport,
-                     manager, &ApplicationManager::onProcessStartReportReceived);
+    QObject::connect(controller, &TaskController::processStarting,
+                     manager, &ApplicationManager::onProcessStarting);
     QObject::connect(controller, &TaskController::processStopped,
                      manager, &ApplicationManager::onProcessStopped);
+    QObject::connect(controller, &TaskController::processFailed,
+                     manager, &ApplicationManager::onProcessFailed);
     QObject::connect(controller, &TaskController::requestFocus,
                      manager, &ApplicationManager::onFocusRequested);
     QObject::connect(controller, &TaskController::requestResume,
                      manager, &ApplicationManager::onResumeRequested);
-
-}
-}
+}
+} // namespace
 
 ApplicationManager* ApplicationManager::Factory::Factory::create()
 {
@@ -485,20 +485,12 @@
     return application;
 }
 
-void ApplicationManager::onProcessStartReportReceived(const QString &appId, const bool failure)
+void ApplicationManager::onProcessStarting(const QString &appId)
 {
-    DLOG("ApplicationManager::onProcessStartReportReceived (this=%p, appId=%s, failure=%c)",
-         this, qPrintable(appId), (failure) ? 'Y' : 'N');
-
-    if (failure) {
-        DLOG("ApplicationManager::onProcessStartReportReceived handling failure:");
-        stopStartingApplication(appId);
-        return;
-    }
-
+    DLOG("ApplicationManager::onProcessStarting (this=%p, appId=%s)", this, qPrintable(appId));
     Application *application = findApplication(appId);
 
-    if (!application) { // if shell did not start this application, but upstart did
+    if (!application) { // then shell did not start this application, so upstart must have - add to list
         application = new Application(
                     m_taskController,
                     m_desktopFileReaderFactory->createInstance(appId, m_taskController->findDesktopFileForAppId(appId)),
@@ -519,7 +511,37 @@
         Q_EMIT focusRequested(appId);
     }
     else {
-        DLOG("ApplicationManager::onProcessStartReportReceived application already found: (app=%p, appId=%s)", application, qPrintable(appId));
+        DLOG("ApplicationManager::onProcessStarting application already found: (app=%p, appId=%s)", application, qPrintable(appId));
+    }
+}
+
+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.
+     */
+
+    DLOG("ApplicationManager::onProcessFailed (this=%p, appId=%s, duringStartup=%c)",
+         this, qPrintable(appId), (duringStartup) ? 'Y' : 'N');
+
+    Application *application = findApplication(appId);
+    if (!application) {
+        LOG("ApplicationManager::onProcessFailed - upstart reports failure of application AppManager is not managing");
+        return;
+    }
+
+    Q_UNUSED(duringStartup); // FIXME(greyback) upstart reports app that fully started up & crashes as failing during startup??
+    if (application->state() == Application::Starting) {
+        checkFocusOnRemovedApplication(application);
+        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);
     }
 }
 
@@ -574,55 +596,31 @@
     return true;
 }
 
-void ApplicationManager::stopStartingApplication(const QString &appId)
-{
-    Application *application = findApplication(appId);
-
-    if (application && application->state() == Application::Starting) {
-        shutdownApplication(application);
-    }
-    else if (application) {
-        DLOG("ApplicationManager::stopStartingApplication start failure report received - but application=%p, appId=%s is not in Starting state",application, qPrintable(appId));
-    }
-}
-
-void ApplicationManager::onProcessStopped(const QString &appId, const bool unexpected)
-{
-    Application *application = findApplication(appId);
+void ApplicationManager::onProcessStopped(const QString &appId)
+{
+    Application *application = findApplication(appId);
+    if (!application) {
+        DLOG("ApplicationManager::onProcessStopped reports stop of appId='%s' which AppMan is not managing, ignoring the event");
+        return;
+    }
     DLOG("ApplicationManager::onProcessStopped (this=%p, application=%p, appId=%s)", this, application, qPrintable(appId));
 
-    // if shell did not stop the application, but upstart 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 upstart gives some failure info.
-    if (application) {
-        shutdownApplication(application);
-    }
-
-    if (unexpected) {
-        // TODO: pop up a message box/notification?
-        LOG("ApplicationManager: application '%s' died unexpectedly!", qPrintable(appId));
-    }
-}
-
-void ApplicationManager::shutdownApplication(Application* application)
-{
-    bool removeApplication = checkFocusOnRemovedApplication(application);
-
-    if (application->state() == Application::Running || application->state() == Application::Starting) {
-        // Application probably crashed, else OOM killer struck. Either way state wasn't saved
-        // so just remove application
-        removeApplication = true;
-    } else if (application->state() == Application::Suspended) {
-        application->setState(Application::Stopped);
-        application->setSession(nullptr);
+    bool removeApplication = true;
+
+    // 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) {
+        DLOG("ApplicationManager::onProcessStopped - removing appId='%s' from the application list", qPrintable(appId));
+        checkFocusOnRemovedApplication(application);
         remove(application);
         m_dbusWindowStack->WindowDestroyed(0, application->appId());
         delete application;
     }
-
 }
 
 void ApplicationManager::onFocusRequested(const QString& appId)
@@ -644,7 +642,7 @@
     }
 
     // If app Stopped, trust that upstart-app-launch respawns it itself, and AppManager will
-    // be notified of that through the onProcessStartReportReceived slot. Else resume.
+    // be notified of that through the onProcessStarting slot. Else resume.
     if (application->state() == Application::Suspended) {
         application->setState(Application::Running);
     }
@@ -670,8 +668,6 @@
     }
 }
 
-/************************************* Mir-side methods *************************************/
-
 void ApplicationManager::authorizeSession(const quint64 pid, bool &authorized)
 {
     authorized = false; //to be proven wrong
@@ -761,6 +757,7 @@
     application = new Application(m_taskController, desktopData, Application::Starting, arguments, this);
     application->setPid(pid);
     application->setStage(stage);
+    application->setCanBeResumed(false);
     add(application);
     authorized = true;
 }
@@ -768,8 +765,8 @@
 void ApplicationManager::placeSession(ms::Session const* session, uint32_t &x, uint32_t &y)
 {
     Application* application = findApplicationWithSession(session);
-    DLOG("ApplicationManager::placeSession (this=%p, application=%p, session=%p, name=%s)", this, application, session, session?(session->name().c_str()):"null");
-    
+    DLOG("ApplicationManager::placeSession (this=%p, application=%p, session=%p, name=%s)", this, application, session,
+         session?(session->name().c_str()):"null");
 
     // Application defaults 
     x = 0;
@@ -818,32 +815,29 @@
     // in case application closed not by hand of shell, check again here:
     Application* application = findApplicationWithSession(session);
 
-    DLOG("ApplicationManager::onSessionStopping (this=%p, application=%p, appId=%s, session name=%s)", this, application, application?qPrintable(application->appId()):"null", session?session->name().c_str():"null");
+    DLOG("ApplicationManager::onSessionStopping (this=%p, application=%p, appId=%s, session name=%s)", this, application,
+         application?qPrintable(application->appId()):"null", session?session->name().c_str():"null");
 
     if (application) {
-        bool removeApplication = true;
-
-        if (application->state() != Application::Starting) {
-            application->setState(Application::Stopped);
-            application->setSession(nullptr);
+        /* 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) {
+            checkFocusOnRemovedApplication(application);
             m_dbusWindowStack->WindowDestroyed(0, application->appId());
-            if (application != m_focusedApplication) {
-                removeApplication = false;
-            }
-        }
-
-        if (m_mainStageApplication == application)
-            m_mainStageApplication = nullptr;
-        
-        if (m_sideStageApplication == application)
-            m_sideStageApplication = nullptr;
-
-        if (removeApplication) {
-            // TODO(greyback) What to do?? Focus next app, or unfocus everything??
-            m_focusedApplication = nullptr;
             remove(application);
             delete application;
-            Q_EMIT focusedApplicationIdChanged();
+        } 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);
         }
     }
 }
@@ -851,7 +845,8 @@
 void ApplicationManager::onSessionFocused(const std::shared_ptr<ms::Session>& session)
 {
     Application* application = findApplicationWithSession(session);
-    DLOG("ApplicationManager::onSessionFocused (this=%p, application=%p, appId=%s, session name=%s)", this, application, application?qPrintable(application->appId()):"null", session?session->name().c_str():"null");
+    DLOG("ApplicationManager::onSessionFocused (this=%p, application=%p, appId=%s, session name=%s)", this, application,
+         application?qPrintable(application->appId()):"null", session?session->name().c_str():"null");
 
     // Don't give application focus until it has created it's surface, when it is set as state "Running"
     // and only notify shell of focus changes that it actually expects

=== modified file 'src/modules/Unity/Application/application_manager.h'
--- src/modules/Unity/Application/application_manager.h	2014-04-15 14:31:02 +0000
+++ src/modules/Unity/Application/application_manager.h	2014-05-20 12:42:58 +0000
@@ -125,8 +125,9 @@
 
     void onSessionCreatedSurface(::mir::scene::Session const*, std::shared_ptr<::mir::scene::Surface> const&);
 
-    void onProcessStartReportReceived(const QString& appId, const bool failure);
-    void onProcessStopped(const QString& appId, const bool unexpected);
+    void onProcessFailed(const QString& appId, const bool duringStartup);
+    void onProcessStarting(const QString& appId);
+    void onProcessStopped(const QString& appId);
     void onFocusRequested(const QString& appId);
     void onResumeRequested(const QString& appId);
 
@@ -144,9 +145,8 @@
     Application* findApplicationWithSession(const ::mir::scene::Session *session);
     Application* applicationForStage(Application::Stage stage);
     QModelIndex findIndex(Application* application);
-    bool checkFocusOnRemovedApplication(Application* application);
-    void shutdownApplication(Application* application);
-    void stopStartingApplication(const QString &appId);
+    bool isFocused(Application* application);
+    bool checkFocusOnRemovedApplication(Application *application);
 
     QList<Application*> m_applications;
     Application* m_focusedApplication; // remove as Mir has API for this

=== modified file 'src/modules/Unity/Application/taskcontroller.cpp'
--- src/modules/Unity/Application/taskcontroller.cpp	2014-05-12 11:09:42 +0000
+++ src/modules/Unity/Application/taskcontroller.cpp	2014-05-20 12:42:58 +0000
@@ -34,11 +34,8 @@
 // STL
 #include <mutex>
 
-// glib
-#include <glib.h>
-
 // std
-#include <signal.h>
+#include <csignal>
 #include <unistd.h>
 
 namespace unitymir
@@ -55,7 +52,7 @@
     connect(m_appController.data(),
             &ApplicationController::applicationAboutToBeStarted,
             this,
-            &TaskController::onApplicationAboutToBeStarted);
+            &TaskController::processStarting);
 
     connect(m_appController.data(),
             &ApplicationController::applicationStarted,
@@ -65,7 +62,7 @@
     connect(m_appController.data(),
             &ApplicationController::applicationStopped,
             this,
-            &TaskController::onApplicationStopped);
+            &TaskController::processStopped);
 
     connect(m_appController.data(),
             &ApplicationController::applicationFocusRequest,
@@ -146,22 +143,12 @@
     }
 }
 
-void TaskController::onApplicationAboutToBeStarted(const QString& id)
-{
-    Q_EMIT processStartReport(id, false);
-}
-
 void TaskController::onApplicationStarted(const QString& id)
 {
     pid_t pid = m_appController->primaryPidForAppId(id);
     m_processController->oomController()->ensureProcessUnlikelyToBeKilled(pid);
 }
 
-void TaskController::onApplicationStopped(const QString& id)
-{
-    Q_EMIT processStopped(id, false);
-}
-
 void TaskController::onApplicationFocusRequest(const QString& id)
 {
     pid_t pid = m_appController->primaryPidForAppId(id);
@@ -176,15 +163,7 @@
 
 void TaskController::onApplicationError(const QString& id, ApplicationController::Error error)
 {
-    switch(error)
-    {
-    case ApplicationController::Error::APPLICATION_CRASHED:
-        Q_EMIT processStopped(id, true);
-        break;
-    case ApplicationController::Error::APPLICATION_FAILED_TO_START:
-        Q_EMIT processStartReport(id, true);
-        break;
-    }
+    Q_EMIT processFailed(id, (error == ApplicationController::Error::APPLICATION_FAILED_TO_START) );
 
     // Is this really the signal we want to emit?
     Q_EMIT requestResume(id);

=== modified file 'src/modules/Unity/Application/taskcontroller.h'
--- src/modules/Unity/Application/taskcontroller.h	2014-05-12 11:09:42 +0000
+++ src/modules/Unity/Application/taskcontroller.h	2014-05-20 12:42:58 +0000
@@ -48,15 +48,14 @@
     QFileInfo findDesktopFileForAppId(const QString &appId) const;
 
 Q_SIGNALS:
-    void processStartReport(const QString& appId, const bool failure);
-    void processStopped(const QString& appId, const bool unexpectedly);
+    void processStarting(const QString& appId);
+    void processStopped(const QString& appId);
+    void processFailed(const QString& appId, const bool duringStartup);
     void requestFocus(const QString& appId);
     void requestResume(const QString& appId);
 
 private Q_SLOTS:
-    void onApplicationAboutToBeStarted(const QString& id);
     void onApplicationStarted(const QString& id);
-    void onApplicationStopped(const QString& id);
     void onApplicationFocusRequest(const QString& id);
     void onApplicationResumeRequest(const QString& id);
 

=== modified file 'src/unity-mir/qmirserver.cpp'
--- src/unity-mir/qmirserver.cpp	2014-04-09 15:47:05 +0000
+++ src/unity-mir/qmirserver.cpp	2014-05-20 12:42:58 +0000
@@ -19,6 +19,7 @@
 #include <mir/abnormal_exit.h>
 #include <mir/default_server_configuration.h>
 #include <mir/display_server.h>
+#include <mir/main_loop.h>
 
 // Platform API
 #include <application/ubuntu_application_api_mirserver_priv.h>
@@ -30,9 +31,11 @@
 
 // Std
 #include <chrono>
+#include <csignal>
 #include <thread>
 
 // local
+#include "logging.h"
 #include "qmirserver.h"
 
 QMirServer::QMirServer(int argc, const char* argv[], QObject *parent)
@@ -53,19 +56,35 @@
     auto argv = m_argv;
     auto config = new ShellServerConfiguration(m_argc, m_argv);
     std::thread *t;
+    bool mirServerShutDown = false;
 
-    mir::run_mir(*config, [config, &client, &argc, &argv, &t](mir::DisplayServer& server) {
+    mir::run_mir(*config, [&](mir::DisplayServer &server) {
         ua_ui_mirserver_init(*config);
 
+        // Mir initiates shutdown on SIGINT & SIGTERM, need to distinguish that shutdown from a
+        // client-initiated shutdown. Do this by installing a custom signal handler that is run
+        // after Mir's initiate-shutdown handler is called.
+        config->the_main_loop()->register_signal_handler(
+        {SIGINT, SIGTERM},
+        [&](int)
+        {
+            DLOG("Mir-initiated shut down in progress");
+            mirServerShutDown = true;
+        });
+
         try {
             t = new std::thread([&]() {
                 client (argc, argv, config);
-                server.stop();
+                if (!mirServerShutDown) {
+                    DLOG("Qt-initiated shut down in progress");
+                    server.stop();
+                }
             });
         } catch (...) {
-            qDebug() << "Exception caught, quitting";
+            LOG("Exception caught, quitting");
         }
     });
+
     if (QCoreApplication::instance()) {
         bool aboutToQuitSignaled = false;
         QObject::connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit, [&]() {

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-03-25 11:05:42 +0000
+++ tests/CMakeLists.txt	2014-05-20 12:42:58 +0000
@@ -24,14 +24,27 @@
   ${QT_TEST}
 )
 
+set(
+  MOCK_HEADERS
+  mock_application_controller.h
+  mock_desktop_file_reader.h
+  mock_focus_controller.h
+  mock_oom_controller.h
+  mock_process_controller.h
+  mock_proc_info.h
+  mock_session.h
+)
+
 add_executable(
   application_manager_test
   application_manager_test.cpp
+  ${MOCK_HEADERS}
 )
 
 add_executable(
   taskcontroller_test
   taskcontroller_test.cpp
+  ${MOCK_HEADERS}
 )
 
 # We should not need this line according to the Qt5/CMake docs.

=== modified file 'tests/application_manager_test.cpp'
--- tests/application_manager_test.cpp	2014-05-13 17:23:22 +0000
+++ tests/application_manager_test.cpp	2014-05-20 12:42:58 +0000
@@ -45,18 +45,22 @@
             QSharedPointer<ProcessController::OomController> (
                 &oomController,
                 [](ProcessController::OomController*){})
-        },
-        applicationManager{
-            QSharedPointer<TaskController>{
-                new TaskController(
-                    nullptr,
-                    QSharedPointer<ApplicationController>(
-                        &appController,
-                        [](ApplicationController*){}),
-                    QSharedPointer<ProcessController>(
-                        &processController,
-                        [](ProcessController*){})
-                    )},
+        }
+        , taskController{
+              QSharedPointer<TaskController> (
+                  new TaskController(
+                      nullptr,
+                      QSharedPointer<ApplicationController>(
+                          &appController,
+                          [](ApplicationController*){}),
+                      QSharedPointer<ProcessController>(
+                          &processController,
+                          [](ProcessController*){})
+                  )
+              )
+        }
+        , applicationManager{
+            taskController,
             QSharedPointer<DesktopFileReader::Factory>(
                 &desktopFileReaderFactory,
                 [](DesktopFileReader::Factory*){}),
@@ -72,6 +76,7 @@
     testing::NiceMock<testing::MockProcInfo> procInfo;
     testing::NiceMock<testing::MockDesktopFileReaderFactory> desktopFileReaderFactory;
     testing::NiceMock<testing::MockFocusController> focusController;
+    QSharedPointer<TaskController> taskController;
     ApplicationManager applicationManager;
 };
 
@@ -167,7 +172,7 @@
 
     // now a second session without desktop file is launched:
     applicationManager.authorizeSession(secondProcId, authed);
-    applicationManager.onProcessStartReportReceived(dialer_app_id, true);
+    applicationManager.onProcessStarting(dialer_app_id);
 
     EXPECT_EQ(false,authed);
     EXPECT_EQ(app,applicationManager.findApplication(dialer_app_id));
@@ -191,7 +196,8 @@
     applicationManager.authorizeSession(procId, authed);
     applicationManager.onSessionStarting(mirSession);
     Application * beforeFailure = applicationManager.findApplication(app_id);
-    applicationManager.onProcessStartReportReceived(app_id,true);
+    applicationManager.onProcessStarting(app_id);
+    applicationManager.onProcessFailed(app_id, true);
     Application * afterFailure = applicationManager.findApplication(app_id);
 
     EXPECT_EQ(true, authed);
@@ -218,7 +224,8 @@
     applicationManager.onSessionStarting(mirSession);
     Application * beforeFailure = applicationManager.findApplication(app_id);
     applicationManager.onSessionCreatedSurface(mirSession.get(), aSurface);
-    applicationManager.onProcessStartReportReceived(app_id, true);
+    applicationManager.onProcessStarting(app_id);
+    applicationManager.onProcessFailed(app_id, false);
     Application * afterFailure = applicationManager.findApplication(app_id);
 
     EXPECT_EQ(true, authed);
@@ -394,7 +401,7 @@
     ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
 
     // mock upstart launching an app which reports itself as sidestage, but we're on phone
-    applicationManager.onProcessStartReportReceived(appId, false);
+    applicationManager.onProcessStarting(appId);
 
     // ensure the app stage is overridden to be main stage
     Application* theApp = applicationManager.findApplication(appId);
@@ -513,3 +520,1276 @@
     QList<QVariant> arguments = spy.takeFirst(); // take the first signal
     EXPECT_EQ(arguments.at(0).toString(), "app3");
 }
+
+/*
+ * Test that an application launched by shell itself creates the correct Application instance and
+ * emits signals indicating the model updated
+ */
+TEST_F(ApplicationManagerTests,appStartedByShell)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    const QString name("Test App");
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+    ON_CALL(*mockDesktopFileReader, name()).WillByDefault(Return(name));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy addedSpy(&applicationManager, SIGNAL(applicationAdded(const QString &)));
+
+    // start the application
+    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);
+
+    // 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);
+
+    // check application in list of apps
+    Application *theAppAgain = applicationManager.findApplication(appId);
+    EXPECT_EQ(theAppAgain, theApp);
+}
+
+/*
+ * Test that an application launched upstart (i.e. not by shell itself) creates the correct Application
+ * instance and emits signals indicating the model updated
+ */
+TEST_F(ApplicationManagerTests,appStartedByUpstart)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    const QString name("Test App");
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+    ON_CALL(*mockDesktopFileReader, name()).WillByDefault(Return(name));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy addedSpy(&applicationManager, SIGNAL(applicationAdded(const QString &)));
+    QSignalSpy focusSpy(&applicationManager, SIGNAL(focusRequested(const QString &)));
+
+    // upstart sends notification that the application was started
+    applicationManager.onProcessStarting(appId);
+
+    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);
+
+    // 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);
+}
+
+/*
+ * Test that an application launched via the command line with a correct --desktop_file_hint is accepted,
+ * creates the correct Application instance and emits signals indicating the model updated
+ */
+TEST_F(ApplicationManagerTests,appStartedUsingCorrectDesktopFileHintSwitch)
+{
+    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));
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy addedSpy(&applicationManager, SIGNAL(applicationAdded(const QString &)));
+
+    // Mir requests authentication for an application that was started
+    bool authed = false;
+    applicationManager.authorizeSession(procId, authed);
+    EXPECT_EQ(authed, true);
+
+    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(), false);
+
+    // 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);
+}
+
+/*
+ * Test that an application launched via the command line without the correct --desktop_file_hint is rejected
+ */
+TEST_F(ApplicationManagerTests,appDoesNotStartWhenUsingBadDesktopFileHintSwitch)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    const QString name("Test App");
+    quint64 procId = 5551;
+    QByteArray cmdLine("/usr/bin/testApp");
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy addedSpy(&applicationManager, SIGNAL(applicationAdded(const QString &)));
+
+    // Mir requests authentication for an application that was started
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    EXPECT_EQ(authed, false);
+
+    Application *theApp = applicationManager.findApplication(appId);
+
+    EXPECT_EQ(theApp, nullptr);
+
+    // check no new signals were emitted
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(applicationManager.count(), 0);
+    EXPECT_EQ(addedSpy.count(), 0);
+}
+
+/*
+ * Test that an application launched via the command line with the --desktop_file_hint but an incorrect
+ * desktop file specified is rejected
+ */
+TEST_F(ApplicationManagerTests,appDoesNotStartWhenUsingBadDesktopFileHintFile)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+    const QString badDesktopFile = QString("%1.desktop").arg(appId);
+    quint64 procId = 5551;
+    QByteArray cmdLine("/usr/bin/testApp --desktop_file_hint=");
+    cmdLine = cmdLine.append(badDesktopFile);
+
+    // 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(false));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    // Mir requests authentication for an application that was started, should fail
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    EXPECT_EQ(authed, false);
+}
+
+/*
+ * Test that the child sessions of a webapp process are accepted
+ */
+TEST_F(ApplicationManagerTests,webAppSecondarySessionsAccepted)
+{
+    using namespace ::testing;
+    quint64 procId = 5551;
+    QByteArray cmdLine("/usr/bin/qt5/libexec/QtWebProcess");
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    bool authed = false;
+    applicationManager.authorizeSession(procId, authed);
+    EXPECT_EQ(authed, true);
+}
+
+/*
+ * Test that signon-ui sessions are accepted
+ */
+TEST_F(ApplicationManagerTests,signonUiSessionsAccepted)
+{
+    using namespace ::testing;
+    quint64 procId = 5151;
+    QByteArray cmdLine("/usr/bin/signon-ui --blah=http://signon-ui");
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    bool authed = false;
+    applicationManager.authorizeSession(procId, authed);
+    EXPECT_EQ(authed, true);
+}
+
+/*
+ * Test that maliit sessions are accepted
+ */
+TEST_F(ApplicationManagerTests,maliitSessionsAccepted)
+{
+    using namespace ::testing;
+    quint64 procId = 151;
+    QByteArray cmdLine("maliit-server --blah");
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    bool authed = false;
+    applicationManager.authorizeSession(procId, authed);
+    EXPECT_EQ(authed, true);
+}
+
+/*
+ * Test that an application in the Starting state is not impacted by the upstart "Starting" message
+ * for that application (i.e. the upstart message is effectively useless)
+ */
+TEST_F(ApplicationManagerTests,onceAppAddedToApplicationLists_upstartStartingEventIgnored)
+{
+    using namespace ::testing;
+    const QString appId("testAppId");
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    applicationManager.startApplication(appId, ApplicationManager::NoFlag);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy addedSpy(&applicationManager, SIGNAL(applicationAdded(const QString &)));
+
+    // upstart sends notification that the application was started
+    applicationManager.onProcessStarting(appId);
+
+    // check no new signals were emitted and application state unchanged
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(applicationManager.count(), 1);
+    EXPECT_EQ(addedSpy.count(), 0);
+
+    Application *theApp = applicationManager.findApplication(appId);
+    EXPECT_EQ(Application::Starting, theApp->state());
+}
+
+/*
+ * Test that an application in the Starting state reacts correctly to the Mir sessionStarted
+ * event for that application (i.e. the Session is associated)
+ */
+TEST_F(ApplicationManagerTests,onceAppAddedToApplicationLists_mirSessionStartingEventHandled)
+{
+    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);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy addedSpy(&applicationManager, SIGNAL(applicationAdded(const QString &)));
+
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+
+    // Authorize session and emit Mir sessionStarting event
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(applicationManager.count(), 1);
+    EXPECT_EQ(addedSpy.count(), 0);
+
+    // Check application state and session are correctly set
+    Application *theApp = applicationManager.findApplication(appId);
+    EXPECT_EQ(theApp->session(), session);
+    EXPECT_EQ(theApp->focused(), false);
+}
+
+/*
+ * Test that an application in the Starting state reacts correctly to the Mir surfaceCreated
+ * event for that application (i.e. the Surface is associated and state set to Running)
+ */
+TEST_F(ApplicationManagerTests,onceAppAddedToApplicationLists_mirSurfaceCreatedEventHandled)
+{
+    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);
+
+    QSignalSpy dataSpy(&applicationManager, SIGNAL(dataChanged(QModelIndex,QModelIndex)));
+    QSignalSpy focusSpy(&applicationManager, SIGNAL(focusedApplicationIdChanged()));
+
+    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
+
+    bool authed = true;
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+
+    EXPECT_EQ(dataSpy.count(), 1);
+    EXPECT_EQ(focusSpy.count(), 1);
+
+    // Check application state is correctly set
+    Application *theApp = applicationManager.findApplication(appId);
+    EXPECT_EQ(theApp->state(), Application::Running);
+    EXPECT_EQ(theApp->focused(), true);
+
+    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
+}
+
+/*
+ * Test that an application is stopped correctly, if it has not yet created a surface (still in Starting state)
+ */
+TEST_F(ApplicationManagerTests,shellStopsAppCorrectlyBeforeSurfaceCreated)
+{
+    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);
+    applicationManager.onSessionStarting(session);
+
+    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 foreground application is stopped correctly (is in Running state, has surface)
+ */
+TEST_F(ApplicationManagerTests,shellStopsForegroundAppCorrectly)
+{
+    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);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    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);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    applicationManager.onSessionUnfocused();
+
+    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);
+    applicationManager.onSessionStarting(session);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    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(removedSpy.count(), 1);
+    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
+}
+
+/*
+ * Test that if the foreground Running application is stopped by upstart, AppMan cleans up after it ok
+ */
+TEST_F(ApplicationManagerTests,upstartNotifiesOfStoppingForegroundApp)
+{
+    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);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    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(removedSpy.count(), 1);
+    EXPECT_EQ(removedSpy.takeFirst().at(0).toString(), appId);
+}
+
+/*
+ * 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_F(ApplicationManagerTests,upstartNotifiesOfUnexpectedStopOfForegroundApp)
+{
+    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);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Upstart notifies of crashing / OOM killed app
+    applicationManager.onProcessFailed(appId, false);
+
+    // Upstart finally notifies the app stopped
+    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);
+}
+
+/*
+ * 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);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    applicationManager.onSessionUnfocused();
+    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
+ * a dodgy app crashing.
+ */
+TEST_F(ApplicationManagerTests,unexpectedStopOfBackgroundApp)
+{
+    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);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    applicationManager.onSessionUnfocused();
+    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy focusSpy(&applicationManager, SIGNAL(focusedApplicationIdChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir reports disconnection
+    applicationManager.onSessionStopping(session);
+
+    // Upstart notifies of crashing / OOM-killed app
+    applicationManager.onProcessFailed(appId, false);
+
+    EXPECT_EQ(focusSpy.count(), 0);
+
+    // Upstart finally notifies the app stopped
+    applicationManager.onProcessStopped(appId);
+
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(applicationManager.count(), 1);
+    EXPECT_EQ(removedSpy.count(), 0);
+}
+
+/*
+ * Test that if a background application is reported to have stopped on startup by upstart, that it
+ * is kept in the application model, as the app can be lifecycle resumed.
+ *
+ * Note that upstart reports this "stopped on startup" even for applications which are running.
+ * This may be an upstart bug, or AppMan mis-understanding upstart's intentions. But need to check
+ * we're doing the right thing in either case. CHECKME(greyback)!
+ */
+TEST_F(ApplicationManagerTests,unexpectedStopOfBackgroundAppCheckingUpstartBug)
+{
+    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);
+    applicationManager.onSessionStarting(session);
+
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session.get(), surface);
+    applicationManager.onSessionUnfocused();
+    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy focusSpy(&applicationManager, SIGNAL(focusedApplicationIdChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir reports disconnection
+    applicationManager.onSessionStopping(session);
+
+    // Upstart notifies of crashing app
+    applicationManager.onProcessFailed(appId, true);
+
+    EXPECT_EQ(focusSpy.count(), 0);
+
+    // Upstart finally notifies the app stopped
+    applicationManager.onProcessStopped(appId);
+
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(applicationManager.count(), 1);
+    EXPECT_EQ(removedSpy.count(), 0);
+}
+
+/*
+ * Test that if a Starting application is then reported to be stopping by Mir, AppMan cleans up after it ok
+ */
+TEST_F(ApplicationManagerTests,mirNotifiesStartingAppIsNowStopping)
+{
+    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);
+    applicationManager.onSessionStarting(session);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app
+    applicationManager.onSessionStopping(session);
+
+    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 a Running foreground application is reported to be stopping by Mir, AppMan cleans up after it ok
+ */
+TEST_F(ApplicationManagerTests,mirNotifiesOfStoppingForegroundApp)
+{
+    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);
+    applicationManager.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);
+    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app
+    applicationManager.onSessionStopping(session);
+
+    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 a foreground 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)
+{
+    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);
+    applicationManager.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);
+    EXPECT_EQ(applicationManager.focusedApplicationId(), appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app
+    applicationManager.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);
+}
+
+/*
+ * Test that if a background application is reported to be stopping by Mir, AppMan sets its state to Stopped
+ * but does not remove it from the model
+ */
+TEST_F(ApplicationManagerTests,mirNotifiesOfStoppingBackgroundApp)
+{
+    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);
+    applicationManager.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.onSessionUnfocused();
+    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app
+    applicationManager.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);
+    applicationManager.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.onSessionUnfocused();
+    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app
+    applicationManager.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);
+}
+
+/*
+ * Test that when an application is stopped correctly by shell, the upstart stopping event is ignored
+ */
+TEST_F(ApplicationManagerTests,shellStoppedApp_upstartStoppingEventIgnored)
+{
+    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);
+    applicationManager.onSessionStarting(session);
+
+    applicationManager.stopApplication(appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Upstart notifies of stopping app
+    applicationManager.onProcessStopped(appId);
+
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 0);
+}
+
+/*
+ * Test that when an application is stopped correctly by shell, the Mir Session stopped event is ignored
+ */
+TEST_F(ApplicationManagerTests,shellStoppedApp_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);
+    applicationManager.onSessionStarting(session);
+
+    applicationManager.stopApplication(appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app/Session
+    applicationManager.onSessionStopping(session);
+
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 0);
+}
+
+/*
+ * 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);
+    applicationManager.onSessionStarting(session);
+
+    applicationManager.onProcessStopped(appId);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app
+    applicationManager.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
+ */
+TEST_F(ApplicationManagerTests,unexpectedStopOfForegroundWebapp)
+{
+    using namespace ::testing;
+    const QString appId("webapp");
+    quint64 procId1 = 5551;
+    quint64 procId2 = 5564;
+    QByteArray cmdLine("/usr/bin/qt5/libexec/QtWebProcess");
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId2))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    ON_CALL(appController,appIdHasProcessId(procId1, appId)).WillByDefault(Return(true));
+    ON_CALL(appController,appIdHasProcessId(procId2, _)).WillByDefault(Return(false));
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    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);
+
+    bool authed = false;
+    applicationManager.authorizeSession(procId1, authed);
+    applicationManager.onSessionStarting(session1);
+    EXPECT_EQ(authed, true);
+    applicationManager.authorizeSession(procId2, authed);
+    applicationManager.onSessionStarting(session2);
+    EXPECT_EQ(authed, true);
+    std::shared_ptr<mir::scene::Surface> surface(nullptr);
+    applicationManager.onSessionCreatedSurface(session2.get(), surface);
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app/Session
+    applicationManager.onSessionStopping(session2);
+    applicationManager.onSessionStopping(session1);
+
+    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);
+}
+
+/*
+ * Webapps have multiple sessions, but only one is linked to the application (other is considered a hidden session).
+ * If webapp in background stops unexpectedly, do not remove it from app list
+ */
+TEST_F(ApplicationManagerTests,unexpectedStopOfBackgroundWebapp)
+{
+    using namespace ::testing;
+    const QString appId("webapp");
+    quint64 procId1 = 5551;
+    quint64 procId2 = 5564;
+    QByteArray cmdLine("/usr/bin/qt5/libexec/QtWebProcess");
+
+    // Set up Mocks & signal watcher
+    EXPECT_CALL(procInfo,command_line(procId2))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    ON_CALL(appController,appIdHasProcessId(procId1, appId)).WillByDefault(Return(true));
+    ON_CALL(appController,appIdHasProcessId(procId2, _)).WillByDefault(Return(false));
+
+    // Set up Mocks & signal watcher
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+
+    ON_CALL(desktopFileReaderFactory, createInstance(appId, _)).WillByDefault(Return(mockDesktopFileReader));
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, _))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    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);
+
+    bool authed = false;
+    applicationManager.authorizeSession(procId1, authed);
+    applicationManager.onSessionStarting(session1);
+    EXPECT_EQ(authed, true);
+    applicationManager.authorizeSession(procId2, authed);
+    applicationManager.onSessionStarting(session2);
+    EXPECT_EQ(authed, true);
+
+    // 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.onSessionUnfocused();
+    EXPECT_EQ(applicationManager.focusedApplicationId(), QString());
+
+    QSignalSpy countSpy(&applicationManager, SIGNAL(countChanged()));
+    QSignalSpy removedSpy(&applicationManager, SIGNAL(applicationRemoved(const QString &)));
+
+    // Mir notifies of stopping app/Session
+    applicationManager.onSessionStopping(session2);
+    applicationManager.onSessionStopping(session1);
+
+    EXPECT_EQ(countSpy.count(), 0);
+    EXPECT_EQ(removedSpy.count(), 0);
+}

=== modified file 'tests/mock_session.h'
--- tests/mock_session.h	2014-04-15 14:31:02 +0000
+++ tests/mock_session.h	2014-05-20 12:42:58 +0000
@@ -15,8 +15,8 @@
  *
  */
 
-#ifndef MOCK_MIR_SHELL_SESSION_H
-#define MOCK_MIR_SHELL_SESSION_H
+#ifndef MOCK_MIR_SCENE_SESSION_H
+#define MOCK_MIR_SCENE_SESSION_H
 
 #include <mir/scene/session.h>
 #include <mir/graphics/display_configuration.h>
@@ -66,4 +66,4 @@
 };
 }
 
-#endif // MOCK_MIR_SHELL_SESSION_H
+#endif // MOCK_MIR_SCENE_SESSION_H