QtMir

Merge lp:~dandrader/qtmir/appRestart-lp1527737 into lp:qtmir

appRestart-lp1527737
Merge into trunk

Proposed by Daniel d'Andrada on 2016-06-22

Status:

Work in progress

Proposed branch:

lp:~dandrader/qtmir/appRestart-lp1527737

Merge into:

lp:qtmir

Diff against target:

472 lines (+271/-63)

7 files modified

src/modules/Unity/Application/application_manager.cpp (+81/-61)
src/modules/Unity/Application/application_manager.h (+1/-1)
src/modules/Unity/Application/taskcontroller.h (+5/-1)
src/modules/Unity/Application/upstart/taskcontroller.cpp (+8/-0)
src/modules/Unity/Application/upstart/taskcontroller.h (+2/-0)
tests/framework/mock_task_controller.h (+1/-0)
tests/modules/ApplicationManager/application_manager_test.cpp (+173/-0)

To merge this branch:

bzr merge lp:~dandrader/qtmir/appRestart-lp1527737

High

Confirmed

Link a bug report

Reviewer	Review Type	Date Requested	Status
Michael Zanetti (community)			Abstain on 2016-07-04
Unity8 CI Bot	continuous-integration	2016-06-22	Approve on 2016-06-28
Michał Sawicz		2016-06-22	Needs Fixing on 2016-06-28
Nick Dedekind (community)		2016-06-22	Approve on 2016-06-22
Gerry Boland		2016-06-22	Pending
PS Jenkins bot	continuous-integration	2016-06-22	Pending
Review via email: mp+298125@code.launchpad.net

This proposal supersedes a proposal from 2016-06-16.

Commit Message

Handle case where TaskController requests an application that is already closing

Happens when you quickly close an application and then tap on its icon in the dash

Description of the Change

* Are there any related MPs required for this MP to build/function as expected? Please list.
No

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

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

Daniel d'Andrada (dandrader) wrote on 2016-06-16: Posted in a previous version of this proposal

Fresh start. Rebased on top of latest trunk.

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-16: Posted in a previous version of this proposal

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

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-19: Posted in a previous version of this proposal

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

review: Approve (continuous-integration)

Nick Dedekind (nick-dedekind) wrote on 2016-06-22: Posted in a previous version of this proposal

small comments.
Otherwise logic looks fine and passes tests.

review: Needs Fixing

Daniel d'Andrada (dandrader) wrote on 2016-06-22: Posted in a previous version of this proposal

On 22/06/2016 11:29, Nick Dedekind wrote:
>> +// std
>> >+#include <csignal>
> remove from application_manager.cpp?
>

I tried, but it won't compile otherwise. It's needed for the
"raise(SIGSTOP);" line.

Daniel d'Andrada (dandrader) wrote on 2016-06-22: Posted in a previous version of this proposal

On 22/06/2016 11:29, Nick Dedekind wrote:
>> + Application *application = findApplication(appId);
> bit of a optimization. move this to after the check for queued/closing apps.
>

Done.

Nick Dedekind (nick-dedekind) wrote on 2016-06-22:

* Did you perform an exploratory manual test run of the code change and any related functionality?
Yes

* Did CI run pass? If not, please explain why.
Yes.

review: Approve

Michael Zanetti (mzanetti) wrote on 2016-06-28:

Found a regression in Silo testing:

* Launch the telegram app
* Launch the gallery
* share a picture from the gallery to telegram

Expected: Telegram app focused
Actual: Focus stays in gallery

review: Needs Fixing

Michał Sawicz (saviq) wrote on 2016-06-28:

This breaks sharing to an already running app:
- start Telegram
- go to Gallery
- share to Telegram
- BREAKAGE (should focus Telegram, is back to gallery instead)

review: Needs Fixing

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-28:

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

review: Approve (continuous-integration)

lp:~dandrader/qtmir/appRestart-lp1527737 updated on 2016-06-28

523. By Daniel d'Andrada on 2016-06-28

Fix bad rebase on top of latest trunk

Code was still using the old, deprecated signal.

Daniel d'Andrada (dandrader) wrote on 2016-06-28:

> Found a regression in Silo testing:
>
> * Launch the telegram app
> * Launch the gallery
> * share a picture from the gallery to telegram
>
> Expected: Telegram app focused
> Actual: Focus stays in gallery

Fixed. It was caused by a bad rebase with latest trunk. The original branch was so old it was still using a deprecated signal.

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-28:

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

review: Approve (continuous-integration)

Michael Zanetti (mzanetti) wrote on 2016-07-04:

Ok. It fixes the regression it had. But tbh in my opinion it doesn't behave totally great for the actual bug it tries to fix. When I close an app and quickly try to relaunch it, I get a haptics feedback from the apps scope, but no splash screen appearing. Only after some seconds later starting the app starts working. But I see there's a TODO in the code for exactly this, so... At least it's not worse than having the splash screen "crashing" as we had it before.

review: Abstain

Albert Astals Cid (aacid) wrote on 2017-03-13:

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

Unmerged revisions

523. By Daniel d'Andrada on 2016-06-28

Fix bad rebase on top of latest trunk

Code was still using the old, deprecated signal.

522. By Daniel d'Andrada on 2016-06-22

Optimize code

521. By Daniel d'Andrada on 2016-06-22

Handle case where TaskController requests an application that is already closing

Happens when you quickly close an application and then tap on its icon in the dash

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Daniel d'Andrada

Mir development team

 === modified file 'src/modules/Unity/Application/application_manager.cpp'
 --- src/modules/Unity/Application/application_manager.cpp	2016-05-06 08:41:15 +0000
 +++ src/modules/Unity/Application/application_manager.cpp	2016-06-28 14:10:50 +0000
@@ -56,6 +56,8 @@
  namespace unityapi = unity::shell::application;
  #define DEBUG_MSG qCDebug(QTMIR_APPLICATIONS).nospace() << "ApplicationManager::" << __func__
++#define WARNING_MSG qCWarning(QTMIR_APPLICATIONS).nospace() << "ApplicationManager::" << __func__
++#define CRITICAL_MSG qCCritical(QTMIR_APPLICATIONS).nospace() << "ApplicationManager::" << __func__
  namespace qtmir
+ {
@@ -102,8 +104,10 @@
                       manager, &ApplicationManager::onProcessFailed);
      QObject::connect(controller, &TaskController::focusRequested,
                       manager, &ApplicationManager::onFocusRequested);
++    // We interpret this as a focus request for a suspended app.
++    // Shell will have this app resumed if it complies with the focus request
      QObject::connect(controller, &TaskController::resumeRequested,
--                     manager, &ApplicationManager::onResumeRequested);
++                     manager, &ApplicationManager::onFocusRequested);
+ }
  } // namespace
@@ -368,35 +372,61 @@
  void ApplicationManager::onProcessStarting(const QString &appId)
+ {
      tracepoint(qtmir, onProcessStarting);
--    qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onProcessStarting - appId=" << appId;
--
--    Application *application = findApplication(appId);
--    if (!application) { // then shell did not start this application, so ubuntu-app-launch must have - add to list
--        auto appInfo = m_taskController->getInfoForApp(appId);
--        if (!appInfo) {
--            qCWarning(QTMIR_APPLICATIONS) << "ApplicationManager::onProcessStarting - Unable to instantiate application with appId" << appId;
--            return;
--        }
--
--        application = new Application(
--                    m_sharedWakelock,
--                    appInfo,
--                    QStringList(),
--                    this);
--        add(application);
--        application->requestFocus();
--    }
--    else {
--        if (application->internalState() == Application::InternalState::StoppedResumable) {
--            // 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->requestFocus();
--        } else {
--            qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onProcessStarting application already found with appId"
--                                        << appId;
--        }
--    }
++
++    Application *application = nullptr;
++
++    application = findClosingApplication(appId);
++    if (application) {
++        // TODO: We should create a new Application instance right away in order to give immediate
++        // feedback to the user, even though there's no actual process backing it up yet.
++        if (!m_queuedStartApplications.contains(appId)) {
++            m_queuedStartApplications.append(appId);
++            DEBUG_MSG << "(" << appId << ") User wants to start a new instance of an application that is still closing."
++                " Queuing its start.";
++            connect(application, &QObject::destroyed, this, [this, appId]() {
++                    m_queuedStartApplications.removeAll(appId);
++                    startApplication(appId, QStringList());
++                }, Qt::QueuedConnection); // Queued so that we finish the app removal before starting again.
++        } else {
++            // Just ignore it.
++            DEBUG_MSG << "(" << appId << ") User wants to start a new instance of an application that is still closing"
++                " and is already queued to start later.";
++        }
++    } else {
++        application = findApplication(appId);
++        if (!application) { // then shell did not start this application, so ubuntu-app-launch must have - add to list
++            createNewApplication(appId);
++        } else {
++            if (application->internalState() == Application::InternalState::StoppedResumable) {
++                // 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).
++                DEBUG_MSG << "(" << appId << ") Stopped application is being resumed externally";
++                application->requestFocus();
++            } else {
++                DEBUG_MSG << "(" << appId << ") application already exists";
++            }
++            application->setProcessState(Application::ProcessRunning);
++        }
++    }
++}
++
++void ApplicationManager::createNewApplication(const QString &appId)
++{
++    DEBUG_MSG << "(" << appId << ")";
++
++    auto appInfo = m_taskController->getInfoForApp(appId);
++    if (!appInfo) {
++        WARNING_MSG << "(" << appId << ") Unable to instantiate application";
++        return;
++    }
++
++    auto application = new Application(
++                m_sharedWakelock,
++                appInfo,
++                QStringList(),
++                this);
++    add(application);
++    application->requestFocus();
      application->setProcessState(Application::ProcessRunning);
+ }
@@ -412,7 +442,7 @@
      Application *application = findApplication(appId);
      if (!application) {
--        qCritical() << "No such running application with appId" << appId;
++        CRITICAL_MSG << "(" << inputAppId << ") No such running application";
          return false;
+     }
@@ -454,14 +484,18 @@
      tracepoint(qtmir, onProcessStopped);
      qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onProcessStopped - appId=" << appId;
--    Application *application = findApplication(appId);
++    // TaskController doesn't give us any PID so we have no way of telling apart two instances
++    // of an application.
++    // The only situation where we expect to have two simultaneous instances is where there's one
++    // closing and a newer one just starting, in which case we assume he's referring to the former.
++    Application *application = findClosingApplication(appId);
      if (!application) {
--        application = findClosingApplication(appId);
++        application = findApplication(appId);
+     }
      if (!application) {
--        qDebug() << "ApplicationManager::onProcessStopped reports stop of appId=" << appId
--                 << "which AppMan is not managing, ignoring the event";
++        // Might happen if the onProcessFailed() was called for this app and it already got deleted in response.
++        DEBUG_MSG << "(" << appId << ") Not managing it, ignoring.";
          return;
+     }
@@ -490,29 +524,15 @@
  void ApplicationManager::onFocusRequested(const QString& appId)
+ {
--    qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onFocusRequested - appId=" << appId;
--
--    Application *application = findApplication(appId);
--    if (application) {
--        application->requestFocus();
--    }
--}
--
--void ApplicationManager::onResumeRequested(const QString& appId)
--{
--    qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onResumeRequested - appId=" << appId;
--
--    Application *application = findApplication(appId);
--
--    if (!application) {
--        qCritical() << "ApplicationManager::onResumeRequested: No such running application" << appId;
--        return;
--    }
--
--    // 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->requestFocus();
++    if (m_queuedStartApplications.contains(appId) || findClosingApplication(appId) != nullptr) {
++        DEBUG_MSG << "(" << appId << ") Ignoring request as the application is closing and/or queued to start";
++    } else {
++        Application *application = findApplication(appId);
++        if (application != nullptr) {
++            application->requestFocus();
++        } else {
++            WARNING_MSG << "(" << appId << ") No such running application";
++        }
+     }
+ }
@@ -702,9 +722,9 @@
      connect(application, &Application::stopProcessRequested, this, [=]() {
          if (!m_taskController->stop(appId) && application->pid() > 0) {
--            qWarning() << "FAILED to ask Upstart to stop application with appId" << appId
--                       << "Sending SIGTERM to process:" << appId;
--            kill(application->pid(), SIGTERM);
++            qCWarning(QTMIR_APPLICATIONS) << "FAILED to ask Upstart to stop application with appId" << appId
++                       << "Sending SIGTERM to process";
++            m_taskController->kill(application->pid());
              application->setProcessState(Application::ProcessStopped);
+         }
      });
 === modified file 'src/modules/Unity/Application/application_manager.h'
 --- src/modules/Unity/Application/application_manager.h	2016-05-05 15:02:01 +0000
 +++ src/modules/Unity/Application/application_manager.h	2016-06-28 14:10:50 +0000
@@ -111,7 +111,6 @@
      void onProcessSuspended(const QString& appId);
      void onProcessFailed(const QString& appId, TaskController::Error error);
      void onFocusRequested(const QString& appId);
--    void onResumeRequested(const QString& appId);
  Q_SIGNALS:
      void emptyChanged();
@@ -132,6 +131,7 @@
      QModelIndex findIndex(Application* application);
      void resumeApplication(Application *application);
      QString toString() const;
++    void createNewApplication(const QString &appId);
      Application* findApplicationWithPromptSession(const mir::scene::PromptSession* promptSession);
      Application *findClosingApplication(const QString &inputAppId) const;
 === modified file 'src/modules/Unity/Application/taskcontroller.h'
 --- src/modules/Unity/Application/taskcontroller.h	2016-04-22 14:03:26 +0000
 +++ src/modules/Unity/Application/taskcontroller.h	2016-06-28 14:10:50 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2014-2015 Canonical, Ltd.
++ * Copyright (C) 2014-2016 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
@@ -54,6 +54,10 @@
      virtual QSharedPointer<qtmir::ApplicationInfo> getInfoForApp(const QString &appId) const = 0;
++    // Not a perfect fit for this class but we need the kill(pid_t pid, int sig) function
++    // behind an interface so we can test it (replacing with a mock or fake)
++    virtual void kill(pid_t pid) = 0;
++
  Q_SIGNALS:
      void processStarting(const QString &appId);
      void applicationStarted(const QString &appId);
 === modified file 'src/modules/Unity/Application/upstart/taskcontroller.cpp'
 --- src/modules/Unity/Application/upstart/taskcontroller.cpp	2016-05-27 07:27:44 +0000
 +++ src/modules/Unity/Application/upstart/taskcontroller.cpp	2016-06-28 14:10:50 +0000
@@ -30,6 +30,9 @@
+ }
  #include <ubuntu-app-launch/registry.h>
++// std
++#include <csignal>
++
  namespace ual = ubuntu::app_launch;
  namespace qtmir
@@ -243,5 +246,10 @@
      return QSharedPointer<qtmir::ApplicationInfo>(appInfo);
+ }
++void TaskController::kill(pid_t pid)
++{
++    ::kill(pid, SIGTERM);
++}
++
  } // namespace upstart
  } // namespace qtmir
 === modified file 'src/modules/Unity/Application/upstart/taskcontroller.h'
 --- src/modules/Unity/Application/upstart/taskcontroller.h	2016-04-22 14:03:26 +0000
 +++ src/modules/Unity/Application/upstart/taskcontroller.h	2016-06-28 14:10:50 +0000
@@ -41,6 +41,8 @@
      QSharedPointer<qtmir::ApplicationInfo> getInfoForApp(const QString &appId) const override;
++    void kill(pid_t pid) override;
++
  private:
      struct Private;
      QScopedPointer<Private> impl;
 === modified file 'tests/framework/mock_task_controller.h'
 --- tests/framework/mock_task_controller.h	2016-04-22 14:03:26 +0000
 +++ tests/framework/mock_task_controller.h	2016-06-28 14:10:50 +0000
@@ -38,6 +38,7 @@
      MOCK_METHOD2(start, bool(const QString&, const QStringList&));
      MOCK_METHOD1(suspend, bool(const QString&));
      MOCK_METHOD1(resume, bool(const QString&));
++    MOCK_METHOD1(kill, void(pid_t pid));
      bool doAppIdHasProcessId(const QString& appId, pid_t pid);
 === modified file 'tests/modules/ApplicationManager/application_manager_test.cpp'
 --- tests/modules/ApplicationManager/application_manager_test.cpp	2016-05-30 14:50:26 +0000
 +++ tests/modules/ApplicationManager/application_manager_test.cpp	2016-06-28 14:10:50 +0000
@@ -1964,3 +1964,176 @@
      delete surface;
+ }
++
++/*
++ * Context:
++ *  - we are waiting for an application to quit following a close()
++ *
++ * Event:
++ *  - TaskController requests that application to be resumed.
++ *    Most likely because the user tapped the app icon in the Dash. From the user's
++ *    perspective the application is already closed and he wants to start a new
++ *    instance of it.
++ *    But from TaskController's perspective the application is still running and
++ *    therefore should just be resumed/focused.
++ *
++ * Expected outcome:
++ *  - ApplicationManager should wait for the closing application to finally end (or
++      be killed) and then finally launch a new instance of it.
++ *
++ * Regression test for https://bugs.launchpad.net/ubuntu/+source/qtmir/+bug/1527737
++ * "Apps do not start if restarted quickly after closing"
++ *
++ * Two test versions:
++ * _appQuits - Application complies and quits
++ * _appKilled - Application ignores close request and thus get killed
++ */
++TEST_F(ApplicationManagerTests, focusRequestedForClosingApplication_appQuits)
++{
++    using namespace ::testing;
++
++    int argc = 0;
++    char* argv[0];
++    QCoreApplication qtApp(argc, argv); // app for deleteLater event
++
++    const QString appId("testAppId");
++    quint64 procId = 5551;
++
++    ON_CALL(*taskController, appIdHasProcessId(appId, procId)).WillByDefault(Return(true));
++
++    EXPECT_CALL(*taskController, start(appId, _))
++        .Times(1)
++        .WillOnce(Return(true));
++
++    auto app = applicationManager.startApplication(appId);
++    applicationManager.onProcessStarting(appId);
++    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
++    bool authed = true;
++    applicationManager.authorizeSession(procId, authed);
++    ASSERT_TRUE(authed);
++    onSessionStarting(session);
++
++    FakeMirSurface *surface = new FakeMirSurface;
++    onSessionCreatedSurface(session.get(), surface);
++    surface->drawFirstFrame();
++
++    ASSERT_EQ(Application::InternalState::Running, app->internalState());
++
++    QSignalSpy closeRequestedSpy(surface, SIGNAL(closeRequested()));
++
++    // User swipes away the application, visually closing/removing it.
++    applicationManager.stopApplication(appId);
++
++    // But asking ApplicationManager to stop the application just makes it request its
++    // surfaces to be closed
++    EXPECT_EQ(Application::InternalState::Closing, app->internalState());
++    EXPECT_EQ(1, closeRequestedSpy.count());
++
++    // User then taps on the app icon
++    applicationManager.onProcessStarting(appId);
++    applicationManager.onFocusRequested(appId);
++
++    // But no application instance should have been created because of that
++    EXPECT_TRUE(applicationManager.findApplication(appId) == nullptr);
++
++    // ApplicationManager will ask TaskController to start the application again
++    // once the closing instance is gone
++    Mock::VerifyAndClearExpectations(taskController);
++    EXPECT_CALL(*taskController, start(appId, _))
++        .Times(1)
++        .WillOnce(Return(true));
++
++    // Simulates that the application complied to the close() request and stopped itself
++    onSessionStopping(session);
++    applicationManager.onProcessStopped(appId);
++
++    // DeferredDelete is special: likes to be called out specifically or it won't come out
++    qtApp.sendPostedEvents(app, QEvent::DeferredDelete);
++    qtApp.sendPostedEvents();
++
++    EXPECT_TRUE(applicationManager.findApplication(appId) != nullptr);
++}
++TEST_F(ApplicationManagerTests, focusRequestedForClosingApplication_appKilled)
++{
++    using namespace ::testing;
++
++    int argc = 0;
++    char* argv[0];
++    QCoreApplication qtApp(argc, argv); // app for deleteLater event
++
++    const QString appId("testAppId");
++    quint64 procId = 5551;
++
++    ON_CALL(*taskController, appIdHasProcessId(appId, procId)).WillByDefault(Return(true));
++
++    EXPECT_CALL(*taskController, start(appId, _))
++        .Times(1)
++        .WillOnce(Return(true));
++
++    auto app = applicationManager.startApplication(appId);
++    applicationManager.onProcessStarting(appId);
++    std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
++    bool authed = true;
++    applicationManager.authorizeSession(procId, authed);
++    ASSERT_TRUE(authed);
++    onSessionStarting(session);
++
++    FakeMirSurface *surface = new FakeMirSurface;
++    onSessionCreatedSurface(session.get(), surface);
++    surface->drawFirstFrame();
++
++    EXPECT_EQ(Application::InternalState::Running, app->internalState());
++
++    QSharedPointer<FakeTimeSource> fakeTimeSource(new FakeTimeSource);
++    FakeTimer *fakeStopTimer = new FakeTimer(fakeTimeSource);
++    app->setStopTimer(fakeStopTimer);
++
++    QSignalSpy closeRequestedSpy(surface, SIGNAL(closeRequested()));
++
++    // User swipes away the application, visually closing/removing it.
++    applicationManager.stopApplication(appId);
++
++    // But asking ApplicationManager to stop the application just makes it request its
++    // surfaces to be closed
++    EXPECT_EQ(Application::InternalState::Closing, app->internalState());
++    EXPECT_EQ(1, closeRequestedSpy.count());
++
++    // User then taps on the app icon
++    applicationManager.onProcessStarting(appId);
++    applicationManager.onFocusRequested(appId);
++
++    // But no application instance should have been created because of that
++    EXPECT_TRUE(applicationManager.findApplication(appId) == nullptr);
++
++    // ApplicationManager will ask TaskController to start the application again
++    // once the closing instance is gone
++    Mock::VerifyAndClearExpectations(taskController);
++    EXPECT_CALL(*taskController, start(appId, _))
++        .Times(1)
++        .WillOnce(Return(true));
++
++    EXPECT_CALL(*taskController, stop(appId))
++        .Times(1)
++        .WillOnce(Return(false));
++
++    EXPECT_CALL(*taskController, kill(procId))
++        .Times(1)
++        .WillOnce(Invoke(
++            [this, session](pid_t) {
++                // simulate application dying and thus severing the mir connection
++                onSessionStopping(session);
++            }
++        ));
++
++    if (fakeStopTimer->isRunning()) {
++        // Simulate that it has timed out.
++        fakeTimeSource->m_msecsSinceReference = fakeStopTimer->nextTimeoutTime() + 1;
++        fakeStopTimer->update();
++    }
++
++    // DeferredDelete is special: likes to be called out specifically or it won't come out
++    qtApp.sendPostedEvents(app, QEvent::DeferredDelete);
++    qtApp.sendPostedEvents();
++
++    EXPECT_TRUE(applicationManager.findApplication(appId) != nullptr);
++}