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.

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

[Michał Sawicz (saviq)]

Missing debian/control entry.

review: Needs Fixing

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

144. By Thomas Voß on 2013-11-12

Add build-dependency on libprocess-cpp.

[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)

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

145. By Thomas Voß on 2013-12-05

Refactor to core namespace.

[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)

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

146. By Thomas Voß on 2013-12-09

[ Gerry Boland ]
* Unity.Application is not a shared library, but a plugin. (LP:
  #1256014)
* Implement preStart callback added to upstart-app-launch-2. (LP:
  #1243665)
[ Ubuntu daily release ]
* Automatic snapshot from revision 157
[ Gerry Boland ]
* Install ServerStatusListener to be notified of mir server start, pause
  and resume. Use start notification to send SIGSTOP signal to upstart,
  so it knows mir is ready for other clients.
* Bump version number
* InputArea: don't use lambda function as slot, can cause crash on
  shutdown Using lambda function as slot can introduce crash as the
  slot's object deletion is not registered unlike with traditional
  signal/slot connections. As a result, on signal emission, the lambda
  can be called on a deleted object. (LP: #1253685)
* Misc fixes for Mir 0.1.2 support. (LP: #1254986)
[ Alan Griffiths ]
* ApplicationSession is a Mir implementation class that shouldn't be
  used by unity-mir, use shell::session instead.
[ Kevin Gunn ]
* mir server abi and api broke, updating dependency to deb 0.1.1.
* update mir deb build dep to 0.1.2
[ Victor Thompson ]
* Fix mir to not suspend the music-app, or any other app granted a
  lifecycle exception, when switching between apps. (LP: #1241185,
  #1241045)
[ Daniel van Vugt ]
* Force the screen to redraw after turning the display back on (LP:
  #1255045). Also stop the compositor when the screen is off.
  Otherwise it will spin in the background, eating battery. (LP:
  #1255045)
[ Ubuntu daily release ]
* Automatic snapshot from revision 154
* Cherry-pick upstream patch to avoid Unity8 crashing on stop
  (LP: #1253685)
[ Gerry Boland ]
* On MirSurface destruction, any InputAreas on that surface will be
  notified and remove their links to that surface. Fixes crash
  bug:1243444. (LP: #1243444)
[ Alan Griffiths ]
* Remove dependency on mir::shell::SessionManager.
* Remove dependency on mir::surfaces::SurfaceController.
* Remove dependency on msh::OrganisingSurfaceFactory.
* Avoid relying on an explicit Mir typename that changes in a
  refactoring coming soon.
* Do all the hacky surface creation customization in
  SurfaceFactory::create_surface() - and don't mention SurfaceBuilder
  at all. (That will allow Mir to get rid of that interface.).
[ Albert Astals ]
* Don't include the QtQml megaheader Include the one we really need.
[ Ubuntu daily release ]
* Automatic snapshot from revision 144

[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

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

147. By Thomas Voß on 2014-01-02

Fix whitespace.

148. By Thomas Voß on 2014-01-02

Replace extremal with boundary.

[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)

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

149. By Thomas Voß on 2014-01-09

Merge cmake setup.
Add testing setup.

[ Daniel d'Andrada ]
* Fix OSKController.enabled property OSKController.enabled was always
  True as we were missing the check for undefined. Also s/variant/var
  as the "variant" QML type is deprecated. (LP: #1248795)
[ kevin gunn ]
* bump debian version dependency for mir to 0.1.3 to force rebuild
[ Ubuntu daily release ]
* Automatic snapshot from revision 160

150. By Thomas Voß on 2014-01-09

Add build-dependency on Google Mock.

[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

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

151. By Thomas Voß on 2014-01-09

Remove leftover pro file.

152. By Thomas Voß on 2014-01-09

Merge pre-requisite branch again.
Remove stale .pro.THIS file.

[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)

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

153. By Thomas Voß on 2014-01-09

Remove obsolete copyright notice in build system file.

[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)

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

154. By Thomas Voß on 2014-01-09

Add missing call for finding process-cpp.

[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

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

155. By Thomas Voß on 2014-01-10

Merge prerequisite branch.

[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.

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

156. By Thomas Voß on 2014-01-13

Add a first test case for application manager.
Split up mocks into their own header file.

157. By Thomas Voß on 2014-01-13

Add test for focus setting behavior (disabled right now).

158. By Thomas Voß on 2014-01-13

Remove dead code.

159. By Thomas Voß on 2014-01-23

First wave of changes accounting for review.

160. By Thomas Voß on 2014-01-27

Refactor signal-slot connections in TaskController to type-safe variant.

161. By Thomas Voß on 2014-01-27

Refactor process operations into class ProcessController and an inner class ProcessController::OomController.

162. By Thomas Voß on 2014-01-27

[ Gerry Boland ]
* [cmake] set default build type to RelWithDebInfo, add workaround to
  set QT_NO_DEBUG with that option.
[ Albert Astals ]
* Tests for ApplicationManager start/stopApplication At the moment
  they just work on the device (well they may as well work on Mir on
  the desktop but have not tried). You need to install the libunity-
  mir-tests package and then run unity-mir-test-app.
[ Ricardo Mendoza ]
* Correctly respect lifecycle exceptions in the new sidestage model.
  (LP: #1269414)
[ Ubuntu daily release ]
* Automatic snapshot from revision 168
[ thomas-voss ]
* Switch to cmake.
[ Albert Astals ]
* Recover the Requires line in the .pc file.
[ Ricardo Mendoza ]
* Re-enable Sidestage as it was under SF.
[ Ubuntu daily release ]
* Automatic snapshot from revision 164

163. By Thomas Voß on 2014-01-27

Adjust slot signatures.

164. By Thomas Voß on 2014-01-29

Adjust copyright year.

165. By Thomas Voß on 2014-01-29

Replace auto variables with pid_t where appropriate.

166. By Thomas Voß on 2014-01-30

Switch to Q_EMIT for passing on signals originating from upstart app launch.

167. By Thomas Voß on 2014-02-06

Merged lp:~ricmm/unity-mir/catch-starting-failure.

168. By Thomas Voß on 2014-02-06

[ Kevin Gunn ]
* bump debian version for mir to 0.1.4
[ Łukasz 'sil2100' Zemczak ]
* Fix the multi-arch stanza in the new -tests package.

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

Initialize ApplicationManager::m_focusedApplication to nullptr in ctor.

Unmerged revisions

=== added file 'CMakeLists.txt'
--- CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ CMakeLists.txt	2014-01-10 09:14:26 +0000
@@ -0,0 +1,64 @@
+cmake_minimum_required(VERSION 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.
+set(CMAKE_AUTOMOC ON)
+
+include(GNUInstallDirs)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -Wall -pedantic -Wextra")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -fno-strict-aliasing -pedantic -Wextra")
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
+
+option(Werror "Treat warnings as errors" ON)
+if (Werror)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Wno-error=format")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-error=format")
+endif()
+
+string(TOLOWER "${CMAKE_BUILD_TYPE}" cmake_build_type_lower)
+
+#####################################################################
+# Enable code coverage calculation with gcov/gcovr/lcov
+# Usage:
+#  * Switch build type to coverage (use ccmake or cmake-gui)
+#  * Invoke make, make test, make coverage
+#  * Find html report in subdir coveragereport
+#  * Find xml report feasible for jenkins in coverage.xml
+#####################################################################
+IF(cmake_build_type_lower MATCHES coverage)
+  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftest-coverage -fprofile-arcs" )
+  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage -fprofile-arcs" )
+  SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -ftest-coverage -fprofile-arcs" )
+  SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -ftest-coverage -fprofile-arcs" )
+ENDIF(cmake_build_type_lower MATCHES coverage)
+
+include(CTest)
+
+set(UNITY_MIR_VERSION_MAJOR 1)
+set(UNITY_MIR_VERSION_MINOR 0)
+set(UNITY_MIR_VERSION_PATCH 0)
+
+find_package(PkgConfig REQUIRED)
+find_package(Threads REQUIRED)
+
+find_package(Qt5Core REQUIRED)
+find_package(Qt5Quick REQUIRED)
+find_package(Qt5DBus REQUIRED)
+
+pkg_check_modules(MIRSERVER mirserver REQUIRED)
+pkg_check_modules(MIRCOMMON mircommon REQUIRED)
+pkg_check_modules(UBUNTU_PLATFORM_API ubuntu-platform-api REQUIRED)
+
+add_subdirectory(src)
+add_subdirectory(data)
+
+add_subdirectory(tests)
+
+# TODO(tvoss): Enable coverage reporting once we have tests in place.
+#enable_coverage_report(posix_process_test linux_process_test)

=== added directory 'data'
=== added file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ data/CMakeLists.txt	2014-01-10 09:14:26 +0000
@@ -0,0 +1,7 @@
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/unity-mir.pc.in 
+  ${CMAKE_CURRENT_BINARY_DIR}/unity-mir.pc @ONLY)
+
+install(
+  FILES ${CMAKE_CURRENT_BINARY_DIR}/unity-mir.pc
+  DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)

=== added file 'data/unity-mir.pc.in'
--- data/unity-mir.pc.in	1970-01-01 00:00:00 +0000
+++ data/unity-mir.pc.in	2014-01-10 09:14:26 +0000
@@ -0,0 +1,10 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}
+libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@
+includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
+ 
+Name: @CMAKE_PROJECT_NAME@
+Description: Qt wrapper for Mir functionality required by Unity
+Version: @UNITY_MIR_VERSION_MAJOR@.@UNITY_MIR_VERSION_MINOR@.@UNITY_MIR_VERSION_PATCH@
+Libs: -L${libdir} -lunity-mir
+Cflags: -I${includedir}/unity-mir

=== modified file 'debian/control'
--- debian/control	2014-01-02 21:27:18 +0000
+++ debian/control	2014-01-10 09:14:26 +0000
@@ -3,10 +3,13 @@
 Priority: optional
 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.3),
                libmirclient-dev (>= 0.1.3),
+               libprocess-cpp-dev,
                libunity-api-dev,
                libupstart-app-launch2-dev,
                qt5-default,

=== modified file 'debian/rules'
--- debian/rules	2013-08-19 07:40:07 +0000
+++ debian/rules	2014-01-10 09:14:26 +0000
@@ -6,6 +6,3 @@
 %:
 	dh $@ --parallel --fail-missing
 
-# Force the build to generate debug symbols, so we can have -dbgsym packages
-override_dh_auto_configure:
-	dh_auto_configure -- QMAKE_CXXFLAGS=-g

=== added file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/CMakeLists.txt	2014-01-10 09:14:26 +0000
@@ -0,0 +1,2 @@
+add_subdirectory(unity-mir)
+add_subdirectory(modules)

=== added file 'src/modules/CMakeLists.txt'
--- src/modules/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/modules/CMakeLists.txt	2014-01-10 09:14:26 +0000
@@ -0,0 +1,1 @@
+add_subdirectory(Unity)

=== removed file 'src/modules/Unity/Application/Application.pro'
--- src/modules/Unity/Application/Application.pro	2013-12-06 12:30:14 +0000
+++ src/modules/Unity/Application/Application.pro	1970-01-01 00:00:00 +0000
@@ -1,58 +0,0 @@
-TARGET = unityapplicationplugin
-TEMPLATE = lib
-
-QT       += core quick dbus
-CONFIG   += link_pkgconfig plugin
-
-# CONFIG += c++11 # only enables C++0x
-QMAKE_CXXFLAGS = -std=c++11 -fvisibility=hidden -fvisibility-inlines-hidden
-QMAKE_CXXFLAGS_RELEASE += -Werror     # so no stop on warning in debug builds
-QMAKE_LFLAGS = -std=c++11 -Wl,-no-undefined
-
-PKGCONFIG += mircommon mirserver ubuntu-platform-api glib-2.0 upstart-app-launch-2
-
-INCLUDEPATH += ../../../unity-mir
-LIBS += -L../../../unity-mir -lunity-mir \
-    -lubuntu_application_api_mirserver #FIXME platform-api pkgconfig should set this
-
-TARGET = $$qtLibraryTarget($$TARGET)
-uri = Unity.Application
-
-SOURCES += application_manager.cpp \
-    application.cpp \
-    desktopfilereader.cpp \
-    plugin.cpp \
-    applicationscreenshotprovider.cpp \
-    dbuswindowstack.cpp \
-    taskcontroller.cpp \
-    mirsurface.cpp \
-    mirsurfacemanager.cpp \
-    inputarea.cpp \
-    inputfilterarea.cpp \
-    shellinputarea.cpp \
-    ubuntukeyboardinfo.cpp
-
-HEADERS += application_manager.h \
-    application.h \
-    desktopfilereader.h \
-    applicationscreenshotprovider.h \
-    dbuswindowstack.h \
-    taskcontroller.h \
-    mirsurface.h \
-    mirsurfacemanager.h \
-    shellinputarea.h \
-    inputarea.h \
-    inputfilterarea.h \
-    ubuntukeyboardinfo.h \
-    /usr/include/unity/shell/application/ApplicationManagerInterface.h \
-    /usr/include/unity/shell/application/ApplicationInfoInterface.h
-
-installPath = $$[QT_INSTALL_IMPORTS]/Unity-Mir/$$replace(uri, \\., /)
-
-QML_FILES = qmldir ApplicationImage.qml OSKController.qml
-qml_files.path = $$installPath
-qml_files.files = $$QML_FILES
-
-target.path = $$installPath
-
-INSTALLS += target qml_files

=== added file 'src/modules/Unity/Application/CMakeLists.txt'
--- src/modules/Unity/Application/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/CMakeLists.txt	2014-01-10 09:14:26 +0000
@@ -0,0 +1,97 @@
+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)
+
+include_directories(
+  ${GLIB_INCLUDE_DIRS}
+  ${MIRCOMMON_INCLUDE_DIRS}
+  ${MIRSERVER_INCLUDE_DIRS}
+  ${PROCESS_CPP_INCLUDE_DIRS}
+  ${UBUNTU_PLATFORM_API_INCLUDE_DIRS}
+  ${UPSTART_APP_LAUNCH_INCLUDE_DIRS}
+
+  ${CMAKE_SOURCE_DIR}/src/unity-mir
+)
+
+add_library(
+  unityapplicationplugin SHARED
+
+  application_manager.cpp
+  application.cpp
+  desktopfilereader.cpp
+  plugin.cpp
+  applicationscreenshotprovider.cpp
+  dbuswindowstack.cpp
+  taskcontroller.cpp
+  mirsurface.cpp
+  mirsurfacemanager.cpp
+  inputarea.cpp
+  inputfilterarea.cpp
+  shellinputarea.cpp
+  ubuntukeyboardinfo.cpp
+
+  upstart/application_controller.h
+  upstart/application_controller.cpp
+
+  application_controller.h
+  application_manager.h
+  application.h
+  desktopfilereader.h
+  applicationscreenshotprovider.h
+  dbuswindowstack.h
+  taskcontroller.h
+  mirsurface.h
+  mirsurfacemanager.h
+  shellinputarea.h
+  inputarea.h
+  inputfilterarea.h
+  ubuntukeyboardinfo.h
+  
+  # We need to pull in some external header files
+  /usr/include/unity/shell/application/ApplicationManagerInterface.h
+  /usr/include/unity/shell/application/ApplicationInfoInterface.h
+)
+
+# 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(unityapplicationplugin Core Quick DBus)
+
+target_link_libraries(
+  unityapplicationplugin
+  
+  unity-mir
+
+  ubuntu_application_api_mirserver
+
+  Qt5::Core
+  Qt5::Quick
+  Qt5::DBus
+
+  ${CMAKE_THREAD_LIBS_INIT}
+
+  ${GLIB_LDFLAGS}
+  ${UBUNTU_PLATFORM_API_LIBRARIES}
+  ${MIRCOMMON_LIBRARIES}
+  ${MIRSERVER_LIBRARIES}
+  ${PROCESS_CPP_LIBRARIES}
+  ${UBUNTU_PLATFORM_API_LIBRARIES}
+  ${UPSTART_APP_LAUNCH_LIBRARIES}
+
+  ubuntu_application_api_mirserver
+)
+
+# Ideally, we would read the plugin installation location from cmake
+# but this does not work currently.
+set(PLUGIN_INSTALL_LOCATION "${CMAKE_INSTALL_LIBDIR}/qt5/imports/Unity-Mir/Unity/Application")
+
+message(STATUS "Installing Qt5 Unity-Application plugin to: ${PLUGIN_INSTALL_LOCATION}")
+
+install(
+  TARGETS unityapplicationplugin
+  LIBRARY DESTINATION ${PLUGIN_INSTALL_LOCATION})
+
+install(
+  FILES qmldir ApplicationImage.qml OSKController.qml
+  DESTINATION ${PLUGIN_INSTALL_LOCATION})

=== modified file 'src/modules/Unity/Application/application.cpp'
--- src/modules/Unity/Application/application.cpp	2013-11-15 17:53:17 +0000
+++ src/modules/Unity/Application/application.cpp	2014-01-10 09:14:26 +0000
@@ -25,6 +25,7 @@
 
 // mir
 #include <mir/shell/session.h>
+#include <mir/shell/snapshot.h>
 
 Application::Application(const QString &appId, Application::State state,
                          const QStringList &arguments, QObject *parent)

=== modified file 'src/modules/Unity/Application/application.h'
--- src/modules/Unity/Application/application.h	2013-10-28 15:39:00 +0000
+++ src/modules/Unity/Application/application.h	2014-01-10 09:14:26 +0000
@@ -20,9 +20,6 @@
 // std
 #include <memory>
 
-// Mir
-#include <mir/shell/snapshot.h>
-
 //Qt
 #include <QtCore/QtCore>
 #include <QImage>

=== added file 'src/modules/Unity/Application/application_controller.h'
--- src/modules/Unity/Application/application_controller.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/application_controller.h	2014-01-10 09:14:26 +0000
@@ -0,0 +1,61 @@
+/*
+ * 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#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/dbuswindowstack.h'
--- src/modules/Unity/Application/dbuswindowstack.h	2013-10-09 09:02:23 +0000
+++ src/modules/Unity/Application/dbuswindowstack.h	2014-01-10 09:14:26 +0000
@@ -62,7 +62,7 @@
     void WindowDestroyed(unsigned int window_id, const QString &app_id);
 };
 
-Q_DECLARE_METATYPE(AppIdDesktopFile);
-Q_DECLARE_METATYPE(WindowInfo);
+Q_DECLARE_METATYPE(AppIdDesktopFile)
+Q_DECLARE_METATYPE(WindowInfo)
 
 #endif // DBUSWINDOWSTACK_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-01-10 09:14:26 +0000
@@ -18,6 +18,7 @@
 
 // local
 #include "taskcontroller.h"
+#include "upstart/application_controller.h"
 
 // unity-mir
 #include <logging.h>
@@ -25,6 +26,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 +42,156 @@
 #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()
-    {
+namespace plpp = core::posix::linux::proc::process;
+
+TaskController::OomController::OomController()
+{
+}
+
+void TaskController::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 TaskController::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 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))
+        static const int defaultValue = 0;
+
+        try
+        {
+            process << plpp::OomAdj{defaultValue};
+        } catch(...)
+        {
             LOG("ensureProcessIsUnlikelyToBeKilled failed");
+        }
+    }
 }
 
-void ensureProcessIsLikelyToBeKilled(pid_t pid)
+TaskController* theTaskController = nullptr;
+
+void cleanup_task_controller_singleton_instance()
 {
-    if (!OomScoreAdjuster::mostLikelyToBeKilled().applyForPid(pid))
-        if (!OomAdjuster::mostLikelyToBeKilled().applyForPid(pid))
-            LOG("ensureProcessIsLikelyToBeKilled failed");
-}
-}
-
-TaskController* TaskController::m_theTaskController = nullptr;
+    delete theTaskController;
+}
 
 TaskController* TaskController::singleton()
 {
-    if (!m_theTaskController) {
-        m_theTaskController = new TaskController();
+    if (!theTaskController) {
+        theTaskController = new TaskController(
+                    nullptr,
+                    QSharedPointer<ApplicationController>(new upstart::ApplicationController()));
+
+        atexit(cleanup_task_controller_singleton_instance);
     }
-    return m_theTaskController;
+    return theTaskController;
 }
 
-TaskController::TaskController(QObject *parent) :
-    QObject(parent)
+TaskController::TaskController(
+        QObject* parent,
+        const QSharedPointer<ApplicationController>& app_controller,
+        const QSharedPointer<TaskController::OomController>& oom_controller) :
+    QObject(parent),
+    app_controller(app_controller),
+    oom_controller(oom_controller)
 {
-    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);
+    connect(app_controller.data(),
+            SIGNAL(applicationAboutToBeStarted(QString)),
+            this,
+            SLOT(onApplicationAboutToBeStarted(QString)));
+
+    connect(app_controller.data(),
+            SIGNAL(applicationStarted(QString)),
+            this,
+            SLOT(onApplicationStarted(QString)));
+
+    connect(app_controller.data(),
+            SIGNAL(applicationStopped(QString)),
+            this,
+            SLOT(onApplicationStopped(QString)));
+
+    connect(app_controller.data(),
+            SIGNAL(applicationFocusRequest(QString)),
+            this,
+            SLOT(onApplicationFocusRequest(QString)));
+
+    connect(app_controller.data(),
+            SIGNAL(applicationResumeRequest(QString)),
+            this,
+            SLOT(onApplicationResumeRequest(QString)));
+
+    connect(app_controller.data(),
+            SIGNAL(applicationError(QString, ApplicationController::Error)),
+            this,
+            SLOT(onApplicationError(QString, ApplicationController::Error)));
 }
 
 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 app_controller->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 = app_controller->stopApplicationWithAppId(appId);
     DLOG_IF(!result, "TaskController::stopApplication appId='%s' FAILED", qPrintable(appId));
     return result;
 }
@@ -398,15 +199,14 @@
 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 app_controller->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);
+    auto pid = app_controller->primaryPidForAppId(appId);
+    oom_controller->ensureProcessLikelyToBeKilled(pid);
 
     if (pid) {
         // We do assume that the app was launched by upstart and with that,
@@ -422,9 +222,9 @@
 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());
+    auto pid = app_controller->primaryPidForAppId(appId);
 
-    ensureProcessIsUnlikelyToBeKilled(pid);
+    oom_controller->ensureProcessUnlikelyToBeKilled(pid);
 
     if (pid) {
         // We do assume that the app was launched by upstart and with that,
@@ -436,3 +236,47 @@
         return false;
     }
 }
+
+void TaskController::onApplicationAboutToBeStarted(QString id)
+{
+    Q_EMIT processStartReport(id, false);
+}
+
+void TaskController::onApplicationStarted(QString id)
+{
+    auto pid = app_controller->primaryPidForAppId(id);
+    oom_controller->ensureProcessUnlikelyToBeKilled(pid);
+}
+
+void TaskController::onApplicationStopped(QString id)
+{
+    Q_EMIT processStopped(id, false);
+}
+
+void TaskController::onApplicationFocusRequest(QString id)
+{
+    auto pid = app_controller->primaryPidForAppId(id);
+    oom_controller->ensureProcessUnlikelyToBeKilled(pid);
+    Q_EMIT requestFocus(id);
+}
+
+void TaskController::onApplicationResumeRequest(QString id)
+{
+    Q_EMIT requestResume(id);
+}
+
+void TaskController::onApplicationError(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-01-10 09:14:26 +0000
@@ -22,17 +22,32 @@
 #include <QObject>
 
 #include "application.h"
-
-// upstart
-extern "C" {
-    #include "upstart-app-launch.h"
-}
+#include "application_controller.h"
 
 class TaskController : public QObject
 {
     Q_OBJECT
 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);
+    };
+
     static TaskController* singleton();
+
+    TaskController(
+            QObject* parent,
+            const QSharedPointer<ApplicationController>& app_controller,
+            const QSharedPointer<OomController>& oom_controller = QSharedPointer<OomController>(new OomController()));
     ~TaskController();
 
     bool start(const QString& appId, const QStringList& args);
@@ -49,12 +64,18 @@
     void requestFocus(const QString& appId);
     void requestResume(const QString& appId);
 
+private Q_SLOTS:
+    void onApplicationAboutToBeStarted(QString id);
+    void onApplicationStarted(QString id);
+    void onApplicationStopped(QString id);
+    void onApplicationFocusRequest(QString id);
+    void onApplicationResumeRequest(QString id);
+
+    void onApplicationError(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> app_controller;
+    QSharedPointer<OomController> oom_controller;
 };
 
 #endif // TASKCONTROLLER_H

=== added directory 'src/modules/Unity/Application/upstart'
=== added file 'src/modules/Unity/Application/upstart/application_controller.cpp'
--- src/modules/Unity/Application/upstart/application_controller.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/upstart/application_controller.cpp	2014-01-10 09:14:26 +0000
@@ -0,0 +1,154 @@
+/*
+ * 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#include "application_controller.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);
+        QMetaObject::invokeMethod(thiz,
+                                  "applicationAboutToBeStarted",
+                                  Qt::QueuedConnection, // This might happen on a different thread.
+                                  Q_ARG(QString, QString(appId)));
+    };
+
+    impl->startedCallback = [](const gchar * appId, gpointer userData) {
+        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        QMetaObject::invokeMethod(thiz,
+                                  "applicationStarted",
+                                  Qt::QueuedConnection, // This might happen on a different thread.
+                                  Q_ARG(QString, QString(appId)));
+    };
+
+    impl->stopCallback = [](const gchar * appId, gpointer userData) {
+        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        QMetaObject::invokeMethod(thiz,
+                                  "applicationStopped",
+                                  Qt::QueuedConnection, // This might happen on a different thread.
+                                  Q_ARG(QString, QString(appId)));
+    };
+
+    impl->focusCallback = [](const gchar * appId, gpointer userData) {
+        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        QMetaObject::invokeMethod(thiz,
+                                  "applicationFocusRequest",
+                                  Qt::QueuedConnection, // This might happen on a different thread.
+                                  Q_ARG(QString, QString(appId)));
+    };
+
+    impl->resumeCallback = [](const gchar * appId, gpointer userData) {
+        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        QMetaObject::invokeMethod(thiz,
+                                  "applicationResumeRequest",
+                                  Qt::QueuedConnection, // This might happen on a different thread.
+                                  Q_ARG(QString, QString(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);
+        QMetaObject::invokeMethod(thiz,
+                                  "applicationError",
+                                  Qt::QueuedConnection, // This might happen on a different thread.
+                                  Q_ARG(QString, QString(appId)),
+                                  Q_ARG(::ApplicationController::Error, 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)
+{
+    auto 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/application_controller.h'
--- src/modules/Unity/Application/upstart/application_controller.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/upstart/application_controller.h	2014-01-10 09:14:26 +0000
@@ -0,0 +1,44 @@
+/*
+ * 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#ifndef UPSTART_APPLICATION_CONTROLLER_H
+#define UPSTART_APPLICATION_CONTROLLER_H
+
+#include "../application_controller.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

=== added file 'src/modules/Unity/CMakeLists.txt'
--- src/modules/Unity/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/CMakeLists.txt	2014-01-10 09:14:26 +0000
@@ -0,0 +1,1 @@
+add_subdirectory(Application)

=== removed file 'src/modules/modules.pro'
--- src/modules/modules.pro	2013-08-29 14:46:43 +0000
+++ src/modules/modules.pro	1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-TEMPLATE = subdirs
-
-SUBDIRS += Unity/Application

=== removed file 'src/src.pro'
--- src/src.pro	2013-07-19 17:29:44 +0000
+++ src/src.pro	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-TEMPLATE = subdirs
-
-SUBDIRS += unity-mir \
-           modules \
-
-modules.depends = unity-mir

=== added file 'src/unity-mir/CMakeLists.txt'
--- src/unity-mir/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/unity-mir/CMakeLists.txt	2014-01-10 09:14:26 +0000
@@ -0,0 +1,72 @@
+include_directories(
+  ${MIRCOMMON_INCLUDE_DIRS}
+  ${MIRSERVER_INCLUDE_DIRS}
+  ${UBUNTU_PLATFORM_API_INCLUDE_DIRS}
+)
+
+set(
+  UNITY_MIR_HEADERS
+
+  dbusscreen.h
+  initialsurfaceplacementstrategy.h
+  qmirserverapplication.h
+  qmirserver.h
+  sessionauthorizer.h
+  sessionlistener.h
+  shellserverconfiguration.h
+  surfacefactory.h
+  surfaceconfigurator.h
+  logging.h
+  focussetter.h
+  serverstatuslistener.h)
+
+add_library(
+  unity-mir SHARED
+
+  dbusscreen.cpp
+  initialsurfaceplacementstrategy.cpp
+  qmirserverapplication.cpp
+  qmirserver.cpp
+  sessionauthorizer.cpp
+  sessionlistener.cpp
+  shellserverconfiguration.cpp
+  surfacefactory.cpp
+  surfaceconfigurator.cpp
+  focussetter.cpp
+  serverstatuslistener.cpp
+
+  ${UNITY_MIR_HEADERS})
+
+# 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(unity-mir Core Quick DBus)
+
+set_target_properties(
+  unity-mir
+
+  PROPERTIES
+  VERSION ${UNITY_MIR_VERSION_MAJOR}.${UNITY_MIR_VERSION_MINOR}.${UNITY_MIR_VERSION_PATCH}
+  SOVERSION ${UNITY_MIR_VERSION_MAJOR})
+
+target_link_libraries(
+  unity-mir
+
+  Qt5::Core
+  Qt5::Quick
+  Qt5::DBus
+
+  ${CMAKE_THREAD_LIBS_INIT}
+
+  ${UBUNTU_PLATFORM_API_LIBRARIES}
+  ${MIRCOMMON_LIBRARIES}
+  ${MIRSERVER_LIBRARIES}
+
+  ubuntu_application_api_mirserver)
+
+install(
+  TARGETS unity-mir
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+install(
+  FILES ${UNITY_MIR_HEADERS}
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/unity-mir)

=== modified file 'src/unity-mir/logging.h'
--- src/unity-mir/logging.h	2013-08-22 12:06:58 +0000
+++ src/unity-mir/logging.h	2014-01-10 09:14:26 +0000
@@ -17,6 +17,8 @@
 #ifndef UBUNTU_APPLICATION_PLUGIN_LOGGING_H
 #define UBUNTU_APPLICATION_PLUGIN_LOGGING_H
 
+#pragma GCC diagnostic ignored "-Wformat"
+
 #include <QDebug>
 
 // Logging and assertion macros.

=== removed file 'src/unity-mir/unity-mir.pro'
--- src/unity-mir/unity-mir.pro	2013-11-18 16:05:56 +0000
+++ src/unity-mir/unity-mir.pro	1970-01-01 00:00:00 +0000
@@ -1,67 +0,0 @@
-TARGET = unity-mir
-TEMPLATE = lib
-
-QT       += core quick dbus
-CONFIG   += link_pkgconfig
-
-# CONFIG += c++11 # only enables C++0x
-QMAKE_CXXFLAGS = -std=c++11
-QMAKE_CXXFLAGS_RELEASE += -Werror     # so no stop on warning in debug builds
-QMAKE_LFLAGS = -std=c++11 -Wl,-no-undefined
-
-PKGCONFIG += mircommon mirserver ubuntu-platform-api
-
-LIBS += -lubuntu_application_api_mirserver #FIXME platform-api pkgconfig should set this
-
-SOURCES += \
-    dbusscreen.cpp \
-    initialsurfaceplacementstrategy.cpp \
-    qmirserverapplication.cpp \
-    qmirserver.cpp \
-    sessionauthorizer.cpp \
-    sessionlistener.cpp \
-    shellserverconfiguration.cpp \
-    surfacefactory.cpp \
-    surfaceconfigurator.cpp \
-    focussetter.cpp \
-    serverstatuslistener.cpp
-
-HEADERS += \
-    dbusscreen.h \
-    initialsurfaceplacementstrategy.h \
-    qmirserverapplication.h \
-    qmirserver.h \
-    sessionauthorizer.h \
-    sessionlistener.h \
-    shellserverconfiguration.h \
-    surfacefactory.h \
-    surfaceconfigurator.h \
-    logging.h \
-    focussetter.h \
-    serverstatuslistener.h
-
-target.path = $$[QT_INSTALL_LIBS]
-
-install_headers.files = qmirserverapplication.h \
-    qmirserver.h \
-    initialsurfaceplacementstrategy.h \
-    sessionauthorizer.h \
-    sessionlistener.h \
-    shellserverconfiguration.h \
-    surfacebuilder.h \
-    surfacefactory.h
-install_headers.path = /usr/include/unity-mir
-
-### Generate pkg-config file
-CONFIG += create_pc create_prl no_install_prl
-
-QMAKE_PKGCONFIG_NAME = Unity-Mir
-QMAKE_PKGCONFIG_DESCRIPTION = Qt wrapper for Mir functionality required by Unity
-QMAKE_PKGCONFIG_PREFIX = $$INSTALLBASE
-QMAKE_PKGCONFIG_LIBDIR = $$target.path
-QMAKE_PKGCONFIG_INCDIR = $$installheaders.path
-QMAKE_PKGCONFIG_VERSION = $$VERSION
-QMAKE_PKGCONFIG_REQUIRES = ubuntu-platform-api mirclient mirserver Qt5Core
-QMAKE_PKGCONFIG_DESTDIR = pkgconfig
-
-INSTALLS += target install_headers

=== added file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/CMakeLists.txt	2014-01-10 09:14:26 +0000
@@ -0,0 +1,48 @@
+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(
+  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(taskcontroller_test Core Quick DBus)
+
+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)

=== added file 'tests/taskcontroller_test.cpp'
--- tests/taskcontroller_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/taskcontroller_test.cpp	2014-01-10 09:14:26 +0000
@@ -0,0 +1,211 @@
+/*
+ * 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ *
+ */
+
+#include <Unity/Application/taskcontroller.h>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+namespace
+{
+struct MockOomController : public TaskController::OomController
+{
+    MOCK_METHOD1(ensureProcessLikelyToBeKilled, void(pid_t));
+    MOCK_METHOD1(ensureProcessUnlikelyToBeKilled, void(pid_t));
+};
+
+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<TaskController::OomController> oomControllerPtr(
+                &oomController,
+                [](TaskController::OomController*){});
+
+    TaskController taskController(nullptr,
+                                  appControllerPtr,
+                                  oomControllerPtr);
+
+    taskController.start("com.canonical.does.not.exist", 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<TaskController::OomController> oomControllerPtr(
+                &oomController,
+                [](TaskController::OomController*){});
+
+    TaskController taskController(nullptr,
+                                  appControllerPtr,
+                                  oomControllerPtr);
+
+    taskController.stop("com.canonical.does.not.exist");
+}
+
+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<TaskController::OomController> oomControllerPtr(
+                &oomController,
+                [](TaskController::OomController*){});
+
+    EXPECT_CALL(oomController, ensureProcessLikelyToBeKilled(-1)).Times(1);
+
+    TaskController taskController(nullptr,
+                                  appControllerPtr,
+                                  oomControllerPtr);
+
+    taskController.suspend("com.canonical.does.not.exist");
+}
+
+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<TaskController::OomController> oomControllerPtr(
+                &oomController,
+                [](TaskController::OomController*){});
+
+    EXPECT_CALL(oomController, ensureProcessUnlikelyToBeKilled(-1)).Times(1);
+
+    TaskController taskController(nullptr,
+                                  appControllerPtr,
+                                  oomControllerPtr);
+
+    taskController.resume("com.canonical.does.not.exist");
+}
+
+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<TaskController::OomController> oomControllerPtr(
+                &oomController,
+                [](TaskController::OomController*){});
+
+    EXPECT_CALL(oomController, ensureProcessUnlikelyToBeKilled(42)).Times(1);
+
+    TaskController taskController(nullptr,
+                                  appControllerPtr,
+                                  oomControllerPtr);
+
+    appControllerPtr->triggerApplicationStarted("com.canonical.does.not.exist");
+}
+
+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<TaskController::OomController> oomControllerPtr(
+                &oomController,
+                [](TaskController::OomController*){});
+
+    EXPECT_CALL(oomController, ensureProcessUnlikelyToBeKilled(42)).Times(1);
+
+    TaskController taskController(nullptr,
+                                  appControllerPtr,
+                                  oomControllerPtr);
+
+    appControllerPtr->triggerApplicationFocusRequest("com.canonical.does.not.exist");
+}

=== removed file 'tests/tests.pro'
=== removed file 'unity-mir.pro'
--- unity-mir.pro	2013-09-26 09:48:22 +0000
+++ unity-mir.pro	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-TEMPLATE = subdirs
-SUBDIRS = src #tests