Merge lp:~unity-team/qtmir/fix-some-lifecycle-bugs into lp:qtmir

[Michael Zanetti]

Fix some bugs in app lifecycle management.

* Correctly determine PID of apps not started by UAL
* Delayed suspending of apps if the first suspending failed because of them being in Starting phase still

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

https://code.launchpad.net/~mzanetti/unity8/async-dashcommunicator/+merge/235272
https://code.launchpad.net/~mzanetti/unity-api/dashActive/+merge/235273

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

yes

 * Did you make sure that your branch does not contain spurious tags?

yes

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

no

 * If you changed the UI, has there been a design review?

no

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:247
http://jenkins.qa.ubuntu.com/job/qtmir-ci/66/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/66
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/66

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

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

+bool TaskController::suspend(Application* app)
const Application* please. Same for resume.

Could we also get a test checking if you start app1 & app2, one after the other, and if app2 comes up first, that app1 is suspended when it comes up. I believe your code fixes that too?

review: Needs Fixing

[Gerry Boland (gerboland)]

Testing problem:
- installed package, rebooted phone, verified dash suspended via SSH. Unlocked screen. Dash was there, but only wallpaper was to be seen, no scope contents was visible. When I entered spread and selected Dash, it finally drew the scope contents.

review: Needs Fixing

[Gerry Boland (gerboland)]

Nitpick not related to this MR - I noticed Dash remains suspended when greeter is shown, but resumed when lock-screen is revealed by swiping greeter away.

I think this MR fixes these bugs too:
https://bugs.launchpad.net/qtmir/+bug/1326906
https://bugs.launchpad.net/qtmir/+bug/1343259
please associate them with this MR.

[Michael Zanetti (mzanetti)]

> Testing problem:
> - installed package, rebooted phone, verified dash suspended via SSH. Unlocked
> screen. Dash was there, but only wallpaper was to be seen, no scope contents
> was visible. When I entered spread and selected Dash, it finally drew the
> scope contents.

Did you install the related unity8 branch? I believe this happened because unity8 trunk doesn't focus any already running app when starting up. The linked branch fixes that in unity8.

[Michael Zanetti (mzanetti)]

> +bool TaskController::suspend(Application* app)
> const Application* please. Same for resume.

done

>
> Could we also get a test checking if you start app1 & app2, one after the
> other, and if app2 comes up first, that app1 is suspended when it comes up. I
> believe your code fixes that too?

done

[Michael Zanetti (mzanetti)]

> Nitpick not related to this MR - I noticed Dash remains suspended when greeter
> is shown, but resumed when lock-screen is revealed by swiping greeter away.
>

Right... ApplicationManager::suspended is tied to the greeter but not the lockscreen. Not sure if that should be even changed. In any case, that's a different issue and its in unity8, not qtmir.

> I think this MR fixes these bugs too:
> https://bugs.launchpad.net/qtmir/+bug/1326906
> https://bugs.launchpad.net/qtmir/+bug/1343259
> please associate them with this MR.

done.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:248
http://jenkins.qa.ubuntu.com/job/qtmir-ci/68/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/68
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/68

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

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

All good, thanks!

review: Approve

[PS Jenkins bot (ps-jenkins)]

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

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

review: Needs Fixing (continuous-integration)

[Gerry Boland (gerboland)]

https://code.launchpad.net/~mzanetti/unity8/focus-first-if-running-at-startup/+merge/234124
this was superceded by a branch which merged, it can be removed from the prereq list

[Gerry Boland (gerboland)]

+ qWarning() << "Dash doesn't seem to be running... Ignoring.";
By your own edict, needs fixing :)

+ && m_sideStageApplication != dashApp) {
possible?? I hope not

+ if (m_dashActive && application->appId() == "unity8-dash") {
+ return false;
+ }
resumeApplication should have this too, no?

Test for the new dashActive property would be good. And test to make sure dash isn't changed by suspendApplication & resumeApplication

review: Needs Fixing

[lp:~unity-team/qtmir/fix-some-lifecycle-bugs]

253. By Michael Zanetti on 2014-09-29

merge/update

254. By Michael Zanetti on 2014-09-29

dashActive -> forceDashActive

[PS Jenkins bot (ps-jenkins)]

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

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

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

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

review: Needs Fixing (continuous-integration)

[lp:~unity-team/qtmir/fix-some-lifecycle-bugs]

255. By Michael Zanetti on 2014-09-29

add a test for forceDashActive

[Michael Zanetti (mzanetti)]

> + qWarning() << "Dash doesn't seem to be running... Ignoring.";
> By your own edict, needs fixing :)
>

fixed

> + && m_sideStageApplication != dashApp) {
> possible?? I hope not

not atm, but yeah, should be according to design.

>
> + if (m_dashActive && application->appId() == "unity8-dash") {
> + return false;
> + }
> resumeApplication should have this too, no?

I don't think so...

>
>
> Test for the new dashActive property would be good. And test to make sure dash
> isn't changed by suspendApplication & resumeApplication

done

[PS Jenkins bot (ps-jenkins)]

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

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

review: Needs Fixing (continuous-integration)

[Albert Astals Cid (aacid)]

Looks good codewise, need to test.

[Albert Astals Cid (aacid)]

 * 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.
No, requires other packages to build not present in the archive

 * Did you make sure that the branch does not contain spurious tags?
Yes

review: Approve

=== modified file 'debian/control'
--- debian/control	2014-09-22 17:38:38 +0000
+++ debian/control	2014-09-29 10:34:35 +0000
@@ -19,7 +19,7 @@
                libubuntu-app-launch2-dev,
                libubuntu-application-api-dev (>= 2.1.0),
                libudev-dev,
-               libunity-api-dev (>= 7.91),
+               libunity-api-dev (>= 7.92),
                liburl-dispatcher1-dev,
                libxkbcommon-dev,
                libxrender-dev,
 
=== modified file 'src/modules/Unity/Application/application.cpp'
--- src/modules/Unity/Application/application.cpp	2014-09-22 17:38:38 +0000
+++ src/modules/Unity/Application/application.cpp	2014-09-29 10:34:35 +0000
@@ -325,13 +325,13 @@
 void Application::onSessionSuspended()
 {
     qCDebug(QTMIR_APPLICATIONS) << "Application::onSessionSuspended - appId=" << appId();
-    m_taskController->suspend(longAppId());
+    m_taskController->suspend(this);
 }
 
 void Application::onSessionResumed()
 {
     qCDebug(QTMIR_APPLICATIONS) << "Application::onSessionResumed - appId=" << appId();
-    m_taskController->resume(longAppId());
+    m_taskController->resume(this);
 }
 
 void Application::respawn()
 
=== modified file 'src/modules/Unity/Application/application.h'
--- src/modules/Unity/Application/application.h	2014-09-22 17:38:38 +0000
+++ src/modules/Unity/Application/application.h	2014-09-29 10:34:35 +0000
@@ -105,7 +105,7 @@
     Stages supportedStages() const;
     SupportedOrientations supportedOrientations() const;
 
-    bool containsProcess(pid_t pid) const;
+    pid_t pid() const;
 
 Q_SIGNALS:
     void fullscreenChanged(bool fullscreen);
@@ -120,7 +120,6 @@
 
 private:
     QString longAppId() const;
-    pid_t pid() const;
     void setPid(pid_t pid);
     void setArguments(const QStringList arguments);
     void setFocused(bool focus);
 
=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2014-09-22 17:38:38 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2014-09-29 10:34:35 +0000
@@ -196,6 +196,7 @@
     , m_desktopFileReaderFactory(desktopFileReaderFactory)
     , m_procInfo(procInfo)
     , m_suspended(false)
+    , m_forceDashActive(false)
 {
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::ApplicationManager (this=%p)" << this;
     setObjectName("qtmir::ApplicationManager");
@@ -320,6 +321,35 @@
     }
 }
 
+bool ApplicationManager::forceDashActive() const
+{
+    return m_forceDashActive;
+}
+
+void ApplicationManager::setForceDashActive(bool forceDashActive)
+{
+    if (m_forceDashActive == forceDashActive) {
+        return;
+    }
+
+    m_forceDashActive = forceDashActive;
+    Q_EMIT forceDashActiveChanged();
+
+    Application *dashApp = findApplication("unity8-dash");
+    if (!dashApp) {
+        qCWarning(QTMIR_APPLICATIONS) << "Dash doesn't seem to be running... Ignoring.";
+        return;
+    }
+
+    if (m_forceDashActive && dashApp->state() != Application::Running) {
+         resumeApplication(dashApp);
+    } else if (!m_forceDashActive && dashApp->state() == Application::Running
+            && m_mainStageApplication != dashApp
+            && m_sideStageApplication != dashApp) {
+        suspendApplication(dashApp);
+    }
+}
+
 bool ApplicationManager::suspendApplication(Application *application)
 {
     if (application == nullptr)
@@ -330,6 +360,10 @@
     if (!m_lifecycleExceptions.filter(application->appId().section('_',0,0)).empty())
         return false;
 
+    if (m_forceDashActive && application->appId() == "unity8-dash") {
+        return false;
+    }
+
     if (application->state() == Application::Running)
         application->setState(Application::Suspended);
 
@@ -370,10 +404,14 @@
 
     if (application->stage() == Application::MainStage) {
         m_mainStageApplication = application;
-        resumeApplication(m_sideStageApplication); // in case unfocusCurrentApplication() was last called
     } else {
         m_sideStageApplication = application;
-        resumeApplication(m_mainStageApplication); // in case unfocusCurrentApplication() was last called
+    }
+
+    if (!m_suspended) {
+        resumeApplication(application); // in case unfocusCurrentApplication() was last called
+    } else {
+        suspendApplication(application); // Make sure we also have this one suspended if everything is suspended
     }
 
     m_focusedApplication = application;
@@ -801,6 +839,9 @@
     if (application && application->state() == Application::Starting) {
         m_dbusWindowStack->WindowCreated(0, application->appId());
         application->setState(Application::Running);
+        if ((application != m_mainStageApplication && application != m_sideStageApplication) || m_suspended) {
+            suspendApplication(application);
+        }
     }
 }
 
 
=== modified file 'src/modules/Unity/Application/application_manager.h'
--- src/modules/Unity/Application/application_manager.h	2014-09-08 21:05:15 +0000
+++ src/modules/Unity/Application/application_manager.h	2014-09-29 10:34:35 +0000
@@ -91,6 +91,8 @@
     QString focusedApplicationId() const override;
     bool suspended() const override;
     void setSuspended(bool suspended) override;
+    bool forceDashActive() const override;
+    void setForceDashActive(bool forceDashActive) override;
     Q_INVOKABLE qtmir::Application* get(int index) const override;
     Q_INVOKABLE qtmir::Application* findApplication(const QString &appId) const override;
     Q_INVOKABLE bool requestFocusApplication(const QString &appId) override;
@@ -161,6 +163,7 @@
     static ApplicationManager* the_application_manager;
     QList<pid_t> m_hiddenPIDs;
     bool m_suspended;
+    bool m_forceDashActive;
 
     friend class Application;
     friend class DBusWindowStack;
 
=== modified file 'src/modules/Unity/Application/taskcontroller.cpp'
--- src/modules/Unity/Application/taskcontroller.cpp	2014-07-17 16:36:50 +0000
+++ src/modules/Unity/Application/taskcontroller.cpp	2014-09-29 10:34:35 +0000
@@ -109,10 +109,13 @@
     return m_appController->findDesktopFileForAppId(appId);
 }
 
-bool TaskController::suspend(const QString& appId)
+bool TaskController::suspend(const Application* app)
 {
-    qCDebug(QTMIR_APPLICATIONS) << "TaskController::suspend - appId=" << appId;
-    pid_t pid = m_appController->primaryPidForAppId(appId);
+    qCDebug(QTMIR_APPLICATIONS) << "TaskController::suspend - appId=" << app->appId();
+    pid_t pid = m_appController->primaryPidForAppId(app->appId());
+    if (pid == 0) {
+        pid = app->pid();
+    }
     m_processController->oomController()->ensureProcessLikelyToBeKilled(pid);
 
     if (pid) {
@@ -125,10 +128,13 @@
     }
 }
 
-bool TaskController::resume(const QString& appId)
+bool TaskController::resume(const Application* app)
 {
-    qCDebug(QTMIR_APPLICATIONS) << "TaskController::resume - appId=" << appId;
-    pid_t pid = m_appController->primaryPidForAppId(appId);
+    qCDebug(QTMIR_APPLICATIONS) << "TaskController::resume - appId=" << app->appId();
+    pid_t pid = m_appController->primaryPidForAppId(app->appId());
+    if (pid == 0) {
+        pid = app->pid();
+    }
 
     m_processController->oomController()->ensureProcessUnlikelyToBeKilled(pid);
 
@@ -139,7 +145,7 @@
         return m_processController->sigContinueProcessGroupForPid(pid);
         return true;
     } else {
-        qCDebug(QTMIR_APPLICATIONS) << "TaskController::resume - couldn't find PID to resume for appId=" << appId;
+        qCDebug(QTMIR_APPLICATIONS) << "TaskController::resume - couldn't find PID to resume for appId=" << app->appId();
         return false;
     }
 }
 
=== modified file 'src/modules/Unity/Application/taskcontroller.h'
--- src/modules/Unity/Application/taskcontroller.h	2014-07-17 16:36:50 +0000
+++ src/modules/Unity/Application/taskcontroller.h	2014-09-29 10:34:35 +0000
@@ -41,8 +41,8 @@
     bool start(const QString &appId, const QStringList &args);
     bool stop(const QString &appId);
 
-    bool suspend(const QString &appId);
-    bool resume(const QString &appId);
+    bool suspend(const Application* app);
+    bool resume(const Application* app);
 
     bool appIdHasProcessId(const QString &appId, const quint64 pid) const;
     QFileInfo findDesktopFileForAppId(const QString &appId) const;
 
=== modified file 'tests/modules/ApplicationManager/application_manager_test.cpp'
--- tests/modules/ApplicationManager/application_manager_test.cpp	2014-09-18 12:00:38 +0000
+++ tests/modules/ApplicationManager/application_manager_test.cpp	2014-09-29 10:34:35 +0000
@@ -393,6 +393,7 @@
     applicationManager.authorizeSession(a_procId, authed);
 
     onSessionStarting(first_session);
+    applicationManager.focusApplication(an_app_id);
     applicationManager.onSessionCreatedSurface(first_session.get(), aSurface);
     onSessionStarting(second_session);
 
@@ -441,6 +442,152 @@
     EXPECT_EQ(true, the_app->focused());
 }
 
+TEST_F(ApplicationManagerTests,suspended_suspends_starting_app_when_it_gets_ready)
+{
+    using namespace ::testing;
+    quint64 a_procId = 5921;
+    const char an_app_id[] = "some_app";
+    QByteArray a_cmd( "/usr/bin/app1 --desktop_file_hint=some_app");
+    std::shared_ptr<mir::scene::Surface> aSurface(nullptr);
+
+    ON_CALL(procInfo,command_line(_)).WillByDefault(Return(a_cmd));
+
+    ON_CALL(appController,appIdHasProcessId(_,_)).WillByDefault(Return(false));
+
+    bool authed = true;
+
+    std::shared_ptr<mir::scene::Session> first_session = std::make_shared<MockSession>("Oo", a_procId);
+    applicationManager.authorizeSession(a_procId, authed);
+
+    onSessionStarting(first_session);
+
+    Application * the_app = applicationManager.findApplication(an_app_id);
+    applicationManager.focusApplication(an_app_id);
+    EXPECT_EQ(Application::Starting, the_app->state());
+
+    applicationManager.setSuspended(true);
+
+    // Not suspending yet, as it's still starting
+    EXPECT_EQ(Application::Starting, the_app->state());
+
+    // This signals the app is ready now
+    applicationManager.onSessionCreatedSurface(first_session.get(), aSurface);
+
+    // And given that the AppManager is suspended now, this should go to suspended too
+    EXPECT_EQ(Application::Suspended, the_app->state());
+    EXPECT_EQ(false, the_app->focused());
+
+    applicationManager.setSuspended(false);
+
+    EXPECT_EQ(Application::Running, the_app->state());
+    EXPECT_EQ(true, the_app->focused());
+}
+
+TEST_F(ApplicationManagerTests,focus_change_suspends_starting_app_when_it_gets_ready)
+{
+    using namespace ::testing;
+    quint64 first_procId = 5921;
+    quint64 second_procId = 5922;
+    std::shared_ptr<mir::scene::Surface> aSurface(nullptr);
+    QByteArray first_cmdLine( "/usr/bin/app1 --desktop_file_hint=app1");
+    QByteArray second_cmdLine( "/usr/bin/app2--desktop_file_hint=app2");
+
+    EXPECT_CALL(procInfo,command_line(first_procId))
+        .Times(1)
+        .WillOnce(Return(first_cmdLine));
+
+    ON_CALL(appController,appIdHasProcessId(_,_)).WillByDefault(Return(false));
+
+    EXPECT_CALL(procInfo,command_line(second_procId))
+        .Times(1)
+        .WillOnce(Return(second_cmdLine));
+
+    bool authed = true;
+
+    std::shared_ptr<mir::scene::Session> first_session = std::make_shared<MockSession>("Oo", first_procId);
+    std::shared_ptr<mir::scene::Session> second_session = std::make_shared<MockSession>("oO", second_procId);
+    applicationManager.authorizeSession(first_procId, authed);
+    applicationManager.authorizeSession(second_procId, authed);
+    onSessionStarting(first_session);
+
+    Application * app1 = applicationManager.findApplication("app1");
+    applicationManager.focusApplication("app1");
+
+    // First app starting...
+    EXPECT_EQ(Application::Starting, app1->state());
+
+    onSessionStarting(second_session);
+    Application * app2 = applicationManager.findApplication("app2");
+    applicationManager.focusApplication("app2");
+
+    // Second app starting...
+    EXPECT_EQ(Application::Starting, app2->state());
+
+    // Make sure first one is still in starting state
+    EXPECT_EQ(Application::Starting, app1->state());
+
+    // Signal app1 is ready now
+    applicationManager.onSessionCreatedSurface(first_session.get(), aSurface);
+
+    // Make sure AppMan suspended it now that its ready
+    EXPECT_EQ(Application::Suspended, app1->state());
+}
+
+TEST_F(ApplicationManagerTests,forceDashActive_activates_dash_while_not_focused)
+{
+    using namespace ::testing;
+    quint64 first_procId = 5921;
+    quint64 second_procId = 5922;
+    std::shared_ptr<mir::scene::Surface> aSurface(nullptr);
+    QByteArray first_cmdLine( "/usr/bin/app1 --desktop_file_hint=unity8-dash");
+    QByteArray second_cmdLine( "/usr/bin/app2--desktop_file_hint=app2");
+
+    EXPECT_CALL(procInfo,command_line(first_procId))
+        .Times(1)
+        .WillOnce(Return(first_cmdLine));
+
+    ON_CALL(appController,appIdHasProcessId(_,_)).WillByDefault(Return(false));
+
+    EXPECT_CALL(procInfo,command_line(second_procId))
+        .Times(1)
+        .WillOnce(Return(second_cmdLine));
+
+    bool authed = true;
+
+    std::shared_ptr<mir::scene::Session> first_session = std::make_shared<MockSession>("Oo", first_procId);
+    std::shared_ptr<mir::scene::Session> second_session = std::make_shared<MockSession>("oO", second_procId);
+    applicationManager.authorizeSession(first_procId, authed);
+    applicationManager.authorizeSession(second_procId, authed);
+    onSessionStarting(first_session);
+
+    Application * dashApp = applicationManager.findApplication("unity8-dash");
+    applicationManager.onSessionCreatedSurface(first_session.get(), aSurface);
+    applicationManager.focusApplication("unity8-dash");
+
+    // Dash app should be ready now...
+    EXPECT_EQ(Application::Running, dashApp->state());
+
+    // Launch second app
+    onSessionStarting(second_session);
+    applicationManager.onSessionCreatedSurface(second_session.get(), aSurface);
+    applicationManager.focusApplication("app2");
+    EXPECT_EQ(applicationManager.focusedApplicationId(), "app2");
+
+    // Make sure the dash is suspended
+    EXPECT_EQ(dashApp->state(), Application::Suspended);
+
+    // Now set the dashactive flag
+    applicationManager.setForceDashActive(true);
+
+    // And make sure the dash is woken up but not focused
+    EXPECT_EQ(applicationManager.focusedApplicationId(), "app2");
+    EXPECT_EQ(dashApp->state(), Application::Running);
+
+    // Unset the dashactive flag
+    applicationManager.setForceDashActive(false);
+    EXPECT_EQ(dashApp->state(), Application::Suspended);
+}
+
 TEST_F(ApplicationManagerTests,requestFocusApplication)
 {
     using namespace ::testing;
@@ -871,6 +1018,7 @@
 
     applicationManager.startApplication(appId, ApplicationManager::NoFlag);
     applicationManager.onProcessStarting(appId);
+    applicationManager.focusApplication(appId);
 
     std::shared_ptr<mir::scene::Session> session = std::make_shared<MockSession>("", procId);
 
 
=== modified file 'tests/modules/TaskController/taskcontroller_test.cpp'
--- tests/modules/TaskController/taskcontroller_test.cpp	2014-07-01 13:38:06 +0000
+++ tests/modules/TaskController/taskcontroller_test.cpp	2014-09-29 10:34:35 +0000
@@ -16,9 +16,12 @@
  */
 
 #include <Unity/Application/taskcontroller.h>
+#include <Unity/Application/desktopfilereader.h>
+#include <Unity/Application/application.h>
 
 #include "mock_oom_controller.h"
 #include "mock_process_controller.h"
+#include "mock_desktop_file_reader.h"
 
 #include <core/posix/fork.h>
 #include <core/posix/linux/proc/process/oom_score_adj.h>
@@ -141,11 +144,17 @@
 
     EXPECT_CALL(oomController, ensureProcessLikelyToBeKilled(-1)).Times(1);
 
-    TaskController taskController(nullptr,
+    auto taskController = QSharedPointer<TaskController>(new TaskController(nullptr,
                                   appControllerPtr,
-                                  processControllerPtr);
-
-    taskController.suspend(appId);
+                                  processControllerPtr));
+
+
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+    Application *app = new Application(taskController, mockDesktopFileReader, Application::Running, QStringList(), nullptr);
+    taskController->suspend(app);
+    delete app;
 }
 
 TEST(TaskController, resumingAnApplicationAdjustsOomScoreForCorrectPid)
@@ -173,11 +182,17 @@
 
     EXPECT_CALL(oomController, ensureProcessUnlikelyToBeKilled(-1)).Times(1);
 
-    TaskController taskController(nullptr,
+    auto taskController = QSharedPointer<TaskController>(new TaskController(nullptr,
                                   appControllerPtr,
-                                  processControllerPtr);
-
-    taskController.resume(appId);
+                                  processControllerPtr));
+
+
+    auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(appId, QFileInfo());
+    ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+    ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(appId));
+    Application *app = new Application(taskController, mockDesktopFileReader, Application::Running, QStringList(), nullptr);
+    taskController->resume(app);
+    delete app;
 }
 
 TEST(TaskController, aStartedApplicationIsOomScoreAdjusted)