Merge lp:~thomas-voss/unity-mir/refactor-oom-score-adj-to-rely-on-process-cpp into lp:unity-mir

[Thomas Voß]

Refactor Oom(Score)Adj to rely on process-cpp helper library.

* 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, I installed the resulting package and checked that I can still run multiple apps in parallel.

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

[Michał Sawicz (saviq)]

Missing debian/control entry.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:144
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/156/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/17/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/17/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/17/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:145
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/176/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/39/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/40/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/39/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:146
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/182/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/45/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/46/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/45/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:146
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/189/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/52
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/53
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/53/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/52

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

review: Approve (continuous-integration)

[Michał Sawicz (saviq)]

There's an indentation issue in debian/control (please use spaces).

Why do we fall back to the deprecated method? Are there any cases where we expect process cpp to raise that is an "expected failure"?

"extremal" is not a word?

Should we maybe store shellScore instead of reading it off of the shell process every time?

This would be a good time to auto-test this, would it not?

review: Needs Fixing

[Thomas Voß (thomas-voss)]

> There's an indentation issue in debian/control (please use spaces).
>

Fixed.

> Why do we fall back to the deprecated method? Are there any cases where we
> expect process cpp to raise that is an "expected failure"?
>

While the method is deprecated it is still present and common in the Android world.
Process-cpp just raises an exception if it is unable to adjust the score, i.e., unable to write to the respective file. I think the fallback renders the overall implementation more robust in real-world scenarios.

> "extremal" is not a word?
>

Fixed.

> Should we maybe store shellScore instead of reading it off of the shell
> process every time?
>

We need to read it everytime as the score might have been adjusted by the kernel in the meantime.

> This would be a good time to auto-test this, would it not?

True, will take care of that task.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:148
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/192/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/55
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/56
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/56/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/55

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:150
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/205/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/68
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/69
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/69/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/68

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

review: Approve (continuous-integration)

[Albert Astals Cid (aacid)]

there's a src/modules/Unity/Application/Application.pro.THIS file taht probably has to go away.

review: Needs Fixing

[Thomas Voß (thomas-voss)]

> there's a src/modules/Unity/Application/Application.pro.THIS file taht
> probably has to go away.

Good catch, fixed.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:152
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/209/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/72/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/73/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/72/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:153
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/210/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/73/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/74/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/73/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:154
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/211/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/74
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/75
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/75/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/74

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

review: Approve (continuous-integration)

[Albert Astals Cid (aacid)]

Which this i am getting libunity-mir.so.0.0.1 while with the master branch i get libunity-mir.so.1.0.0

I don't think this change is intentional, no?

review: Needs Fixing

[Thomas Voß (thomas-voss)]

> Which this i am getting libunity-mir.so.0.0.1 while with the master branch i
> get libunity-mir.so.1.0.0
>
> I don't think this change is intentional, no?

Nope, it is not. Also fixed in prerequisite branch.

[Albert Astals Cid (aacid)]

Looks good to me, would prefer someone with more unity-mir knowledge to top-approve though :-)

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:155
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~thomas-voss/unity-mir/refactor-oom-score-adj-to-rely-on-process-cpp/+merge/201145/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/unity-mir-ci/212/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/75
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/76
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/76/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/75

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:155
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/214/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/77
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/78
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/78/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/77

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:156
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/215/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/78
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/79
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/79/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/78

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:157
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/216/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/79
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/80
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/80/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/79

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:158
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/217/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/80
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/81
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/81/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/80

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

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

First off, thank you for the tests! Great to have them. Here are my comments:

For ApplicationController, I dislike the naming, the difference in purpose between "ApplicationManager" and "ApplicationController" is now not obvious to me.

Your making separate TaskController and ApplicationController is clear to me - yes I see that ApplicationController is implementation specific (i.e. we could have a systemd implementation later), and TaskController is implementation agnostic, that's clear.

But I'd consider your using the process-cpp library an implementation specific detail also - other init sytems may provide their own APIs to configure things for an OOM killer. As a result, I think it makes more sense to have the TaskController interface and allow multiple possible implementations (so removing the ApplicationController).

It would also help remove this

+ the_application_manager = new ApplicationManager(
+ QSharedPointer<TaskController>(
+ new TaskController(
+ nullptr,
+ QSharedPointer<ApplicationController>(
+ new upstart::ApplicationController()))),
+ QSharedPointer<DesktopFileReader::Factory>(
+ new DesktopFileReader::Factory()));
which is ugly to my eyes.

I prefer appending "Interface" or "Base" to the names of interfaces classes too.

review: Needs Fixing

[Gerry Boland (gerboland)]

More generally I find it strange that the Process C++ library isn't isolating unity-mir from the implementation details of OOM score setter. Yes I know there are 2 separate scoring systems, but is there not a way to calculate the respective score to suit both backends? The plpp::OomScoreAdj and plpp::OomAdj classes just open the /proc/$pid/oom_something files and read/write values? If so it's a pretty thin layer, and I could do the equivalent in a few lines of code in Qt.

I can't say I'm terribly fond of the API in process-cpp. I'm a fan of defined setters & getters, so I find
+ core::posix::this_process::instance() >> shellScore; int score = shellScore.value;
less readable than
+ int score = core::posix::this_process::instance().get_score();
Using >> and << operators means it's not obvious at all what's being read and written. Again, personal preference

[Gerry Boland (gerboland)]

+ // static TaskController* singleton();
Junk

+ void onApplicationAboutToBeStarted(QString id);
Please use "const QString" here and in the other slots

+ connect(app_controller.data(),
+ SIGNAL(applicationAboutToBeStarted(QString)),
+ this,
+ SLOT(onApplicationAboutToBeStarted(QString)));
If possible you can use the C++11 syntax for signal/slot connections which is checked at compile-time, unlike that syntax (checked run-time):
  connect(app_controller.data(), &applicationAboutToBeStarted, this, &onApplicationAboutToBeStarted);

[Gerry Boland (gerboland)]

+ auto pid = app_controller->primaryPidForAppId(id);
My opinion on "auto" is it should be used with care, as it reduces the clarity of code for the developer. auto should be used only when the actual type is obvious - in for loops or for iterator types of lists, it's handy. But here pid is a pid_t, not an int, which a developer might guess and be subtly wrong about.

+++ src/modules/Unity/Application/upstart/application_controller.cpp
This is a very un-Qt piece of code, using some Qt methods. Making upstart::ApplicationController::ApplicationController not be a QObject means you loose Q_EMIT and have to go down the QMetaObject::invokeMethod road, which drops compile-time checking, and deciding if signal can be direct or queued. You're also loosing readability, so where's the real gain?

+ auto thiz = static_cast<upstart::ApplicationController*>(userData);
You're comprehensive :) I've not seen a use for userData yet however. Really needed? Here the auto is obvious though so I'm fine with it.

[Gerry Boland (gerboland)]

+# Build with system gmock and embedded gtest
+set (GMOCK_INCLUDE_DIR "/usr/include/gmock/include" CACHE PATH "gmock source include directory")
+set (GMOCK_SOURCE_DIR "/usr/src/gmock" CACHE PATH "gmock source directory")
+set (GTEST_INCLUDE_DIR "${GMOCK_SOURCE_DIR}/gtest/include" CACHE PATH "gtest source include directory")
Can't cmake read this from the pkgconfig file?

+TEST(TaskController, startingAnApplicationCallsCorrectlyIntoApplicationController)
+ const QString appId{"com.canonical.does.not.exist"};
+ taskController.start("com.canonical.does.not.exist", QStringList());
Why not just use appId on the latter line? Is case for all tests in tests/taskcontroller_test.cpp

[Gerry Boland (gerboland)]

Some notes:
I'd also prefer if you maintained the coding style of the project, please keep the opening brace on the same line as the "try" and "catch(...)" commands, and the other places.

+ * Copyright (C) 2013 Canonical, Ltd.
2014

+ * Authored by: Thomas Voß <email address hidden>
some of that was my code you moved around, can you either remove this or add my name too please in the relevant places? I prefer not having it, as it introduces politics over code ownership, who did what, etc. Again, opinion.

[Thomas Voß (thomas-voss)]

> + auto pid = app_controller->primaryPidForAppId(id);
> My opinion on "auto" is it should be used with care, as it reduces the clarity
> of code for the developer. auto should be used only when the actual type is
> obvious - in for loops or for iterator types of lists, it's handy. But here
> pid is a pid_t, not an int, which a developer might guess and be subtly wrong
> about.
>
>

Ack, will fix it.

>
> +++ src/modules/Unity/Application/upstart/application_controller.cpp
> This is a very un-Qt piece of code, using some Qt methods. Making
> upstart::ApplicationController::ApplicationController not be a QObject means
> you loose Q_EMIT and have to go down the QMetaObject::invokeMethod road, which
> drops compile-time checking, and deciding if signal can be direct or queued.
> You're also loosing readability, so where's the real gain?
>

I guess I don't understand the difference between Q_EMIT and QMetaObject::invoke then. How can a macro do compile-time checking, specifically in the Qt signal/slot system? I get your point about ::connect(...) with C++11 syntax but not about the emit case. For the direct vs. queued question: ::connect() can only determine the correct setup if the thread affinity of both objects is known at connect time iiuc. That's not necessarily the case here as far as I can see.

> + auto thiz = static_cast<upstart::ApplicationController*>(userData);
> You're comprehensive :) I've not seen a use for userData yet however. Really
> needed? Here the auto is obvious though so I'm fine with it.

It's required to rely on the userData when removing the singleton-based approaches that make testing quite difficult.

[Thomas Voß (thomas-voss)]

> First off, thank you for the tests! Great to have them. Here are my comments:
>
>

Yup, happy to help.

> For ApplicationController, I dislike the naming, the difference in purpose
> between "ApplicationManager" and "ApplicationController" is now not obvious to
> me.
>
> Your making separate TaskController and ApplicationController is clear to me -
> yes I see that ApplicationController is implementation specific (i.e. we could
> have a systemd implementation later), and TaskController is implementation
> agnostic, that's clear.
>
> But I'd consider your using the process-cpp library an implementation specific
> detail also - other init sytems may provide their own APIs to configure things
> for an OOM killer. As a result, I think it makes more sense to have the
> TaskController interface and allow multiple possible implementations (so
> removing the ApplicationController).
>

Okay, I can see that we should fold the ApplicationController into the TaskController interface, but the Oom API I'm modelling here is independent of the init system and only leverages kernel facilities. With that, and your proposal to have an upstart::TaskController implementation, I would propose to have an interface ProcessController that includes state control as well as oom adjustments. TaskController would then depend on an implementation of ProcessController. Makes sense?

> It would also help remove this
>
> + the_application_manager = new ApplicationManager(
> + QSharedPointer<TaskController>(
> + new TaskController(
> + nullptr,
> + QSharedPointer<ApplicationController>(
> + new upstart::ApplicationController()))),
> + QSharedPointer<DesktopFileReader::Factory>(
> + new DesktopFileReader::Factory()));
> which is ugly to my eyes.
>

I can see what I can do.

> I prefer appending "Interface" or "Base" to the names of interfaces classes
> too.

Dito

[Thomas Voß (thomas-voss)]

> More generally I find it strange that the Process C++ library isn't isolating
> unity-mir from the implementation details of OOM score setter. Yes I know
> there are 2 separate scoring systems, but is there not a way to calculate the
> respective score to suit both backends? The plpp::OomScoreAdj and plpp::OomAdj
> classes just open the /proc/$pid/oom_something files and read/write values? If
> so it's a pretty thin layer, and I could do the equivalent in a few lines of
> code in Qt.
>

I'm not questioning that. The real problem is testing, though. If you burry that inside the implementation, how do you test for correct behavior. Pulling out the behavior and putting it in its component, testing it and making it available to other parties, too, is the motivation for process-cpp.

>
> I can't say I'm terribly fond of the API in process-cpp. I'm a fan of defined
> setters & getters, so I find
> + core::posix::this_process::instance() >> shellScore; int score =
> shellScore.value;
> less readable than
> + int score = core::posix::this_process::instance().get_score();
> Using >> and << operators means it's not obvious at all what's being read and
> written. Again, personal preference

We could certainly apply this inside unity-mir where the scope of operation is limited to oom scores. However, in the bigger picture of features in /proc/pid, placing the actual logic in an external entity and separating concern between the process (providing the pid) and explicit objects for features in /proc/pid helps in keeping the size of the interfaces manageable. I would also argue that a getter should be free of side-effects, but that's me being pedantic.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:159
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/230/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/93/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/94/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/93/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:161
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/231/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/94/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/95/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/94/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:162
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/232/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/95
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/96
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/96/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/95

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:163
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/233/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/96
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/97
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/97/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/96

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:165
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/235/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/98
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/99
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/99/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/98

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

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

> > For ApplicationController, I dislike the naming, the difference in purpose
> > between "ApplicationManager" and "ApplicationController" is now not obvious
> to
> > me.
> >
> > Your making separate TaskController and ApplicationController is clear to me
> -
> > yes I see that ApplicationController is implementation specific (i.e. we
> could
> > have a systemd implementation later), and TaskController is implementation
> > agnostic, that's clear.
> >
> > But I'd consider your using the process-cpp library an implementation
> specific
> > detail also - other init sytems may provide their own APIs to configure
> things
> > for an OOM killer. As a result, I think it makes more sense to have the
> > TaskController interface and allow multiple possible implementations (so
> > removing the ApplicationController).
> >
>
> Okay, I can see that we should fold the ApplicationController into the
> TaskController interface, but the Oom API I'm modelling here is independent of
> the init system and only leverages kernel facilities. With that, and your
> proposal to have an upstart::TaskController implementation, I would propose to
> have an interface ProcessController that includes state control as well as oom
> adjustments. TaskController would then depend on an implementation of
> ProcessController. Makes sense?

While I am averse to adding yet another class, yes that works for me. It does introduce further class naming confusion as how can one easily guess the difference between {Process,Application,Task}Controller. I'll maybe do a little refactoring to clarify.

> I can see what I can do.
>
> > I prefer appending "Interface" or "Base" to the names of interfaces classes
> > too.
>
> Dito

Dito meaning you'll do it? Or you object?

[Gerry Boland (gerboland)]

> > +++ src/modules/Unity/Application/upstart/application_controller.cpp
> > This is a very un-Qt piece of code, using some Qt methods. Making
> > upstart::ApplicationController::ApplicationController not be a QObject means
> > you loose Q_EMIT and have to go down the QMetaObject::invokeMethod road,
> which
> > drops compile-time checking, and deciding if signal can be direct or queued.
> > You're also loosing readability, so where's the real gain?
> >
>
> I guess I don't understand the difference between Q_EMIT and
> QMetaObject::invoke then. How can a macro do compile-time checking,
> specifically in the Qt signal/slot system? I get your point about
> ::connect(...) with C++11 syntax but not about the emit case. For the direct
> vs. queued question: ::connect() can only determine the correct setup if the
> thread affinity of both objects is known at connect time iiuc. That's not
> necessarily the case here as far as I can see.

The MOC compiler helps out. For any Q_SIGNAL you declare in the header file, it generates an extra method in that class for it, for Q_SIGNAL void valueChanged(int) something like:

void Class::valueChanged(int _t1)
{
    void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

Then in the .cpp file, calling "Q_EMIT valueChanged(5)" reduces to "valueChanged(5)" which is a valid method since it was added by MOC (Q_EMIT is an empty macro, is more a hint for developer).

Using QMetaObject::invokeMethod, you are not taking advantage of this compile time check. If the signal you're invoking is removed, the code will still compile, but you'll get run-time errors only.

QMetaObject::activate is a Qt-internal equivalent to QMetaObject::invokeMethod - it works with signal indexes (generated by MOC), not their string names, so is slightly more efficient. And it looks after the thread affinity for you.

[Gerry Boland (gerboland)]

Functionally everything works ok. Please address my couple of comments above and then this will be good to go!

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:166
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/236/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/99
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/100
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/100/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/99

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

review: Approve (continuous-integration)

[Thomas Voß (thomas-voss)]

> > > +++ src/modules/Unity/Application/upstart/application_controller.cpp
> > > This is a very un-Qt piece of code, using some Qt methods. Making
> > > upstart::ApplicationController::ApplicationController not be a QObject
> means
> > > you loose Q_EMIT and have to go down the QMetaObject::invokeMethod road,
> > which
> > > drops compile-time checking, and deciding if signal can be direct or
> queued.
> > > You're also loosing readability, so where's the real gain?
> > >
> >
> > I guess I don't understand the difference between Q_EMIT and
> > QMetaObject::invoke then. How can a macro do compile-time checking,
> > specifically in the Qt signal/slot system? I get your point about
> > ::connect(...) with C++11 syntax but not about the emit case. For the direct
> > vs. queued question: ::connect() can only determine the correct setup if the
> > thread affinity of both objects is known at connect time iiuc. That's not
> > necessarily the case here as far as I can see.
>
> The MOC compiler helps out. For any Q_SIGNAL you declare in the header file,
> it generates an extra method in that class for it, for Q_SIGNAL void
> valueChanged(int) something like:
>
> void Class::valueChanged(int _t1)
> {
> void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1))
> };
> QMetaObject::activate(this, &staticMetaObject, 0, _a);
> }
>
> Then in the .cpp file, calling "Q_EMIT valueChanged(5)" reduces to
> "valueChanged(5)" which is a valid method since it was added by MOC (Q_EMIT is
> an empty macro, is more a hint for developer).
>
> Using QMetaObject::invokeMethod, you are not taking advantage of this compile
> time check. If the signal you're invoking is removed, the code will still
> compile, but you'll get run-time errors only.
>
> QMetaObject::activate is a Qt-internal equivalent to QMetaObject::invokeMethod
> - it works with signal indexes (generated by MOC), not their string names, so
> is slightly more efficient. And it looks after the thread affinity for you.

I switched to Q_EMIT. For thread affinity: Sure, that's certainly true but thread-affinity requires an explicit moveToThread iiuc, and we do not do that, yet. With that, it defaults to Qt::AutoConnection which resolves to Qt::DirectConnection in our particular case iiuc.

[Thomas Voß (thomas-voss)]

> > > For ApplicationController, I dislike the naming, the difference in purpose
> > > between "ApplicationManager" and "ApplicationController" is now not
> obvious
> > to
> > > me.
> > >
> > > Your making separate TaskController and ApplicationController is clear to
> me
> > -
> > > yes I see that ApplicationController is implementation specific (i.e. we
> > could
> > > have a systemd implementation later), and TaskController is implementation
> > > agnostic, that's clear.
> > >
> > > But I'd consider your using the process-cpp library an implementation
> > specific
> > > detail also - other init sytems may provide their own APIs to configure
> > things
> > > for an OOM killer. As a result, I think it makes more sense to have the
> > > TaskController interface and allow multiple possible implementations (so
> > > removing the ApplicationController).
> > >
> >
> > Okay, I can see that we should fold the ApplicationController into the
> > TaskController interface, but the Oom API I'm modelling here is independent
> of
> > the init system and only leverages kernel facilities. With that, and your
> > proposal to have an upstart::TaskController implementation, I would propose
> to
> > have an interface ProcessController that includes state control as well as
> oom
> > adjustments. TaskController would then depend on an implementation of
> > ProcessController. Makes sense?
>
> While I am averse to adding yet another class, yes that works for me. It does
> introduce further class naming confusion as how can one easily guess the
> difference between {Process,Application,Task}Controller. I'll maybe do a
> little refactoring to clarify.
>
>
> > I can see what I can do.
> >
> > > I prefer appending "Interface" or "Base" to the names of interfaces
> classes
> > > too.
> >
> > Dito
>
> Dito meaning you'll do it? Or you object?

I'm not a fan of Base or Interface to be honest. And given your proposal to refactor the class structure a little I'm wondering if we should minimize changes to this MP now and postpone any further adjustments to the class structure. What do you think? I'm happy to fuse both classes but I have a feeling that we need some more refactorings anyway.

[Gerry Boland (gerboland)]

> I'm not a fan of Base or Interface to be honest. And given your proposal to
> refactor the class structure a little I'm wondering if we should minimize
> changes to this MP now and postpone any further adjustments to the class
> structure. What do you think? I'm happy to fuse both classes but I have a
> feeling that we need some more refactorings anyway.
Yeah ok

[Gerry Boland (gerboland)]

Approved! Thanks

review: Approve

[Thomas Voß (thomas-voss)]

* 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, I installed the resulting package and checked that I can still run multiple apps in parallel.

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

[Gerry Boland (gerboland)]

 * 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

[Albert Astals Cid (aacid)]

m_focusedApplication is not initialized to null anymore causing a crash in unity8 start when ApplicationManager::focusedApplicationId is called

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:168
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/248/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/111
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/112
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/112/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/111

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

review: Approve (continuous-integration)

[lp:~thomas-voss/unity-mir/refactor-oom-score-adj-to-rely-on-process-cpp]

169. By Thomas Voß on 2014-02-11

Initialize ApplicationManager::m_focusedApplication to nullptr in ctor.

[Albert Astals Cid (aacid)]

Looks good :-)

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-01-15 14:59:00 +0000
+++ CMakeLists.txt	2014-02-11 09:48:32 +0000
@@ -2,6 +2,8 @@
 
 project(Unity-Mir)
 
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
+
 # Find includes in corresponding build directories
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 # Instruct CMake to run moc automatically when needed.
@@ -65,8 +67,6 @@
 add_subdirectory(src)
 add_subdirectory(data)
 
-# TODO(tvoss, pitti): With the build system switched to cmake, we can now
-# start adding unit- and integration tests for unity-mir.
 add_subdirectory(tests)
 
 # TODO(tvoss): Enable coverage reporting once we have tests in place.

=== modified file 'debian/control'
--- debian/control	2014-02-04 16:47:30 +0000
+++ debian/control	2014-02-11 09:48:32 +0000
@@ -4,10 +4,12 @@
 Maintainer: Ubuntu Developers <[e-mail]>
 Build-Depends: debhelper (>= 9),
                cmake,
+               google-mock (>= 1.6.0+svn437),
                pkg-config,
                libplatform-api1-dev,
                libmirserver-dev (>= 0.1.4),
                libmirclient-dev (>= 0.1.4),
+               libprocess-cpp-dev,
                libunity-api-dev,
                libupstart-app-launch2-dev,
                qt5-default,

=== modified file 'src/modules/Unity/Application/CMakeLists.txt'
--- src/modules/Unity/Application/CMakeLists.txt	2014-01-09 15:49:18 +0000
+++ src/modules/Unity/Application/CMakeLists.txt	2014-02-11 09:48:32 +0000
@@ -1,4 +1,5 @@
 pkg_check_modules(GLIB glib-2.0 REQUIRED)
+pkg_check_modules(PROCESS_CPP process-cpp REQUIRED)
 pkg_check_modules(UPSTART_APP_LAUNCH upstart-app-launch-2 REQUIRED)
 
 add_definitions(-DQT_PLUGIN)
@@ -7,6 +8,7 @@
   ${GLIB_INCLUDE_DIRS}
   ${MIRCOMMON_INCLUDE_DIRS}
   ${MIRSERVER_INCLUDE_DIRS}
+  ${PROCESS_CPP_INCLUDE_DIRS}
   ${UBUNTU_PLATFORM_API_INCLUDE_DIRS}
   ${UPSTART_APP_LAUNCH_INCLUDE_DIRS}
 
@@ -27,9 +29,15 @@
   mirsurfacemanager.cpp
   inputarea.cpp
   inputfilterarea.cpp
+  processcontroller.h
+  processcontroller.cpp
   shellinputarea.cpp
   ubuntukeyboardinfo.cpp
 
+  upstart/applicationcontroller.h
+  upstart/applicationcontroller.cpp
+
+  applicationcontroller.h
   application_manager.h
   application.h
   desktopfilereader.h
@@ -69,6 +77,8 @@
   ${UBUNTU_PLATFORM_API_LIBRARIES}
   ${MIRCOMMON_LIBRARIES}
   ${MIRSERVER_LIBRARIES}
+  ${PROCESS_CPP_LIBRARIES}
+  ${UBUNTU_PLATFORM_API_LIBRARIES}
   ${UPSTART_APP_LAUNCH_LIBRARIES}
 
   ubuntu_application_api_mirserver

=== modified file 'src/modules/Unity/Application/application.cpp'
--- src/modules/Unity/Application/application.cpp	2014-01-02 14:54:13 +0000
+++ src/modules/Unity/Application/application.cpp	2014-02-11 09:48:32 +0000
@@ -25,16 +25,15 @@
 
 // mir
 #include <mir/shell/session.h>
-
-Application::Application(const QString &appId, Application::State state,
-                         const QStringList &arguments, QObject *parent)
-    : Application(new DesktopFileReader(appId), state, arguments, parent)
-{
-}
-
-Application::Application(DesktopFileReader *desktopFileReader, State state,
-                         const QStringList &arguments, QObject *parent)
+#include <mir/shell/snapshot.h>
+
+Application::Application(const QSharedPointer<TaskController>& taskController,
+                         DesktopFileReader *desktopFileReader,
+                         State state,
+                         const QStringList &arguments,
+                         QObject *parent)
     : ApplicationInfoInterface(desktopFileReader->appId(), parent)
+    , m_taskController(taskController)
     , m_desktopData(desktopFileReader)
     , m_pid(0)
     , m_stage((m_desktopData->stageHint() == "SideStage") ? Application::SideStage : Application::MainStage)
@@ -220,17 +219,17 @@
 void Application::suspend()
 {
     DLOG("Application::suspend (this=%p)", this);
-    TaskController::singleton()->suspend(appId());
+    m_taskController->suspend(appId());
 }
 
 void Application::resume()
 {
     DLOG("Application::resume (this=%p)", this);
-    TaskController::singleton()->resume(appId());
+    m_taskController->resume(appId());
 }
 
 void Application::respawn()
 {
     DLOG("Application::respawn (this=%p)", this);
-    TaskController::singleton()->start(appId(), m_arguments);
+    m_taskController->start(appId(), m_arguments);
 }

=== modified file 'src/modules/Unity/Application/application.h'
--- src/modules/Unity/Application/application.h	2014-01-02 16:04:19 +0000
+++ src/modules/Unity/Application/application.h	2014-02-11 09:48:32 +0000
@@ -20,12 +20,10 @@
 // std
 #include <memory>
 
-// Mir
-#include <mir/shell/snapshot.h>
-
 //Qt
 #include <QtCore/QtCore>
 #include <QImage>
+#include <QSharedPointer>
 
 // Unity API
 #include <unity/shell/application/ApplicationInfoInterface.h>
@@ -43,8 +41,11 @@
     Q_PROPERTY(Stage stage READ stage WRITE setStage NOTIFY stageChanged)
 
 public:
-    Application(const QString &appId, State state, const QStringList &arguments, QObject *parent = 0);
-    Application(DesktopFileReader *desktopFileReader, State state, const QStringList &arguments, QObject *parent = 0);
+    Application(const QSharedPointer<TaskController>& taskController,
+                DesktopFileReader *desktopFileReader,
+                State state,
+                const QStringList &arguments,
+                QObject *parent = 0);
     virtual ~Application();
 
     // ApplicationInfoInterface
@@ -82,6 +83,7 @@
     void setSession(const std::shared_ptr<mir::shell::Session>& session);
     void setSessionName(const QString& name);
 
+    QSharedPointer<TaskController> m_taskController;
     DesktopFileReader* m_desktopData;
     qint64 m_pid;
     Stage m_stage;

=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2014-01-16 11:57:16 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2014-02-11 09:48:32 +0000
@@ -19,6 +19,8 @@
 #include "application.h"
 #include "desktopfilereader.h"
 #include "dbuswindowstack.h"
+#include "taskcontroller.h"
+#include "upstart/applicationcontroller.h"
 
 // unity-mir
 #include "qmirserverapplication.h"
@@ -31,6 +33,7 @@
 #include "logging.h"
 
 // mir
+#include <mir/scene/depth_id.h>
 #include <mir/shell/session.h>
 #include <mir/shell/focus_controller.h>
 #include <mir/shell/surface.h>
@@ -53,23 +56,34 @@
 ApplicationManager* ApplicationManager::singleton()
 {
     if (!the_application_manager) {
-        the_application_manager = new ApplicationManager();
+        the_application_manager = new ApplicationManager(
+                    QSharedPointer<TaskController>(
+                        new TaskController(
+                            nullptr,
+                            QSharedPointer<ApplicationController>(
+                                new upstart::ApplicationController()))),
+                    QSharedPointer<DesktopFileReader::Factory>(
+                        new DesktopFileReader::Factory()));
     }
     return the_application_manager;
 }
 
-ApplicationManager::ApplicationManager(QObject *parent)
-:   ApplicationManagerInterface(parent)
-,   m_focusedApplication(nullptr)
-,   m_mainStageApplication(nullptr)
-,   m_sideStageApplication(nullptr)
-,   m_msApplicationToBeFocused(nullptr)
-,   m_ssApplicationToBeFocused(nullptr)
-,   m_lifecycleExceptions(QStringList() << "com.ubuntu.music")
-,   m_taskController(TaskController::singleton())
-,   m_gridUnitPx(8)
-,   m_fenceNext(false)
-,   m_panelHeight(54)
+ApplicationManager::ApplicationManager(
+        const QSharedPointer<TaskController>& taskController,
+        const QSharedPointer<DesktopFileReader::Factory>& desktopFileReaderFactory,
+        QObject *parent)
+    : ApplicationManagerInterface(parent)
+    , m_focusedApplication(nullptr)
+    , m_mainStageApplication(nullptr)
+    , m_sideStageApplication(nullptr)
+    , m_msApplicationToBeFocused(nullptr)
+    , m_ssApplicationToBeFocused(nullptr)
+    , m_lifecycleExceptions(QStringList() << "com.ubuntu.music")
+    , m_taskController(taskController)
+    , m_desktopFileReaderFactory(desktopFileReaderFactory)
+    , m_gridUnitPx(8)
+    , m_fenceNext(false)
+    , m_panelHeight(54)
 {
     DLOG("ApplicationManager::ApplicationManager (this=%p)", this);
 
@@ -280,7 +294,12 @@
         return nullptr;
     }
 
-    Application* application = new Application(appId, Application::Starting, arguments, this);
+    Application* application = new Application(
+                m_taskController,
+                m_desktopFileReaderFactory->createInstanceForAppId(appId),
+                Application::Starting,
+                arguments,
+                this);
     if (!application->isValid()) {
         DLOG("Unable to instantiate application with appId '%s'", qPrintable(appId));
         return nullptr;
@@ -307,7 +326,11 @@
     Application *application = findApplication(appId);
 
     if (!application) { // if shell did not start this application, but upstart did
-        application = new Application(appId, Application::Starting, QStringList(), this);
+        application = new Application(
+                    m_taskController,
+                    m_desktopFileReaderFactory->createInstanceForAppId(appId),
+                    Application::Starting,
+                    QStringList(), this);
         if (!application->isValid()) {
             DLOG("Unable to instantiate application with appId '%s'", qPrintable(appId));
             return;
@@ -370,7 +393,7 @@
             removeApplication = true;
         }
 
-        if (application->state() == Application::Running) {
+        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;
@@ -472,9 +495,9 @@
     // case we didn't get an existing .desktop file path
     DesktopFileReader* desktopData;
     if (QFileInfo(desktopFileName).exists()) {
-        desktopData = new DesktopFileReader(QFileInfo(desktopFileName));
+        desktopData = m_desktopFileReaderFactory->createInstanceForDesktopFile(QFileInfo(desktopFileName));
     } else {
-        desktopData = new DesktopFileReader(desktopFileName);
+        desktopData = m_desktopFileReaderFactory->createInstanceForAppId(desktopFileName);
     }
 
     if (!desktopData->loaded()) {
@@ -510,7 +533,7 @@
 
     QString argStr(command.data());
     QStringList arguments(argStr.split(' '));
-    application = new Application(desktopData, Application::Starting, arguments, this);
+    application = new Application(m_taskController, desktopData, Application::Starting, arguments, this);
     application->setPid(pid);
     application->setStage(stage);
     add(application);
@@ -574,9 +597,16 @@
     // in case application closed not by hand of shell, check again here:
     Application* application = findApplicationWithSession(session);
     if (application) {
-        application->setState(Application::Stopped);
-        application->setSession(nullptr);
-        m_dbusWindowStack->WindowDestroyed(0, application->appId());
+        bool removeApplication = true;
+
+        if (application->state() != Application::Starting) {
+            application->setState(Application::Stopped);
+            application->setSession(nullptr);
+            m_dbusWindowStack->WindowDestroyed(0, application->appId());
+            if (application != m_focusedApplication) {
+	            removeApplication = false;
+            }
+        }
 
         if (m_mainStageApplication == application)
             m_mainStageApplication = nullptr;
@@ -584,7 +614,7 @@
         if (m_sideStageApplication == application)
             m_sideStageApplication = nullptr;
 
-        if (application == m_focusedApplication) {
+        if (removeApplication) {
             // TODO(greyback) What to do?? Focus next app, or unfocus everything??
             m_focusedApplication = NULL;
             remove(application);

=== modified file 'src/modules/Unity/Application/application_manager.h'
--- src/modules/Unity/Application/application_manager.h	2014-01-16 11:57:16 +0000
+++ src/modules/Unity/Application/application_manager.h	2014-02-11 09:48:32 +0000
@@ -17,11 +17,15 @@
 #ifndef APPLICATIONMANAGER_H
 #define APPLICATIONMANAGER_H
 
+// local
+#include "desktopfilereader.h"
+
 // std
 #include <memory>
 
 // Qt
 #include <QObject>
+#include <QSharedPointer>
 #include <QStringList>
 
 // Unity API
@@ -30,8 +34,6 @@
 // local
 #include "application.h"
 
-#include <mir/scene/depth_id.h>
-
 class ShellServerConfiguration;
 class DBusWindowStack;
 class MirSurfaceManager;
@@ -62,7 +64,9 @@
 
     static ApplicationManager* singleton();
 
-    explicit ApplicationManager(QObject *parent = 0);
+    explicit ApplicationManager(const QSharedPointer<TaskController>& taskController,
+                                const QSharedPointer<DesktopFileReader::Factory>& desktopFileReaderFactory,
+                                QObject *parent = 0);
     virtual ~ApplicationManager();
 
     // ApplicationManagerInterface
@@ -128,7 +132,8 @@
     QStringList m_lifecycleExceptions;
     ShellServerConfiguration* m_mirServer;
     DBusWindowStack* m_dbusWindowStack;
-    QScopedPointer<TaskController> m_taskController;
+    QSharedPointer<TaskController> m_taskController;
+    QSharedPointer<DesktopFileReader::Factory> m_desktopFileReaderFactory;
     static ApplicationManager* the_application_manager;
     int m_gridUnitPx;
     bool m_fenceNext;

=== added file 'src/modules/Unity/Application/applicationcontroller.h'
--- src/modules/Unity/Application/applicationcontroller.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/applicationcontroller.h	2014-02-11 09:48:32 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef APPLICATION_CONTROLLER_H
+#define APPLICATION_CONTROLLER_H
+
+#include <QObject>
+#include <QString>
+#include <QStringList>
+
+class ApplicationController : public QObject
+{
+    Q_OBJECT
+
+public:
+    enum class Error
+    {
+        APPLICATION_CRASHED,
+        APPLICATION_FAILED_TO_START
+    };
+
+    ApplicationController(const ApplicationController&) = delete;
+    virtual ~ApplicationController() = default;
+
+    ApplicationController& operator=(const ApplicationController&) = delete;
+
+    virtual pid_t primaryPidForAppId(const QString& appId) = 0;
+    virtual bool appIdHasProcessId(pid_t pid, const QString& appId) = 0;
+
+    virtual bool stopApplicationWithAppId(const QString& appId) = 0;
+    virtual bool startApplicationWithAppIdAndArgs(const QString& appId, const QStringList& arguments) = 0;
+
+Q_SIGNALS:
+    void applicationAboutToBeStarted(QString id);
+    void applicationStarted(QString id);
+    void applicationStopped(QString id);
+    void applicationFocusRequest(QString id);
+    void applicationResumeRequest(QString id);
+
+    void applicationError(QString id, ApplicationController::Error error);
+
+protected:
+    ApplicationController() = default;
+};
+
+#endif // APPLICATION_CONTROLLER_H

=== modified file 'src/modules/Unity/Application/desktopfilereader.cpp'
--- src/modules/Unity/Application/desktopfilereader.cpp	2013-10-14 09:21:43 +0000
+++ src/modules/Unity/Application/desktopfilereader.cpp	2014-02-11 09:48:32 +0000
@@ -25,6 +25,24 @@
 #include <QDir>
 #include <QStandardPaths>
 
+DesktopFileReader::Factory::Factory()
+{
+}
+
+DesktopFileReader::Factory::~Factory()
+{
+}
+
+DesktopFileReader* DesktopFileReader::Factory::createInstanceForAppId(const QString& appId)
+{
+    return new DesktopFileReader(appId);
+}
+
+DesktopFileReader* DesktopFileReader::Factory::createInstanceForDesktopFile(const QFileInfo& fi)
+{
+    return new DesktopFileReader(fi);
+}
+
 // Retrieves the size of an array at compile time.
 #define ARRAY_SIZE(a) \
     ((sizeof(a) / sizeof(*(a))) / static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))

=== modified file 'src/modules/Unity/Application/desktopfilereader.h'
--- src/modules/Unity/Application/desktopfilereader.h	2013-10-10 16:26:03 +0000
+++ src/modules/Unity/Application/desktopfilereader.h	2014-02-11 09:48:32 +0000
@@ -23,20 +23,37 @@
 
 class DesktopFileReader {
 public:
+    class Factory
+    {
+    public:
+        Factory();
+        Factory(const Factory&) = delete;
+        virtual ~Factory();
+
+        Factory& operator=(const Factory&) = delete;
+
+        virtual DesktopFileReader* createInstanceForAppId(const QString& appId);
+        virtual DesktopFileReader* createInstanceForDesktopFile(const QFileInfo& fi);
+    };
+
+    virtual ~DesktopFileReader();
+
+    virtual QString file() const { return file_; }
+    virtual QString appId() const { return appId_; }
+    virtual QString name() const { return entries_[kNameIndex]; }
+    virtual QString comment() const { return entries_[kCommentIndex]; }
+    virtual QString icon() const { return entries_[kIconIndex]; }
+    virtual QString exec() const { return entries_[kExecIndex]; }
+    virtual QString path() const { return entries_[kPathIndex]; }
+    virtual QString stageHint() const { return entries_[kStageHintIndex]; }
+    virtual bool loaded() const { return loaded_; }
+    virtual QString findDesktopFile(const QString &appId) const;
+
+protected:
+    friend class DesktopFileReaderFactory;
+
     DesktopFileReader(const QString &appId);
     DesktopFileReader(const QFileInfo &desktopFile);
-    ~DesktopFileReader();
-
-    QString file() const { return file_; }
-    QString appId() const { return appId_; }
-    QString name() const { return entries_[kNameIndex]; }
-    QString comment() const { return entries_[kCommentIndex]; }
-    QString icon() const { return entries_[kIconIndex]; }
-    QString exec() const { return entries_[kExecIndex]; }
-    QString path() const { return entries_[kPathIndex]; }
-    QString stageHint() const { return entries_[kStageHintIndex]; }
-    bool loaded() const { return loaded_; }
-    QString findDesktopFile(const QString &appId) const;
 
 private:
     static const int kNameIndex = 0,
@@ -47,7 +64,7 @@
     kStageHintIndex = 5,
     kNumberOfEntries = 6;
 
-    bool loadDesktopFile(QString desktopFile);
+    virtual bool loadDesktopFile(QString desktopFile);
 
     QString appId_;
     QString file_;

=== added file 'src/modules/Unity/Application/processcontroller.cpp'
--- src/modules/Unity/Application/processcontroller.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/processcontroller.cpp	2014-02-11 09:48:32 +0000
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "processcontroller.h"
+
+#include "logging.h"
+
+// Process C++
+#include <core/posix/process.h>
+#include <core/posix/this_process.h>
+#include <core/posix/linux/proc/process/oom_adj.h>
+#include <core/posix/linux/proc/process/oom_score_adj.h>
+
+// std
+#include <signal.h>
+#include <unistd.h>
+
+namespace plpp = core::posix::linux::proc::process;
+
+ProcessController::OomController::OomController()
+{
+}
+
+void ProcessController::OomController::ensureProcessLikelyToBeKilled(pid_t pid)
+{
+    // We avoid boundary values for oom_score_adj. For that, we
+    // set it to 80% of the total available range.
+    static const float defaultPercentage = 0.8;
+
+    core::posix::Process process(pid);
+
+    try {
+        plpp::OomScoreAdj shellScore;
+        core::posix::this_process::instance() >> shellScore;
+
+        plpp::OomScoreAdj processScore
+        {
+            static_cast<int>((plpp::OomScoreAdj::max_value() - shellScore.value) * defaultPercentage) + shellScore.value
+        };
+
+        process << processScore;
+    } catch(...) {
+        // Accessing OomScoreAdj resulted in an exception being thrown.
+        // Trying with the deprecated OomAdj now as a last resort.
+        try
+        {
+            process << plpp::OomAdj{plpp::OomAdj::max_value()};
+        } catch(...)
+        {
+            LOG("ensureProcessIsLikelyToBeKilled failed");
+        }
+    }
+}
+
+void ProcessController::OomController::ensureProcessUnlikelyToBeKilled(pid_t pid)
+{
+    // By system default, we set the oom_score_adj of Unity8 to -10 (via lightdm).
+    // As we want to avoid that any app's oom_score_adj is <= Unity8's oom_score_adj,
+    // we choose a default increase of +1.
+    static const int default_increase = 1;
+
+    core::posix::Process process(pid);
+
+    try {
+        plpp::OomScoreAdj shellScore;
+        core::posix::this_process::instance() >> shellScore;
+
+        plpp::OomScoreAdj processScore
+        {
+            shellScore.value + default_increase
+        };
+
+        process << processScore;
+    } catch(...) {
+        // Accessing OomScoreAdj resulted in an exception being thrown.
+        // Trying with the deprecated OomAdj now as a last resort.
+        // By system default, we set the oom_score_adj of Unity8 to -10 (via lightdm).
+        // As we want to avoid that any app's oom_score_adj or oom_adj is <= Unity8's oom_score_adj,
+        // we choose a default value of -9 for oom_score_adj and 0 for oom_adj.
+        static const int defaultValue = 0;
+
+        try
+        {
+            process << plpp::OomAdj{defaultValue};
+        } catch(...)
+        {
+            LOG("ensureProcessIsUnlikelyToBeKilled failed");
+        }
+    }
+}
+
+ProcessController::ProcessController()
+    : m_oomController(new ProcessController::OomController())
+{
+}
+
+ProcessController::~ProcessController()
+{
+}
+
+const QSharedPointer<ProcessController::OomController>& ProcessController::oomController() const
+{
+    return m_oomController;
+}
+
+bool ProcessController::sigStopProcessGroupForPid(pid_t pid) const
+{
+    return -1 != kill(-pid, SIGSTOP);
+}
+
+bool ProcessController::sigContinueProcessGroupForPid(pid_t pid) const
+{
+    return -1 != kill(-pid, SIGCONT);
+}

=== added file 'src/modules/Unity/Application/processcontroller.h'
--- src/modules/Unity/Application/processcontroller.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/processcontroller.h	2014-02-11 09:48:32 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef PROCESS_CONTROLLER_H
+#define PROCESS_CONTROLLER_H
+
+#include <QSharedPointer>
+
+#include <sys/types.h>
+
+class ProcessController
+{
+public:
+    class OomController
+    {
+    public:
+        OomController();
+        OomController(const OomController&) = delete;
+        virtual ~OomController() = default;
+
+        OomController& operator=(const OomController&) = delete;
+
+        virtual void ensureProcessLikelyToBeKilled(pid_t);
+        virtual void ensureProcessUnlikelyToBeKilled(pid_t);
+    };
+
+    ProcessController();
+    ProcessController(const ProcessController&) = delete;
+    virtual ~ProcessController();
+
+    ProcessController& operator=(const ProcessController&) = delete;
+
+    virtual const QSharedPointer<OomController>& oomController() const;
+
+    virtual bool sigStopProcessGroupForPid(pid_t pid) const;
+    virtual bool sigContinueProcessGroupForPid(pid_t pid) const;
+
+protected:
+    QSharedPointer<OomController> m_oomController;
+};
+
+#endif // PROCESS_CONTROLLER_H

=== modified file 'src/modules/Unity/Application/taskcontroller.cpp'
--- src/modules/Unity/Application/taskcontroller.cpp	2013-12-05 17:30:57 +0000
+++ src/modules/Unity/Application/taskcontroller.cpp	2014-02-11 09:48:32 +0000
@@ -25,6 +25,12 @@
 // Qt
 #include <QStringList>
 
+// Process C++
+#include <core/posix/process.h>
+#include <core/posix/this_process.h>
+#include <core/posix/linux/proc/process/oom_adj.h>
+#include <core/posix/linux/proc/process/oom_score_adj.h>
+
 // STL
 #include <mutex>
 
@@ -35,362 +41,61 @@
 #include <signal.h>
 #include <unistd.h>
 
-// linux specific
-#include <linux/oom.h>
-
-namespace
-{
-/**
- * From man proc:
- *
- * This file can be used to adjust the score used to select which
- * process should be killed in an out-of-memory (OOM) situation.  The
- * kernel uses this value for a bit-shift opera‐ tion of the process's
- * oom_score value: valid values are in the range -16 to +15, plus the
- * special value -17, which disables OOM-killing altogether for this
- * process.  A posi‐ tive score increases the likelihood of this process
- * being killed by the OOM-killer; a negative score decreases the
- * likelihood.
- *
- * The default value for this file is 0; a new process inherits its
- * parent's oom_adj setting.  A process must be privileged
- * (CAP_SYS_RESOURCE) to update this file.
-
- * Since Linux 2.6.36, use of this file is deprecated in favor of
- * /proc/[pid]/oom_score_adj.
- */
-struct OomAdjuster
-{
-    static int disableOomKillerValue()
-    {
-        return OOM_DISABLE;
-    }
-
-    static int minValue()
-    {
-        return OOM_ADJUST_MIN;
-    }
-
-    static int maxValue()
-    {
-        return OOM_ADJUST_MAX;
-    }
-
-    static OomAdjuster leastLikelyToBeKilled()
-    {
-        // By system default, we set the oom_score_adj of Unity8 to -10 (via lightdm).
-        // As we want to avoid that any app's oom_score_adj or oom_adj is <= Unity8's oom_score_adj,
-        // we choose a default value of -9 for oom_score_adj and 0 for oom_adj.
-        static const int default_value = 0;
-
-        return OomAdjuster(default_value);
-    }
-
-    static OomAdjuster mostLikelyToBeKilled()
-    {
-        return OomAdjuster(maxValue());
-    }
-
-    OomAdjuster(int value) : value(value)
-    {
-    }
-
-    bool isValid() const
-    {
-        return !(value < disableOomKillerValue() || value > maxValue());
-    }
-
-    bool applyForPid(pid_t pid) const
-    {
-        auto fn = QString("/proc/%1/oom_adj").arg(pid);
-        QFile file(fn);
-
-        if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
-            return false;
-
-        QTextStream out(&file);
-        out << value;
-
-        return true;
-    }
-
-    int value;
-};
-
-/**
- * From man proc:
- *
- *  This file can be used to adjust the badness heuristic used to
- *  select which process gets killed in out-of-memory conditions.
- *
- *  The badness heuristic assigns a value to each candidate
- *  task ranging from 0 (never kill) to 1000 (always kill)
- *  to determine which process is targeted.  The units are
- *  roughly a proportion along that range of allowed memory
- *  the process may allocate from, based on an estimation of
- *  its current memory and swap use.  For example, if a task
- *  is using all allowed memory, its badness score will be
- *  1000.  If it is using half of its allowed memory, its
- *  score will be 500.
- *
- *  There is an additional factor included in the badness score: root
- *  processes are given 3% extra memory over other tasks.
- *
- *  The amount of "allowed" memory depends on the context in
- *  which the OOM-killer was called.  If it is due to the
- *  memory assigned to the allocating task's cpuset being
- *  exhausted, the allowed memory represents the set of mems
- *  assigned to that cpuset (see cpuset(7)).  If it is due
- *  to a mempolicy's node(s) being exhausted, the allowed
- *  memory represents the set of mempolicy nodes.  If it is
- *  due to a memory limit (or swap limit) being reached, the
- *  allowed memory is that configured limit.  Finally, if it
- *  is due to the entire system being out of memory, the
- *  allowed memory represents all allocatable resources.
- *
- *  The value of oom_score_adj is added to the badness score before it
- *  is used to determine which task to kill.  Acceptable values range
- *  from -1000 (OOM_SCORE_ADJ_MIN) to +1000 (OOM_SCORE_ADJ_MAX).  This
- *  allows user space to control the preference for OOM-killing,
- *  ranging from always preferring a certain task or completely
- *  disabling it from OOM- killing.  The lowest possible value, -1000,
- *  is equivalent to disabling OOM-killing entirely for that task,
- *  since it will always report a badness score of 0.
- *
- *  Consequently, it is very simple for user space to define the amount
- *  of memory to consider for each task.  Setting a oom_score_adj value
- *  of +500, for example, is roughly equiv‐ alent to allowing the
- *  remainder of tasks sharing the same system, cpuset, mempolicy, or
- *  memory controller resources to use at least 50% more memory.  A
- *  value of -500, on the other hand, would be roughly equivalent to
- *  discounting 50% of the task's allowed memory from being considered
- *  as scoring against the task.
- *
- *  For backward compatibility with previous kernels,
- *  /proc/[pid]/oom_adj can still be used to tune the badness score.
- *  Its value is scaled linearly with oom_score_adj.
- *
- *  Writing to /proc/[pid]/oom_score_adj or
- *  /proc/[pid]/oom_adj will change the other with its
- *  scaled value.
- */
-struct OomScoreAdjuster
-{
-    static int disableOomKillerValue()
-    {
-        return OOM_SCORE_ADJ_MIN;
-    }
-
-    static int minValue()
-    {
-        return OOM_SCORE_ADJ_MIN;
-    }
-
-    static int maxValue()
-    {
-        return OOM_SCORE_ADJ_MAX;
-    }
-
-    static OomScoreAdjuster leastLikelyToBeKilled()
-    {
-        // By system default, we set the oom_score_adj of Unity8 to -10 (via lightdm).
-        // As we want to avoid that any app's oom_score_adj is <= Unity8's oom_score_adj,
-        // we choose a default value of -9, and a default increase of +1.
-        static const int default_value = -9;
-        static const int default_increase = 1;
-        
-
-        // We could be way more clever here if we knew the distribution
-        // of oom_score_adj values of all app processes. However, we just
-        // make sure that the process is not ignored by the oom killer for now.
-        return OomScoreAdjuster(
-            OomScoreAdjuster::thisProcess().isValid() ?
-            OomScoreAdjuster::thisProcess().value + default_increase :
-            default_value);
-    }
-
-    static OomScoreAdjuster mostLikelyToBeKilled()
-    {
-        // We avoid extremal values for oom_score_adj. For that, we
-        // set it to 80% of the total available range. If we cannot
-        // determine the oom_score_adj of the current process, i.e.,
-        // Unity8, we substract -200 by default.
-        static const float default_percentage = 0.8;
-        static const int default_decrease = -200;
-
-        return OomScoreAdjuster(
-            OomScoreAdjuster::thisProcess().isValid() ?
-            (maxValue() - OomScoreAdjuster::thisProcess().value) * default_percentage + OomScoreAdjuster::thisProcess().value :
-            maxValue() - default_decrease);
-    }
-
-    static const OomScoreAdjuster& thisProcess()
-    {
-        // Initialize as invalid.
-        static OomScoreAdjuster adjusterForThisProcess(minValue()-1);
-
-        static std::once_flag query_once;
-        std::call_once(
-            query_once,
-            []()
-            {
-                pid_t pid = getpid();
-
-                auto fn = QString("/proc/%1/oom_score_adj").arg(pid);
-                QFile file(fn);
-
-                if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
-                    return;
-
-                QTextStream in(&file);
-                int value; in >> value;
-
-                adjusterForThisProcess.value = value;
-            });
-
-        return adjusterForThisProcess;
-    }
-
-    OomScoreAdjuster(int value) : value(value)
-    {
-    }
-
-    bool isValid() const
-    {
-        return !(value < disableOomKillerValue() || value > maxValue());
-    }
-
-    bool applyForPid(pid_t pid) const
-    {
-        auto fn = QString("/proc/%1/oom_score_adj").arg(pid);
-        QFile file(fn);
-
-        if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
-            return false;
-
-        QTextStream out(&file);
-        out << value;
-
-        return true;
-    }
-
-    int value;
-};
-
-void ensureProcessIsUnlikelyToBeKilled(pid_t pid)
-{
-    if (!OomScoreAdjuster::leastLikelyToBeKilled().applyForPid(pid))
-        if (!OomAdjuster::leastLikelyToBeKilled().applyForPid(pid))
-            LOG("ensureProcessIsUnlikelyToBeKilled failed");
-}
-
-void ensureProcessIsLikelyToBeKilled(pid_t pid)
-{
-    if (!OomScoreAdjuster::mostLikelyToBeKilled().applyForPid(pid))
-        if (!OomAdjuster::mostLikelyToBeKilled().applyForPid(pid))
-            LOG("ensureProcessIsLikelyToBeKilled failed");
-}
-}
-
-TaskController* TaskController::m_theTaskController = nullptr;
-
-TaskController* TaskController::singleton()
-{
-    if (!m_theTaskController) {
-        m_theTaskController = new TaskController();
-    }
-    return m_theTaskController;
-}
-
-TaskController::TaskController(QObject *parent) :
-    QObject(parent)
-{
-    preStartCallback = [](const gchar * appId, gpointer userData) {
-        Q_UNUSED(userData)
-        Q_EMIT TaskController::singleton()->processStartReport(QString(appId), false);
-    };
-
-    startedCallback = [](const gchar * appId, gpointer userData) {
-        Q_UNUSED(userData)
-        pid_t pid = upstart_app_launch_get_primary_pid(appId);
-        ensureProcessIsUnlikelyToBeKilled(pid);
-    };
-
-    stopCallback = [](const gchar * appId, gpointer userData) {
-        Q_UNUSED(userData)
-        Q_EMIT TaskController::singleton()->processStopped(QString(appId), false);
-    };
-
-    focusCallback = [](const gchar * appId, gpointer userData) {
-        Q_UNUSED(userData)
-        pid_t pid = upstart_app_launch_get_primary_pid(appId);
-        ensureProcessIsUnlikelyToBeKilled(pid);
-        Q_EMIT TaskController::singleton()->requestFocus(QString(appId));
-    };
-
-    resumeCallback = [](const gchar * appId, gpointer userData) {
-        Q_UNUSED(userData)
-        Q_EMIT TaskController::singleton()->requestResume(QString(appId));
-    };
-
-    failureCallback = [](const gchar * appId, upstart_app_launch_app_failed_t failureType, gpointer userData) {
-        Q_UNUSED(userData)
-        if (failureType == UPSTART_APP_LAUNCH_APP_FAILED_CRASH) {
-            Q_EMIT TaskController::singleton()->processStopped(QString(appId), true);
-        } else if (failureType == UPSTART_APP_LAUNCH_APP_FAILED_START_FAILURE) {
-            Q_EMIT TaskController::singleton()->processStartReport(QString(appId), true);
-        } else {
-            LOG("TaskController: unknown failure type returned from upstart-app-launch");
-        }
-        Q_EMIT TaskController::singleton()->requestResume(QString(appId));
-    };
-
-    upstart_app_launch_observer_add_app_starting(preStartCallback, nullptr);
-    upstart_app_launch_observer_add_app_started(startedCallback, nullptr);
-    upstart_app_launch_observer_add_app_stop(stopCallback, nullptr);
-    upstart_app_launch_observer_add_app_focus(focusCallback, nullptr);
-    upstart_app_launch_observer_add_app_resume(resumeCallback, nullptr);
-    upstart_app_launch_observer_add_app_failed(failureCallback, nullptr);
+
+
+TaskController::TaskController(
+        QObject* parent,
+        const QSharedPointer<ApplicationController>& appController,
+        const QSharedPointer<ProcessController>& processController) :
+    QObject(parent),
+    m_appController(appController),
+    m_processController(processController)
+{
+    connect(m_appController.data(),
+            &ApplicationController::applicationAboutToBeStarted,
+            this,
+            &TaskController::onApplicationAboutToBeStarted);
+
+    connect(m_appController.data(),
+            &ApplicationController::applicationStarted,
+            this,
+            &TaskController::onApplicationStarted);
+
+    connect(m_appController.data(),
+            &ApplicationController::applicationStopped,
+            this,
+            &TaskController::onApplicationStopped);
+
+    connect(m_appController.data(),
+            &ApplicationController::applicationFocusRequest,
+            this,
+            &TaskController::onApplicationFocusRequest);
+
+    connect(m_appController.data(),
+            &ApplicationController::applicationResumeRequest,
+            this,
+            &TaskController::onApplicationResumeRequest);
+
+    connect(m_appController.data(),
+            &ApplicationController::applicationError,
+            this,
+            &TaskController::onApplicationError);
 }
 
 TaskController::~TaskController()
 {
-    upstart_app_launch_observer_delete_app_starting(preStartCallback, nullptr);
-    upstart_app_launch_observer_delete_app_started(startedCallback, nullptr);
-    upstart_app_launch_observer_delete_app_stop(stopCallback, nullptr);
-    upstart_app_launch_observer_delete_app_focus(focusCallback, nullptr);
-    upstart_app_launch_observer_delete_app_resume(resumeCallback, nullptr);
-    upstart_app_launch_observer_delete_app_failed(failureCallback, nullptr);
 }
 
 bool TaskController::start(const QString& appId, const QStringList& arguments)
 {
     DLOG("TaskController::start appId='%s'", qPrintable(appId));
-    gchar ** upstartArgs = nullptr;
-    bool result = false;
-
-    // Convert arguments QStringList into format suitable for upstart-app-launch
-    upstartArgs = g_new0(gchar *, arguments.length());
-
-    for (int i=0; i<arguments.length(); i++) {
-        upstartArgs[i] = arguments.at(i).toLatin1().data();
-    }
-
-    result = upstart_app_launch_start_application(appId.toLatin1().constData(),
-                                                  static_cast<const gchar * const *>(upstartArgs));
-    g_free(upstartArgs);
-
-    DLOG_IF(!result, "TaskController::startApplication appId='%s' FAILED", qPrintable(appId));
-    return result;
+    return m_appController->startApplicationWithAppIdAndArgs(appId, arguments);
 }
 
 bool TaskController::stop(const QString& appId)
 {
     DLOG("TaskController::stop appId='%s'", qPrintable(appId));
-    bool result = false;
-
-    result = upstart_app_launch_stop_application(appId.toLatin1().constData());
-
+    auto result = m_appController->stopApplicationWithAppId(appId);
     DLOG_IF(!result, "TaskController::stopApplication appId='%s' FAILED", qPrintable(appId));
     return result;
 }
@@ -398,22 +103,20 @@
 bool TaskController::appIdHasProcessId(const QString& appId, const quint64 pid)
 {
     DLOG("TaskController::isApplicationPid appId='%s', pid=%lld", qPrintable(appId), pid);
-    return upstart_app_launch_pid_in_app_id(pid, appId.toLatin1().constData());
+    return m_appController->appIdHasProcessId(pid, appId);
 }
 
 bool TaskController::suspend(const QString& appId)
 {
     DLOG("TaskController::suspend (this=%p, application=%p)", this, qPrintable(appId));
-    pid_t pid = upstart_app_launch_get_primary_pid(appId.toLatin1().constData());
-
-    ensureProcessIsLikelyToBeKilled(pid);
+    pid_t pid = m_appController->primaryPidForAppId(appId);
+    m_processController->oomController()->ensureProcessLikelyToBeKilled(pid);
 
     if (pid) {
         // We do assume that the app was launched by upstart and with that,
         // in its own process group. For that, we interpret the pid as pgid and
         // sigstop the complete process group on suspend.
-        kill(-pid, SIGSTOP);
-        return true;
+        return m_processController->sigStopProcessGroupForPid(pid);
     } else {
         return false;
     }
@@ -422,17 +125,61 @@
 bool TaskController::resume(const QString& appId)
 {
     DLOG("TaskController::resume (this=%p, application=%p)", this, qPrintable(appId));
-    pid_t pid = upstart_app_launch_get_primary_pid(appId.toLatin1().constData());
+    pid_t pid = m_appController->primaryPidForAppId(appId);
 
-    ensureProcessIsUnlikelyToBeKilled(pid);
+    m_processController->oomController()->ensureProcessUnlikelyToBeKilled(pid);
 
     if (pid) {
         // We do assume that the app was launched by upstart and with that,
         // in its own process group. For that, we interpret the pid as pgid and
         // sigcont the complete process group on resume.
-        kill(-pid, SIGCONT);
+        return m_processController->sigContinueProcessGroupForPid(pid);
         return true;
     } else {
         return false;
     }
 }
+
+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);
+    m_processController->oomController()->ensureProcessUnlikelyToBeKilled(pid);
+    Q_EMIT requestFocus(id);
+}
+
+void TaskController::onApplicationResumeRequest(const QString& id)
+{
+    Q_EMIT requestResume(id);
+}
+
+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;
+    }
+
+    // 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	2013-12-05 17:11:36 +0000
+++ src/modules/Unity/Application/taskcontroller.h	2014-02-11 09:48:32 +0000
@@ -22,17 +22,17 @@
 #include <QObject>
 
 #include "application.h"
-
-// upstart
-extern "C" {
-    #include "upstart-app-launch.h"
-}
+#include "applicationcontroller.h"
+#include "processcontroller.h"
 
 class TaskController : public QObject
 {
     Q_OBJECT
 public:
-    static TaskController* singleton();
+    TaskController(
+            QObject* parent,
+            const QSharedPointer<ApplicationController>& app_controller,
+            const QSharedPointer<ProcessController>& processController = QSharedPointer<ProcessController>(new ProcessController()));
     ~TaskController();
 
     bool start(const QString& appId, const QStringList& args);
@@ -49,12 +49,18 @@
     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);
+
+    void onApplicationError(const QString& id, ApplicationController::Error error);
+
 private:
-    TaskController(QObject *parent = 0);
-
-    static TaskController* m_theTaskController;
-    upstart_app_launch_app_observer_t preStartCallback, startedCallback, stopCallback, focusCallback, resumeCallback;
-    upstart_app_launch_app_failed_observer_t failureCallback;
+    QSharedPointer<ApplicationController> m_appController;
+    QSharedPointer<ProcessController> m_processController;
 };
 
 #endif // TASKCONTROLLER_H

=== added directory 'src/modules/Unity/Application/upstart'
=== added file 'src/modules/Unity/Application/upstart/applicationcontroller.cpp'
--- src/modules/Unity/Application/upstart/applicationcontroller.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/upstart/applicationcontroller.cpp	2014-02-11 09:48:32 +0000
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "applicationcontroller.h"
+
+// unity-mir
+#include <logging.h>
+
+// upstart
+extern "C" {
+    #include "upstart-app-launch.h"
+}
+
+struct upstart::ApplicationController::Private
+{
+    upstart_app_launch_app_observer_t preStartCallback = nullptr;
+    upstart_app_launch_app_observer_t startedCallback = nullptr;
+    upstart_app_launch_app_observer_t stopCallback = nullptr;
+    upstart_app_launch_app_observer_t focusCallback = nullptr;
+    upstart_app_launch_app_observer_t resumeCallback = nullptr;
+    upstart_app_launch_app_failed_observer_t failureCallback = nullptr;
+};
+
+upstart::ApplicationController::ApplicationController()
+    : ::ApplicationController(),
+      impl(new Private())
+{
+    impl->preStartCallback = [](const gchar * appId, gpointer userData) {
+        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        Q_EMIT(thiz->applicationAboutToBeStarted(appId));
+    };
+
+    impl->startedCallback = [](const gchar * appId, gpointer userData) {
+        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        Q_EMIT(thiz->applicationStarted(appId));
+    };
+
+    impl->stopCallback = [](const gchar * appId, gpointer userData) {
+        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        Q_EMIT(thiz->applicationStopped(appId));
+    };
+
+    impl->focusCallback = [](const gchar * appId, gpointer userData) {
+        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        Q_EMIT(thiz->applicationFocusRequest(appId));
+    };
+
+    impl->resumeCallback = [](const gchar * appId, gpointer userData) {
+        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        Q_EMIT(thiz->applicationResumeRequest(appId));
+    };
+
+    impl->failureCallback = [](const gchar * appId, upstart_app_launch_app_failed_t failureType, gpointer userData) {
+        ApplicationController::Error error;
+        switch(failureType)
+        {
+        case UPSTART_APP_LAUNCH_APP_FAILED_CRASH: error = ApplicationController::Error::APPLICATION_CRASHED;
+        case UPSTART_APP_LAUNCH_APP_FAILED_START_FAILURE: error = ApplicationController::Error::APPLICATION_FAILED_TO_START;
+        }
+
+        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        Q_EMIT(thiz->applicationError(appId, error));
+    };
+
+    upstart_app_launch_observer_add_app_starting(impl->preStartCallback, this);
+    upstart_app_launch_observer_add_app_started(impl->startedCallback, this);
+    upstart_app_launch_observer_add_app_stop(impl->stopCallback, this);
+    upstart_app_launch_observer_add_app_focus(impl->focusCallback, this);
+    upstart_app_launch_observer_add_app_resume(impl->resumeCallback, this);
+    upstart_app_launch_observer_add_app_failed(impl->failureCallback, this);
+}
+
+upstart::ApplicationController::~ApplicationController()
+{
+    upstart_app_launch_observer_delete_app_starting(impl->preStartCallback, this);
+    upstart_app_launch_observer_delete_app_started(impl->startedCallback, this);
+    upstart_app_launch_observer_delete_app_stop(impl->stopCallback, this);
+    upstart_app_launch_observer_delete_app_focus(impl->focusCallback, this);
+    upstart_app_launch_observer_delete_app_resume(impl->resumeCallback, this);
+    upstart_app_launch_observer_delete_app_failed(impl->failureCallback, this);
+}
+
+pid_t upstart::ApplicationController::primaryPidForAppId(const QString& appId)
+{
+    GPid pid = upstart_app_launch_get_primary_pid(appId.toLatin1().constData());
+    DLOG_IF(!pid, "ApplicationController::stopApplication appId='%s' FAILED", qPrintable(appId));
+
+    return pid;
+}
+
+bool upstart::ApplicationController::appIdHasProcessId(pid_t pid, const QString& appId)
+{
+    return upstart_app_launch_pid_in_app_id(pid, appId.toLatin1().constData());
+}
+
+bool upstart::ApplicationController::stopApplicationWithAppId(const QString& appId)
+{
+    auto result = upstart_app_launch_stop_application(appId.toLatin1().constData());
+    DLOG_IF(!result, "upstart::ApplicationController::stopApplicationWithAppId appId='%s' FAILED", qPrintable(appId));
+    return result;
+}
+
+bool upstart::ApplicationController::startApplicationWithAppIdAndArgs(const QString& appId, const QStringList& arguments)
+{
+    // Convert arguments QStringList into format suitable for upstart-app-launch
+    auto upstartArgs = g_new0(gchar *, arguments.length());
+
+    for (int i=0; i<arguments.length(); i++) {
+        upstartArgs[i] = arguments.at(i).toLatin1().data();
+    }
+
+    auto result = upstart_app_launch_start_application(
+                appId.toLatin1().constData(),
+                static_cast<const gchar * const *>(upstartArgs));
+
+    g_free(upstartArgs);
+
+    DLOG_IF(!result, "upstart::Application::Controller::startApplicationWithAppIdAndArgs appId='%s' FAILED", qPrintable(appId));
+    return result;
+}

=== added file 'src/modules/Unity/Application/upstart/applicationcontroller.h'
--- src/modules/Unity/Application/upstart/applicationcontroller.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/upstart/applicationcontroller.h	2014-02-11 09:48:32 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef UPSTART_APPLICATION_CONTROLLER_H
+#define UPSTART_APPLICATION_CONTROLLER_H
+
+#include "../applicationcontroller.h"
+
+namespace upstart
+{
+class ApplicationController : public ::ApplicationController
+{
+public:
+    ApplicationController();
+    ~ApplicationController();
+
+    pid_t primaryPidForAppId(const QString& appId);
+    bool appIdHasProcessId(pid_t pid, const QString& appId);
+
+    bool stopApplicationWithAppId(const QString& appId);
+    bool startApplicationWithAppIdAndArgs(const QString& appId, const QStringList& arguments);
+
+private:
+    struct Private;
+    QScopedPointer<Private> impl;
+};
+}
+
+#endif // UPSTART_APPLICATION_CONTROLLER_H

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-01-14 16:11:40 +0000
+++ tests/CMakeLists.txt	2014-02-11 09:48:32 +0000
@@ -1,1 +1,71 @@
+find_package(Qt5Core REQUIRED)
+find_package(Qt5Quick REQUIRED)
+find_package(Qt5DBus REQUIRED)
+
+# Build with system gmock and embedded gtest
+set (GMOCK_INCLUDE_DIR "/usr/include/gmock/include" CACHE PATH "gmock source include directory")
+set (GMOCK_SOURCE_DIR "/usr/src/gmock" CACHE PATH "gmock source directory")
+set (GTEST_INCLUDE_DIR "${GMOCK_SOURCE_DIR}/gtest/include" CACHE PATH "gtest source include directory")
+
+add_subdirectory(${GMOCK_SOURCE_DIR} "${CMAKE_CURRENT_BINARY_DIR}/gmock")
+
+#set (OLD_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+# Don't treat warnings as errors in 3rd_party/{gmock,cucumber-cpp}
+#string (REPLACE " -Werror " " " CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+#find_package(Gtest REQUIRED)
+#include_directories(${GMOCK_INCLUDE_DIR} ${GTEST_INCLUDE_DIR})
+#set (CMAKE_CXX_FLAGS ${OLD_CMAKE_CXX_FLAGS})
+
+include_directories(
+  ${CMAKE_SOURCE_DIR}/src/modules
+  ${GMOCK_INCLUDE_DIR}
+  ${GTEST_INCLUDE_DIR}
+)
+
+add_executable(
+  application_manager_test
+  application_manager_test.cpp
+)
+
+add_executable(
+  taskcontroller_test
+  taskcontroller_test.cpp
+)
+
+# We should not need this line according to the Qt5/CMake docs.
+# However, when removing it, include paths are not set and linking to Qt5 fails.
+qt5_use_modules(application_manager_test Core Quick DBus)
+qt5_use_modules(taskcontroller_test Core Quick DBus)
+
+target_link_libraries(
+  application_manager_test
+
+  unityapplicationplugin
+
+  Qt5::Core
+  Qt5::Quick
+  Qt5::DBus
+
+  gtest
+  gtest_main
+  gmock
+)
+
+target_link_libraries(
+  taskcontroller_test
+
+  unityapplicationplugin
+
+  Qt5::Core
+  Qt5::Quick
+  Qt5::DBus
+
+  gtest
+  gtest_main
+  gmock
+)
+
+add_test(taskcontroller_test ${CMAKE_CURRENT_BINARY_DIR}/taskcontroller_test)
+add_test(application_manager_test ${CMAKE_CURRENT_BINARY_DIR}/application_manager_test)
+
 add_subdirectory(auto)

=== added file 'tests/application_manager_test.cpp'
--- tests/application_manager_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/application_manager_test.cpp	2014-02-11 09:48:32 +0000
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <Unity/Application/application_manager.h>
+
+#include <Unity/Application/applicationcontroller.h>
+#include <Unity/Application/taskcontroller.h>
+
+#include <core/posix/linux/proc/process/oom_score_adj.h>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "mock_application_controller.h"
+#include "mock_desktop_file_reader.h"
+#include "mock_oom_controller.h"
+#include "mock_process_controller.h"
+
+TEST(ApplicationManager, SuspendingAndResumingARunningApplicationResultsInOomScoreAdjustment)
+{
+    using namespace ::testing;
+
+    const QString appId("com.canonical.does.not.exist");
+
+    NiceMock<testing::MockOomController> oomController;
+    QSharedPointer<ProcessController::OomController> oomControllerPtr(
+                &oomController,
+                [](ProcessController::OomController*){});
+
+    NiceMock<testing::MockProcessController> processController(oomControllerPtr);
+    QSharedPointer<ProcessController> processControllerPtr(
+                &processController,
+                [](ProcessController*){});
+
+    NiceMock<testing::MockApplicationController> appController;
+    QSharedPointer<ApplicationController> appControllerPtr(
+                &appController,
+                [](ApplicationController*){});
+
+    QSharedPointer<TaskController> taskController(
+                new TaskController(
+                    nullptr,
+                    appControllerPtr,
+                    processControllerPtr
+                    ));
+
+    NiceMock<MockDesktopFileReaderFactory> desktopFileReaderFactory;
+    QSharedPointer<DesktopFileReader::Factory> desktopFileReaderFactoryPtr(
+                &desktopFileReaderFactory,
+                [](DesktopFileReader::Factory*){});
+
+    ApplicationManager applicationManager(
+                taskController,
+                desktopFileReaderFactoryPtr);
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(_, _)).Times(1);
+
+    EXPECT_CALL(desktopFileReaderFactory, createInstanceForAppId(appId)).Times(1);
+
+    EXPECT_CALL(processController, sigStopProcessGroupForPid(_)).Times(1);
+    EXPECT_CALL(processController, sigContinueProcessGroupForPid(_)).Times(1);
+    EXPECT_CALL(oomController, ensureProcessUnlikelyToBeKilled(_)).Times(1);
+    EXPECT_CALL(oomController, ensureProcessLikelyToBeKilled(_)).Times(1);
+
+    auto application = applicationManager.startApplication(
+                appId,
+                ApplicationManager::NoFlag,
+                QStringList());
+
+    application->suspend();
+    application->resume();
+}
+
+// Currently disabled as we need to make sure that we have a corresponding mir session, too.
+TEST(ApplicationManager, DISABLED_FocusingRunningApplicationResultsInOomScoreAdjustment)
+{
+    using namespace ::testing;
+
+    const QString appId("com.canonical.does.not.exist");
+
+    NiceMock<testing::MockOomController> oomController;
+    QSharedPointer<ProcessController::OomController> oomControllerPtr(
+                &oomController,
+                [](ProcessController::OomController*){});
+
+    NiceMock<testing::MockProcessController> processController(oomControllerPtr);
+    QSharedPointer<ProcessController> processControllerPtr(
+                &processController,
+                [](ProcessController*){});
+
+    NiceMock<testing::MockApplicationController> appController;
+    QSharedPointer<ApplicationController> appControllerPtr(
+                &appController,
+                [](ApplicationController*){});
+
+    QSharedPointer<TaskController> taskController(
+                new TaskController(
+                    nullptr,
+                    appControllerPtr,
+                    processControllerPtr
+                    ));
+
+    NiceMock<MockDesktopFileReaderFactory> desktopFileReaderFactory;
+    QSharedPointer<DesktopFileReader::Factory> desktopFileReaderFactoryPtr(
+                &desktopFileReaderFactory,
+                [](DesktopFileReader::Factory*){});
+
+    ApplicationManager applicationManager(
+                taskController,
+                desktopFileReaderFactoryPtr);
+
+    QSet<QString> appIds;
+
+    for (unsigned int i = 0; i < 50; i++)
+    {
+        QString appIdFormat("%1.does.not.exist");
+        auto appId = appIdFormat.arg(i);
+
+        auto application = applicationManager.startApplication(
+                    appId,
+                    ApplicationManager::NoFlag,
+                    QStringList());
+
+        EXPECT_NE(nullptr, application);
+
+        appIds.insert(appId);
+        auto it = appController.children.find(appId);
+        if (it != appController.children.end())
+            EXPECT_CALL(oomController,
+                        ensureProcessUnlikelyToBeKilled(it->pid())).Times(1);
+    }
+
+    for (auto appId : appIds)
+    {
+        applicationManager.focusApplication(appId);
+    }
+}

=== modified file 'tests/auto/modules/Unity/Application/CMakeLists.txt'
--- tests/auto/modules/Unity/Application/CMakeLists.txt	2014-01-14 16:01:18 +0000
+++ tests/auto/modules/Unity/Application/CMakeLists.txt	2014-02-11 09:48:32 +0000
@@ -1,28 +1,27 @@
 add_subdirectory(fakeApp)
 
 include_directories(
-    ../../../../../src/modules/Unity/Application
-    ../../../../../src/unity-mir
+    ${CMAKE_SOURCE_DIR}/src/modules/Unity/Application
+    ${CMAKE_SOURCE_DIR}/src/unity-mir
+
     ${MIRSERVER_INCLUDE_DIRS}
-    ${UPSTART_APP_LAUNCH_INCLUDE_DIRS}
-    )
-
-add_executable(unity-mir-test-app
-    main.cpp
-    ../../../../../src/modules/Unity/Application/application_manager.cpp
-    ../../../../../src/modules/Unity/Application/application.cpp
-    ../../../../../src/modules/Unity/Application/desktopfilereader.cpp
-    ../../../../../src/modules/Unity/Application/dbuswindowstack.cpp
-    ../../../../../src/modules/Unity/Application/taskcontroller.cpp
-    # We need to pull in some external header files
-    /usr/include/unity/shell/application/ApplicationManagerInterface.h
-    /usr/include/unity/shell/application/ApplicationInfoInterface.h
-    )
+    ${UPSTART_APP_LAUNCH_INCLUDE_DIRS})
+
+add_executable(
+    unity-mir-test-app
+    main.cpp)
+
 qt5_use_modules(unity-mir-test-app Test DBus Gui)
-install(TARGETS unity-mir-test-app RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-target_link_libraries(unity-mir-test-app
+
+target_link_libraries(
+    unity-mir-test-app
+
     unity-mir
+    unityapplicationplugin
+
     ${MIRSERVER_LIBRARIES}
-    ${UPSTART_APP_LAUNCH_LIBRARIES}
-    )
-install(TARGETS unity-mir-test-app RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+    ${UPSTART_APP_LAUNCH_LIBRARIES})
+
+install(
+    TARGETS unity-mir-test-app
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

=== modified file 'tests/auto/modules/Unity/Application/main.cpp'
--- tests/auto/modules/Unity/Application/main.cpp	2014-01-08 12:23:11 +0000
+++ tests/auto/modules/Unity/Application/main.cpp	2014-02-11 09:48:32 +0000
@@ -17,6 +17,9 @@
 #include <QtTest/QtTest>
 
 #include "application_manager.h"
+#include "processcontroller.h"
+#include "taskcontroller.h"
+#include "upstart/applicationcontroller.h"
 
 #include "qmirserverapplication.h"
 #include "qmirserver.h"
@@ -41,7 +44,11 @@
 
 void ApplicationManagerTests::testStartStop()
 {
-    ApplicationManager manager;
+    QSharedPointer<upstart::ApplicationController> appController(new upstart::ApplicationController());
+    QSharedPointer<TaskController> taskController(new TaskController(nullptr, appController));
+    QSharedPointer<DesktopFileReader::Factory> fileReaderFactory(new DesktopFileReader::Factory());
+
+    ApplicationManager manager(taskController, fileReaderFactory);
     Application *app = manager.startApplication("unity-mir-test-helper-app", QStringList());
     QVERIFY(app);
     QCOMPARE(app->desktopFile(), QString("/usr/share/applications/unity-mir-test-helper-app.desktop"));

=== added file 'tests/mock_application_controller.h'
--- tests/mock_application_controller.h	1970-01-01 00:00:00 +0000
+++ tests/mock_application_controller.h	2014-02-11 09:48:32 +0000
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MOCK_APPLICATION_CONTROLLER_H
+#define MOCK_APPLICATION_CONTROLLER_H
+
+#include <Unity/Application/applicationcontroller.h>
+
+#include <core/posix/fork.h>
+
+#include <gmock/gmock.h>
+
+namespace testing
+{
+struct MockApplicationController : public ApplicationController
+{
+    MOCK_METHOD1(primaryPidForAppId, pid_t(const QString& appId));
+    MOCK_METHOD2(appIdHasProcessId, bool(pid_t, const QString&));
+
+    MOCK_METHOD1(stopApplicationWithAppId, bool(const QString&));
+    MOCK_METHOD2(startApplicationWithAppIdAndArgs, bool(const QString&, const QStringList&));
+
+    MockApplicationController()
+    {
+        using namespace ::testing;
+        ON_CALL(*this, primaryPidForAppId(_))
+                .WillByDefault(
+                    Invoke(this, &MockApplicationController::doPrimaryPidForAppId));
+
+        ON_CALL(*this, appIdHasProcessId(_, _))
+                .WillByDefault(
+                    Invoke(this, &MockApplicationController::doAppIdHasProcessId));
+
+        ON_CALL(*this, stopApplicationWithAppId(_))
+                .WillByDefault(
+                    Invoke(this, &MockApplicationController::doStopApplicationWithAppId));
+
+        ON_CALL(*this, startApplicationWithAppIdAndArgs(_, _))
+                .WillByDefault(
+                    Invoke(this, &MockApplicationController::doStartApplicationWithAppIdAndArgs));
+    }
+
+    pid_t doPrimaryPidForAppId(const QString& appId)
+    {
+        auto it = children.find(appId);
+        if (it == children.end())
+            return -1;
+
+        return it->pid();
+    }
+
+    bool doAppIdHasProcessId(pid_t pid, const QString& appId)
+    {
+        auto it = children.find(appId);
+        if (it == children.end())
+            return -1;
+
+        return it->pid() == pid;
+    }
+
+    bool doStopApplicationWithAppId(const QString& appId)
+    {
+        (void) appId;
+
+        return false;
+    }
+
+    bool doStartApplicationWithAppIdAndArgs(const QString& appId, const QStringList& args)
+    {
+        (void) args;
+
+        auto child = core::posix::fork([]()
+        {
+            while (true);
+
+            return core::posix::exit::Status::success;
+        }, core::posix::StandardStream::empty);
+
+        if (child.pid() > 0)
+        {
+            children.insert(appId, child);
+            return true;
+        }
+
+        return false;
+    }
+
+    QMap<QString, core::posix::ChildProcess> children;
+};
+}
+
+#endif // MOCK_APPLICATION_CONTROLLER_H

=== added file 'tests/mock_desktop_file_reader.h'
--- tests/mock_desktop_file_reader.h	1970-01-01 00:00:00 +0000
+++ tests/mock_desktop_file_reader.h	2014-02-11 09:48:32 +0000
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MOCK_DESKTOP_FILE_READER_H
+#define MOCK_DESKTOP_FILE_READER_H
+
+#include <Unity/Application/desktopfilereader.h>
+
+#include <gmock/gmock.h>
+
+namespace testing
+{
+struct MockDesktopFileReader : public DesktopFileReader
+{
+    MockDesktopFileReader(const QString& appId)
+        : DesktopFileReader(appId)
+    {
+        using namespace ::testing;
+
+        ON_CALL(*this, file()).WillByDefault(Invoke(this, &MockDesktopFileReader::doFile));
+        ON_CALL(*this, appId()).WillByDefault(Invoke(this, &MockDesktopFileReader::doAppId));
+        ON_CALL(*this, name()).WillByDefault(Invoke(this, &MockDesktopFileReader::doName));
+        ON_CALL(*this, comment()).WillByDefault(Invoke(this, &MockDesktopFileReader::doComment));
+        ON_CALL(*this, icon()).WillByDefault(Invoke(this, &MockDesktopFileReader::doIcon));
+        ON_CALL(*this, exec()).WillByDefault(Invoke(this, &MockDesktopFileReader::doExec));
+        ON_CALL(*this, path()).WillByDefault(Invoke(this, &MockDesktopFileReader::doPath));
+        ON_CALL(*this, stageHint()).WillByDefault(Invoke(this, &MockDesktopFileReader::doStageHint));
+        ON_CALL(*this, loaded()).WillByDefault(Invoke(this, &MockDesktopFileReader::doLoaded));
+        ON_CALL(*this, findDesktopFile(_)).WillByDefault(Invoke(this, &MockDesktopFileReader::doFindDesktopFile));
+    }
+
+    MockDesktopFileReader(const QFileInfo& fileInfo)
+        : DesktopFileReader(fileInfo)
+    {
+        using namespace ::testing;
+
+        ON_CALL(*this, file()).WillByDefault(Invoke(this, &MockDesktopFileReader::doFile));
+        ON_CALL(*this, appId()).WillByDefault(Invoke(this, &MockDesktopFileReader::doAppId));
+        ON_CALL(*this, name()).WillByDefault(Invoke(this, &MockDesktopFileReader::doName));
+        ON_CALL(*this, comment()).WillByDefault(Invoke(this, &MockDesktopFileReader::doComment));
+        ON_CALL(*this, icon()).WillByDefault(Invoke(this, &MockDesktopFileReader::doIcon));
+        ON_CALL(*this, exec()).WillByDefault(Invoke(this, &MockDesktopFileReader::doExec));
+        ON_CALL(*this, path()).WillByDefault(Invoke(this, &MockDesktopFileReader::doPath));
+        ON_CALL(*this, stageHint()).WillByDefault(Invoke(this, &MockDesktopFileReader::doStageHint));
+        ON_CALL(*this, loaded()).WillByDefault(Invoke(this, &MockDesktopFileReader::doLoaded));
+        ON_CALL(*this, findDesktopFile(_)).WillByDefault(Invoke(this, &MockDesktopFileReader::doFindDesktopFile));
+    }
+
+    MOCK_CONST_METHOD0(file, QString());
+    MOCK_CONST_METHOD0(appId, QString ());
+    MOCK_CONST_METHOD0(name, QString());
+    MOCK_CONST_METHOD0(comment, QString());
+    MOCK_CONST_METHOD0(icon, QString());
+    MOCK_CONST_METHOD0(exec, QString());
+    MOCK_CONST_METHOD0(path, QString());
+    MOCK_CONST_METHOD0(stageHint, QString());
+    MOCK_CONST_METHOD0(loaded, bool());
+    MOCK_CONST_METHOD1(findDesktopFile, QString(const QString&));
+
+    QString doFile() const
+    {
+        return DesktopFileReader::file();
+    }
+
+    QString doAppId() const
+    {
+        return DesktopFileReader::appId();
+    }
+
+    QString doName() const
+    {
+        return DesktopFileReader::name();
+    }
+
+    QString doComment() const
+    {
+        return DesktopFileReader::comment();
+    }
+
+    QString doIcon() const
+    {
+        return DesktopFileReader::icon();
+    }
+
+    QString doExec() const
+    {
+        return DesktopFileReader::exec();
+    }
+
+    QString doPath() const
+    {
+        return DesktopFileReader::path();
+    }
+
+    QString doStageHint() const
+    {
+        return DesktopFileReader::stageHint();
+    }
+
+    bool doLoaded() const
+    {
+        return DesktopFileReader::loaded();
+    }
+
+    QString doFindDesktopFile(const QString& appId) const
+    {
+        return DesktopFileReader::findDesktopFile(appId);
+    }
+};
+
+struct MockDesktopFileReaderFactory : public DesktopFileReader::Factory
+{
+    MockDesktopFileReaderFactory()
+    {
+        using namespace ::testing;
+        ON_CALL(*this, createInstanceForAppId(_))
+                .WillByDefault(
+                    Invoke(
+                        this,
+                        &MockDesktopFileReaderFactory::doCreateInstanceForAppId));
+        ON_CALL(*this, createInstanceForDesktopFile(_))
+                .WillByDefault(
+                    Invoke(
+                        this,
+                        &MockDesktopFileReaderFactory::doCreateInstanceForDesktopFile));
+    }
+
+    virtual DesktopFileReader* doCreateInstanceForAppId(const QString& appId)
+    {
+        using namespace ::testing;
+        auto instance = new NiceMock<MockDesktopFileReader>(appId);
+        ON_CALL(*instance, loaded()).WillByDefault(Return(true));
+
+        return instance;
+    }
+
+    virtual DesktopFileReader* doCreateInstanceForDesktopFile(const QFileInfo& fi)
+    {
+        using namespace ::testing;
+        auto instance = new NiceMock<MockDesktopFileReader>(fi);
+        ON_CALL(*instance, loaded()).WillByDefault(Return(true));
+
+        return instance;
+    }
+
+    MOCK_METHOD1(createInstanceForAppId, DesktopFileReader*(const QString&));
+    MOCK_METHOD1(createInstanceForDesktopFile, DesktopFileReader*(const QFileInfo&));
+};
+}
+
+#endif // MOCK_DESKTOP_FILE_READER_H

=== added file 'tests/mock_oom_controller.h'
--- tests/mock_oom_controller.h	1970-01-01 00:00:00 +0000
+++ tests/mock_oom_controller.h	2014-02-11 09:48:32 +0000
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef MOCK_OOM_CONTROLLER_H
+#define MOCK_OOM_CONTROLLER_H
+
+#include <Unity/Application/processcontroller.h>
+
+#include <gmock/gmock.h>
+
+namespace testing
+{
+struct MockOomController : public ProcessController::OomController
+{
+    MOCK_METHOD1(ensureProcessLikelyToBeKilled, void(pid_t));
+    MOCK_METHOD1(ensureProcessUnlikelyToBeKilled, void(pid_t));
+};
+}
+
+#endif // MOCK_OOM_CONTROLLER_H

=== added file 'tests/mock_process_controller.h'
--- tests/mock_process_controller.h	1970-01-01 00:00:00 +0000
+++ tests/mock_process_controller.h	2014-02-11 09:48:32 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef MOCK_PROCESS_CONTROLLER_H
+#define MOCK_PROCESS_CONTROLLER_H
+
+#include <Unity/Application/processcontroller.h>
+
+#include <gmock/gmock.h>
+
+namespace testing
+{
+struct MockProcessController : public ProcessController
+{
+    MockProcessController(const QSharedPointer<ProcessController::OomController>& oomController)
+        : m_oomController(oomController)
+    {
+    }
+
+    const QSharedPointer<OomController>& oomController() const
+    {
+        return m_oomController;
+    }
+
+    MOCK_CONST_METHOD1(sigStopProcessGroupForPid, bool(pid_t));
+    MOCK_CONST_METHOD1(sigContinueProcessGroupForPid, bool(pid_t));
+
+    QSharedPointer<ProcessController::OomController> m_oomController;
+};
+}
+
+#endif // MOCK_PROCESS_CONTROLLER_H

=== added file 'tests/taskcontroller_test.cpp'
--- tests/taskcontroller_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/taskcontroller_test.cpp	2014-02-11 09:48:32 +0000
@@ -0,0 +1,272 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <Unity/Application/taskcontroller.h>
+
+#include "mock_oom_controller.h"
+#include "mock_process_controller.h"
+
+#include <core/posix/fork.h>
+#include <core/posix/linux/proc/process/oom_score_adj.h>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+namespace
+{
+
+struct TriggerableApplicationController : public ApplicationController
+{
+    void triggerApplicationStarted(const QString& appId)
+    {
+        Q_EMIT applicationStarted(appId);
+    }
+
+    void triggerApplicationStopped(const QString& appId)
+    {
+        Q_EMIT applicationStopped(appId);
+    }
+
+    void triggerApplicationFocusRequest(const QString& appId)
+    {
+        Q_EMIT applicationFocusRequest(appId);
+    }
+
+    MOCK_METHOD1(primaryPidForAppId, pid_t (const QString&));
+    MOCK_METHOD2(appIdHasProcessId, bool(pid_t, const QString&));
+    MOCK_METHOD1(stopApplicationWithAppId, bool(const QString&));
+    MOCK_METHOD2(startApplicationWithAppIdAndArgs, bool(const QString&, const QStringList&));
+};
+}
+
+TEST(TaskController, startingAnApplicationCallsCorrectlyIntoApplicationController)
+{
+    using namespace ::testing;
+
+    const QString appId{"com.canonical.does.not.exist"};
+
+    testing::NiceMock<TriggerableApplicationController> appController;
+    QSharedPointer<TriggerableApplicationController> appControllerPtr(
+                &appController,
+                [](ApplicationController*){});
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(appId, QStringList())).Times(1).WillRepeatedly(Return(true));
+
+    testing::NiceMock<MockOomController> oomController;
+    QSharedPointer<ProcessController::OomController> oomControllerPtr(
+                &oomController,
+                [](ProcessController::OomController*){});
+
+    NiceMock<testing::MockProcessController> processController(oomControllerPtr);
+    QSharedPointer<ProcessController> processControllerPtr(
+                &processController,
+                [](ProcessController*){});
+
+    TaskController taskController(nullptr,
+                                  appControllerPtr,
+                                  processControllerPtr);
+
+    taskController.start(appId, QStringList());
+}
+
+TEST(TaskController, stoppingAnApplicationCallsCorrectlyIntoApplicationController)
+{
+    using namespace ::testing;
+
+    const QString appId{"com.canonical.does.not.exist"};
+
+    testing::NiceMock<TriggerableApplicationController> appController;
+    QSharedPointer<TriggerableApplicationController> appControllerPtr(
+                &appController,
+                [](ApplicationController*){});
+
+    EXPECT_CALL(appController, stopApplicationWithAppId(appId)).Times(1).WillRepeatedly(Return(true));
+
+    testing::NiceMock<MockOomController> oomController;
+    QSharedPointer<ProcessController::OomController> oomControllerPtr(
+                &oomController,
+                [](ProcessController::OomController*){});
+
+    NiceMock<testing::MockProcessController> processController(oomControllerPtr);
+    QSharedPointer<ProcessController> processControllerPtr(
+                &processController,
+                [](ProcessController*){});
+
+    TaskController taskController(nullptr,
+                                  appControllerPtr,
+                                  processControllerPtr);
+
+    taskController.stop(appId);
+}
+
+TEST(TaskController, suspendingAnApplicationAdjustsOomScoreForCorrectPid)
+{
+    using namespace ::testing;
+
+    const QString appId{"com.canonical.does.not.exist"};
+
+    testing::NiceMock<TriggerableApplicationController> appController;
+    QSharedPointer<TriggerableApplicationController> appControllerPtr(
+                &appController,
+                [](ApplicationController*){});
+
+    EXPECT_CALL(appController, primaryPidForAppId(appId)).Times(1).WillRepeatedly(Return(-1));
+
+    testing::NiceMock<MockOomController> oomController;
+    QSharedPointer<ProcessController::OomController> oomControllerPtr(
+                &oomController,
+                [](ProcessController::OomController*){});
+
+    NiceMock<testing::MockProcessController> processController(oomControllerPtr);
+    QSharedPointer<ProcessController> processControllerPtr(
+                &processController,
+                [](ProcessController*){});
+
+    EXPECT_CALL(oomController, ensureProcessLikelyToBeKilled(-1)).Times(1);
+
+    TaskController taskController(nullptr,
+                                  appControllerPtr,
+                                  processControllerPtr);
+
+    taskController.suspend(appId);
+}
+
+TEST(TaskController, resumingAnApplicationAdjustsOomScoreForCorrectPid)
+{
+    using namespace ::testing;
+
+    const QString appId{"com.canonical.does.not.exist"};
+
+    testing::NiceMock<TriggerableApplicationController> appController;
+    QSharedPointer<TriggerableApplicationController> appControllerPtr(
+                &appController,
+                [](ApplicationController*){});
+
+    EXPECT_CALL(appController, primaryPidForAppId(appId)).Times(1).WillRepeatedly(Return(-1));
+
+    testing::NiceMock<MockOomController> oomController;
+    QSharedPointer<ProcessController::OomController> oomControllerPtr(
+                &oomController,
+                [](ProcessController::OomController*){});
+
+    NiceMock<testing::MockProcessController> processController(oomControllerPtr);
+    QSharedPointer<ProcessController> processControllerPtr(
+                &processController,
+                [](ProcessController*){});
+
+    EXPECT_CALL(oomController, ensureProcessUnlikelyToBeKilled(-1)).Times(1);
+
+    TaskController taskController(nullptr,
+                                  appControllerPtr,
+                                  processControllerPtr);
+
+    taskController.resume(appId);
+}
+
+TEST(TaskController, aStartedApplicationIsOomScoreAdjusted)
+{
+    using namespace ::testing;
+
+    const QString appId{"com.canonical.does.not.exist"};
+
+    testing::NiceMock<TriggerableApplicationController> appController;
+    QSharedPointer<TriggerableApplicationController> appControllerPtr(
+                &appController,
+                [](ApplicationController*){});
+    EXPECT_CALL(appController, primaryPidForAppId(appId)).Times(1).WillRepeatedly(Return(42));
+
+    testing::NiceMock<MockOomController> oomController;
+    QSharedPointer<ProcessController::OomController> oomControllerPtr(
+                &oomController,
+                [](ProcessController::OomController*){});
+
+    NiceMock<testing::MockProcessController> processController(oomControllerPtr);
+    QSharedPointer<ProcessController> processControllerPtr(
+                &processController,
+                [](ProcessController*){});
+
+    EXPECT_CALL(oomController, ensureProcessUnlikelyToBeKilled(42)).Times(1);
+
+    TaskController taskController(nullptr,
+                                  appControllerPtr,
+                                  processControllerPtr);
+
+    appControllerPtr->triggerApplicationStarted(appId);
+}
+
+TEST(TaskController, aFocusedApplicationIsOomScoreAdjusted)
+{
+    using namespace ::testing;
+
+    const QString appId{"com.canonical.does.not.exist"};
+
+    testing::NiceMock<TriggerableApplicationController> appController;
+    QSharedPointer<TriggerableApplicationController> appControllerPtr(
+                &appController,
+                [](ApplicationController*){});
+    EXPECT_CALL(appController, primaryPidForAppId(appId)).Times(1).WillRepeatedly(Return(42));
+
+    testing::NiceMock<MockOomController> oomController;
+    QSharedPointer<ProcessController::OomController> oomControllerPtr(
+                &oomController,
+                [](ProcessController::OomController*){});
+
+    NiceMock<testing::MockProcessController> processController(oomControllerPtr);
+    QSharedPointer<ProcessController> processControllerPtr(
+                &processController,
+                [](ProcessController*){});
+
+    EXPECT_CALL(oomController, ensureProcessUnlikelyToBeKilled(42)).Times(1);
+
+    TaskController taskController(nullptr,
+                                  appControllerPtr,
+                                  processControllerPtr);
+
+    appControllerPtr->triggerApplicationFocusRequest(appId);
+}
+
+TEST(TaskController, oomControllerUpdatesOomScoreAdjCorrectly)
+{
+    ProcessController::OomController oomController;
+
+    auto child = core::posix::fork([]()
+    {
+        while (true);
+
+        return core::posix::exit::Status::success;
+    }, core::posix::StandardStream::empty);
+
+    EXPECT_GT(child.pid(), 0);
+
+    core::posix::linux::proc::process::OomScoreAdj oomScoreAdj;
+    child >> oomScoreAdj;
+
+    core::posix::linux::proc::process::OomScoreAdj likelyOomScoreAdj, unlikelyOomScoreAdj;
+    {
+        oomController.ensureProcessLikelyToBeKilled(child.pid());
+        child >> likelyOomScoreAdj;
+
+        EXPECT_GE(likelyOomScoreAdj.value, oomScoreAdj.value);
+    }
+
+    {
+        oomController.ensureProcessUnlikelyToBeKilled(child.pid());
+        child >> unlikelyOomScoreAdj;
+
+        EXPECT_LE(unlikelyOomScoreAdj.value, likelyOomScoreAdj.value);
+    }
+}