Merge lp:~gerboland/unity-mir/namespace-to-prevent-collision into lp:unity-mir

[Gerry Boland]

Wrap classes of the QML plugin in a unitymir namespace, prevents symbol collision with Mir

Wrap classes of the QML plugin in a unitymir namespace, prevents symbol collision with Mir

• Are there any related MPs required for this MP to build/function as expected?
No
• Did you perform an exploratory manual test run of your code change and any related functionality?
Yes
• If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
Unnecessary

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[Alexandros Frantzis (afrantzis)]

Great! Confirmed this MP fixes bug #1282248 in the emulator, too.

review: Approve

[Alberto Aguirre (albaguirre)]

Looks like this needs a pre-requisite branch: lp:~albaguirre/unity-mir/add-cross-compile-scripts

[Alberto Aguirre (albaguirre)]

Actually looks like the MP needs pre-req: lp:~andreas-pokorny/unity-mir/fix-1240400

But namespace changes look good.

review: Approve

[Gerry Boland (gerboland)]

> Actually looks like the MP needs pre-req: lp:~andreas-pokorny/unity-
> mir/fix-1240400
Forgot to specify that, correcting now.

[lp:~gerboland/unity-mir/namespace-to-prevent-collision]

187. By Gerry Boland on 2014-02-28

Wrap classes of the QML plugin in a unitymir namespace, prevents symbol collision with Mir

188. By Gerry Boland on 2014-02-28

Merge fix from fix-1240400

189. By Gerry Boland on 2014-03-07

missing namespace qualifier in Q_PROPERTY

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-02-14 15:42:49 +0000
+++ CMakeLists.txt	2014-02-26 21:35:04 +0000
@@ -59,6 +59,7 @@
 find_package(Qt5Core REQUIRED)
 find_package(Qt5Quick REQUIRED)
 find_package(Qt5DBus REQUIRED)
+find_package(Boost 1.50 COMPONENTS system REQUIRED)
 
 find_package(Protobuf REQUIRED)
 if(PROTOBUF_PROTOC_EXECUTABLE STREQUAL "PROTOBUF_PROTOC_EXECUTABLE-NOTFOUND")

=== added directory 'cmake'
=== added file 'cmake/LinuxCrossCompile.cmake'
--- cmake/LinuxCrossCompile.cmake	1970-01-01 00:00:00 +0000
+++ cmake/LinuxCrossCompile.cmake	2014-02-26 21:35:04 +0000
@@ -0,0 +1,39 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_VERSION 1)
+
+set(UNITYMIR_CHROOT_DIR $ENV{UNITYMIR_CHROOT_DIR} CACHE STRING "directory containing partial chroot for unity-mir cross-compilation")
+set(UNITYMIR_ARM_EABI "arm-linux-gnueabihf")
+
+set(CMAKE_C_COMPILER   /usr/bin/${UNITYMIR_ARM_EABI}-gcc)
+set(CMAKE_CXX_COMPILER /usr/bin/${UNITYMIR_ARM_EABI}-g++)
+
+# where to look to find dependencies in the target environment
+set(CMAKE_FIND_ROOT_PATH  "${UNITYMIR_CHROOT_DIR}")
+
+#treat the chroot's includes as system includes
+include_directories(SYSTEM "${UNITYMIR_CHROOT_DIR}/usr/include" "${UNITYMIR_CHROOT_DIR}/usr/include/${UNITYMIR_ARM_EABI}")
+
+list(APPEND CMAKE_SYSTEM_INCLUDE_PATH "${UNITYMIR_CHROOT_DIR}/usr/include" "${UNITYMIR_CHROOT_DIR}/usr/include/${UNITYMIR_ARM_EABI}" )
+
+# Add the chroot libraries as system libraries
+list(APPEND CMAKE_SYSTEM_LIBRARY_PATH
+  "${UNITYMIR_CHROOT_DIR}/lib"
+  "${UNITYMIR_CHROOT_DIR}/lib/${UNITYMIR_ARM_EABI}"
+  "${UNITYMIR_CHROOT_DIR}/usr/lib"
+  "${UNITYMIR_CHROOT_DIR}/usr/lib/${UNITYMIR_ARM_EABI}"
+)
+
+set(CMAKE_INSTALL_RPATH_USE_LINK_PATH FALSE)
+set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
+set(CMAKE_EXECUTABLE_RUNTIME_C_FLAG "-Wl,-rpath-link,")
+set(CMAKE_EXECUTABLE_RUNTIME_CXX_FLAG "-Wl,-rpath-link,")
+set(CMAKE_INSTALL_RPATH "${UNITYMIR_CHROOT_DIR}/lib:${UNITYMIR_CHROOT_DIR}/lib/${UNITYMIR_ARM_EABI}:${UNITYMIR_CHROOT_DIR}/usr/lib:${UNITYMIR_CHROOT_DIR}/usr/lib/${UNITYMIR_ARM_EABI}:${UNITYMIR_CHROOT_DIR}/usr/lib/${UNITYMIR_ARM_EABI}/mesa-egl")
+
+set(ENV{PKG_CONFIG_PATH} "${UNITYMIR_CHROOT_DIR}/usr/lib/pkgconfig:${UNITYMIR_CHROOT_DIR}/usr/lib/${UNITYMIR_ARM_EABI}/pkgconfig")
+set(ENV{PKG_CONFIG_SYSROOT_DIR} "${UNITYMIR_CHROOT_DIR}")
+
+#use only the cross compile system
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+

=== added file 'cross-compile-chroot.sh'
--- cross-compile-chroot.sh	1970-01-01 00:00:00 +0000
+++ cross-compile-chroot.sh	2014-02-26 21:35:04 +0000
@@ -0,0 +1,85 @@
+#!/bin/bash
+# build script to compile unity-mir for armhf devices
+
+set -e
+
+usage() {
+  echo "usage: $(basename $0) [-c] [-u]"
+  echo "-c clean before building"
+  echo "-u update partial chroot directory"
+  echo "-h this message"
+}
+
+clean_build_dir() {
+    rm -rf ${1}
+    mkdir ${1}
+}
+
+BUILD_DIR=build-android-arm
+NUM_JOBS=$(( $(grep -c ^processor /proc/cpuinfo) + 1 ))
+_do_update_chroot=0
+
+while getopts "cuh" OPTNAME
+do
+    case $OPTNAME in
+      c )
+        clean_build_dir ${BUILD_DIR}
+        ;;
+      u )
+        _do_update_chroot=1
+        ;;
+      h )
+        usage
+        exit 0
+        ;;
+      * )
+        echo "invalid option specified"
+        usage
+        exit 1
+        ;;
+    esac
+done
+
+
+if [ "${UNITYMIR_CHROOT_DIR}" = "" ]; then
+    export UNITYMIR_CHROOT_DIR=$(pwd)/partial-armhf-chroot
+fi
+
+if [ ! -d ${UNITYMIR_CHROOT_DIR} ]; then 
+    echo "no partial chroot dir detected. attempting to create one"
+    _do_update_chroot=1
+fi
+
+if [ ! -d ${BUILD_DIR} ]; then 
+    mkdir ${BUILD_DIR}
+fi
+
+if [ ${_do_update_chroot} -eq 1 ] ; then
+    pushd scripts > /dev/null
+        ./setup-partial-armhf-chroot.sh ${UNITYMIR_CHROOT_DIR}
+    popd > /dev/null
+    # force a clean build after an update, since CMake cache maybe out of date
+    clean_build_dir ${BUILD_DIR}
+fi
+
+echo "Using UNITYMIR_CHROOT_DIR: ${UNITYMIR_CHROOT_DIR}"
+
+pushd ${BUILD_DIR} > /dev/null 
+
+    export CMAKE_PREFIX_PATH=${UNITYMIR_CHROOT_DIR}/usr/lib/arm-linux-gnueabihf/cmake
+    export PKG_CONFIG_PATH="${UNITYMIR_CHROOT_DIR}/usr/lib/pkgconfig:${UNITYMIR_CHROOT_DIR}/usr/lib/arm-linux-gnueabihf/pkgconfig"
+    export PKG_CONFIG_ALLOW_SYSTEM_CFLAGS=1
+    export PKG_CONFIG_ALLOW_SYSTEM_LIBS=1
+    export PKG_CONFIG_SYSROOT_DIR=${UNITYMIR_CHROOT_DIR}
+    export PKG_CONFIG_EXECUTABLE=`which pkg-config`
+    echo "Using PKG_CONFIG_PATH: $PKG_CONFIG_PATH"
+    echo "Using PKG_CONFIG_EXECUTABLE: $PKG_CONFIG_EXECUTABLE"
+    
+    # These are used to make cmake select the host machine QT MOC compiler in the AutoMocInfo module
+    export DEB_HOST_MULTIARCH=arm-linux-gnueabihf
+    export DEB_BUILD_MULTIARCH=$(gcc -dumpmachine)
+
+    cmake -DCMAKE_TOOLCHAIN_FILE=../cmake/LinuxCrossCompile.cmake ..
+    make -j${NUM_JOBS}
+
+popd ${BUILD_DIR} > /dev/null 

=== modified file 'debian/control'
--- debian/control	2014-02-14 15:42:49 +0000
+++ debian/control	2014-02-26 21:35:04 +0000
@@ -6,6 +6,7 @@
                cmake,
                google-mock (>= 1.6.0+svn437),
                pkg-config,
+               libboost-dev,
                libboost-system-dev,
                libplatform-api1-dev,
                libmirserver-dev (>= 0.1.5),

=== added directory 'scripts'
=== added file 'scripts/fix-qt-cmake.sh'
--- scripts/fix-qt-cmake.sh	1970-01-01 00:00:00 +0000
+++ scripts/fix-qt-cmake.sh	2014-02-26 21:35:04 +0000
@@ -0,0 +1,10 @@
+#!/bin/bash
+
+# $1 must contain path to QT cmake files
+# Given that path, all hardcoded root paths are fixed up
+for file in $(find ${1} -type f -name \*.cmake)
+do
+    echo "fixing $file"
+    sed -i 's/NO_DEFAULT_PATH/ONLY_CMAKE_FIND_ROOT_PATH/g' $file
+    sed -i 's/\/usr/${CMAKE_FIND_ROOT_PATH}\/usr/g' $file
+done

=== added file 'scripts/setup-partial-armhf-chroot.sh'
--- scripts/setup-partial-armhf-chroot.sh	1970-01-01 00:00:00 +0000
+++ scripts/setup-partial-armhf-chroot.sh	2014-02-26 21:35:04 +0000
@@ -0,0 +1,67 @@
+#!/bin/bash
+
+set -e
+
+if [ -z ${1} ]; then
+    echo "please supply directory to create partial chroot in. (eg, ./setup-partial-armhf-chroot.sh mychroot-dir)"
+    exit
+fi
+
+echo "creating phablet-compatible armhf partial chroot for unity-mir compilation in directory ${1}"
+
+if [ ! -d ${1} ]; then
+    mkdir -p ${1} 
+fi
+
+DEBCONTROL=$(pwd)/../debian/control
+
+pushd ${1} > /dev/null
+
+# Empty dpkg status file, so that ALL dependencies are listed with dpkg-checkbuilddeps
+echo "" > status
+
+# Manual error code checking is needed for dpkg-checkbuilddeps
+set +e
+
+# Parse dependencies from debian/control
+# dpkg-checkbuilddeps returns 1 when dependencies are not met and the list is sent to stderr
+builddeps=$(dpkg-checkbuilddeps -a armhf --admindir=. ${DEBCONTROL} 2>&1 )
+if [ $? -ne 1 ] ; then
+    echo "${builddeps}"
+    exit 2
+fi
+
+# now turn exit on error option
+set -e
+
+# Sanitize dependencies list for submission to debootstrap
+# build-essential is not needed as we are cross-compiling
+builddeps=$(echo ${builddeps} | sed -e 's/dpkg-checkbuilddeps://g' -e 's/Unmet build dependencies://g' -e 's/build-essential:native//g')
+builddeps=$(echo ${builddeps} | sed 's/([^)]*)//g')
+# TODO: figure out why debootstrap is not finding libunity-api-dev package - it doesn't seem to be needed for cross-compilation - is it needed in debian/control?
+builddeps=$(echo ${builddeps} | sed 's/libunity-api-dev//g')
+builddeps=$(echo ${builddeps} | sed 's/ /,/g')
+
+fakeroot debootstrap --include=${builddeps} --arch=armhf --download-only --variant=buildd trusty .
+
+# Remove libc libraries that confuse the cross-compiler
+rm var/cache/apt/archives/libc-dev*.deb
+rm var/cache/apt/archives/libc6*.deb
+
+for deb in var/cache/apt/archives/* ; do
+if [ ! -d ${deb} ] ; then
+    echo "unpacking: ${deb}"
+    dpkg -x ${deb} .
+fi
+done
+
+# Fix up symlinks which asssumed the usual root path
+for broken_symlink in $(find . -name \*.so -type l -xtype l) ; do
+    ln -sf $(pwd)$(readlink ${broken_symlink}) ${broken_symlink}
+done
+
+popd > /dev/null
+
+# QT CMake files have hardcoded root paths - fix them up
+./fix-qt-cmake.sh ${1}/usr/lib/arm-linux-gnueabihf/cmake/
+

=== modified file 'src/modules/Unity/Application/CMakeLists.txt'
--- src/modules/Unity/Application/CMakeLists.txt	2014-01-27 11:29:44 +0000
+++ src/modules/Unity/Application/CMakeLists.txt	2014-02-26 21:35:04 +0000
@@ -31,6 +31,7 @@
   inputfilterarea.cpp
   processcontroller.h
   processcontroller.cpp
+  proc_info.cpp
   shellinputarea.cpp
   ubuntukeyboardinfo.cpp
 
@@ -74,12 +75,10 @@
   ${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_PLATFORM_API_LDFLAGS}
+  ${MIRSERVER_LDFLAGS}
+  ${PROCESS_CPP_LDFLAGS}
+  ${UPSTART_APP_LAUNCH_LDFLAGS}
 
   ubuntu_application_api_mirserver
 )

=== modified file 'src/modules/Unity/Application/application.cpp'
--- src/modules/Unity/Application/application.cpp	2014-01-27 11:29:44 +0000
+++ src/modules/Unity/Application/application.cpp	2014-02-26 21:35:04 +0000
@@ -27,6 +27,9 @@
 #include <mir/shell/session.h>
 #include <mir/shell/snapshot.h>
 
+namespace unitymir
+{
+
 Application::Application(const QSharedPointer<TaskController>& taskController,
                          DesktopFileReader *desktopFileReader,
                          State state,
@@ -52,7 +55,7 @@
 
 Application::~Application()
 {
-    DLOG("Application::~Application");
+    DLOG("Application::~Application (this=%p)", this);
     delete m_desktopData;
 }
 
@@ -233,3 +236,5 @@
     DLOG("Application::respawn (this=%p)", this);
     m_taskController->start(appId(), m_arguments);
 }
+
+} // namespace unitymir

=== modified file 'src/modules/Unity/Application/application.h'
--- src/modules/Unity/Application/application.h	2014-01-27 11:29:44 +0000
+++ src/modules/Unity/Application/application.h	2014-02-26 21:35:04 +0000
@@ -29,9 +29,13 @@
 #include <unity/shell/application/ApplicationInfoInterface.h>
 
 class QImage;
+namespace mir { namespace shell { class Session; }}
+
+namespace unitymir
+{
+
 class DesktopFileReader;
 class TaskController;
-namespace mir { namespace shell { class Session; }}
 
 class Application : public unity::shell::application::ApplicationInfoInterface {
     Q_OBJECT
@@ -100,6 +104,8 @@
     friend class MirSurfaceManager;
 };
 
-Q_DECLARE_METATYPE(Application*)
+} // namespace unity-mir
+
+Q_DECLARE_METATYPE(unitymir::Application*)
 
 #endif  // APPLICATION_H

=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2014-02-11 09:47:56 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2014-02-26 21:35:04 +0000
@@ -16,6 +16,7 @@
 
 // local
 #include "application_manager.h"
+#include "proc_info.h"
 #include "application.h"
 #include "desktopfilereader.h"
 #include "dbuswindowstack.h"
@@ -51,26 +52,133 @@
 
 using namespace unity::shell::application;
 
-ApplicationManager *ApplicationManager::the_application_manager = nullptr;
+namespace unitymir
+{
+
+namespace
+{
+
+QSize get_display_size(std::shared_ptr<mir::graphics::Display> const& display) {
+    // Obtain display size
+    mir::geometry::Rectangles view_area;
+    display->for_each_display_buffer(
+        [&view_area](mir::graphics::DisplayBuffer const& db)
+        {
+            view_area.add(db.view_area());
+        });
+
+    return QSize(
+        view_area.bounding_rectangle().size.width.as_uint32_t(),
+        view_area.bounding_rectangle().size.height.as_uint32_t()
+        );
+}
+
+
+void connectToSessionListener(ApplicationManager * manager, SessionListener * listener)
+{
+
+    QObject::connect(listener, &SessionListener::sessionStarting,
+                     manager, &ApplicationManager::onSessionStarting);
+    QObject::connect(listener, &SessionListener::sessionStopping,
+                     manager, &ApplicationManager::onSessionStopping);
+    QObject::connect(listener, &SessionListener::sessionFocused,
+                     manager, &ApplicationManager::onSessionFocused, Qt::QueuedConnection);
+    QObject::connect(listener, &SessionListener::sessionUnfocused,
+                     manager, &ApplicationManager::onSessionUnfocused);
+    QObject::connect(listener, &SessionListener::sessionCreatedSurface,
+                     manager, &ApplicationManager::onSessionCreatedSurface);
+    QObject::connect(listener, &SessionListener::sessionStarting,
+                     manager, &ApplicationManager::onSessionStarting);
+    QObject::connect(listener, &SessionListener::sessionStopping,
+                     manager, &ApplicationManager::onSessionStopping);
+    QObject::connect(listener, &SessionListener::sessionFocused,
+                     manager, &ApplicationManager::onSessionFocused, Qt::QueuedConnection);
+    QObject::connect(listener, &SessionListener::sessionUnfocused,
+                     manager, &ApplicationManager::onSessionUnfocused);
+    QObject::connect(listener, &SessionListener::sessionCreatedSurface,
+                     manager, &ApplicationManager::onSessionCreatedSurface);
+}
+
+void connectToSessionAuthorizer(ApplicationManager * manager, SessionAuthorizer * authorizer)
+{
+    QObject::connect(authorizer, &SessionAuthorizer::requestAuthorizationForSession,
+                     manager, &ApplicationManager::authorizeSession, Qt::BlockingQueuedConnection);
+}
+
+
+void connectToPlacementStrategy(ApplicationManager * manager, InitialSurfacePlacementStrategy * strategy)
+{
+    QObject::connect(strategy, &InitialSurfacePlacementStrategy::requestPlacementForSession,
+                     manager, &ApplicationManager::placeSession, Qt::DirectConnection);
+
+}
+
+void connectToTaskController(ApplicationManager * manager, TaskController * controller)
+{
+    QObject::connect(controller, &TaskController::processStartReport,
+                     manager, &ApplicationManager::onProcessStartReportReceived);
+    QObject::connect(controller, &TaskController::processStopped,
+                     manager, &ApplicationManager::onProcessStopped);
+    QObject::connect(controller, &TaskController::requestFocus,
+                     manager, &ApplicationManager::onFocusRequested);
+    QObject::connect(controller, &TaskController::requestResume,
+                     manager, &ApplicationManager::onResumeRequested);
+
+}
+}
+
+QSharedPointer<ApplicationManager> ApplicationManager::Factory::Factory::create()
+{
+    QMirServerApplication* mirServerApplication = dynamic_cast<QMirServerApplication*>(QCoreApplication::instance());
+    if (mirServerApplication == NULL) {
+        LOG("Need to use QMirServerApplication");
+        QCoreApplication::quit();
+        return QSharedPointer<ApplicationManager>(nullptr);
+    }
+
+    ShellServerConfiguration * mirServer = mirServerApplication->server();
+
+    QSize displaySize{get_display_size(mirServer->the_display())};
+
+    QSharedPointer<upstart::ApplicationController> appController(new upstart::ApplicationController());
+    QSharedPointer<TaskController> taskController(new TaskController(nullptr, appController));
+    QSharedPointer<DesktopFileReader::Factory> fileReaderFactory(new DesktopFileReader::Factory());
+    QSharedPointer<ProcInfo> procInfo(new ProcInfo());
+    QSharedPointer<ApplicationManager> appManager(
+        new ApplicationManager(
+            taskController,
+            fileReaderFactory,
+            procInfo,
+            mirServer->the_focus_controller(),
+            displaySize
+            )
+        );
+
+
+    connectToSessionListener(appManager.data(), mirServer->sessionListener());
+    connectToSessionAuthorizer(appManager.data(), mirServer->sessionAuthorizer());
+    connectToPlacementStrategy(appManager.data(), mirServer->placementStrategy());
+    connectToTaskController(appManager.data(), taskController.data());
+
+    return appManager;
+}
 
 ApplicationManager* ApplicationManager::singleton()
 {
-    if (!the_application_manager) {
-        the_application_manager = new ApplicationManager(
-                    QSharedPointer<TaskController>(
-                        new TaskController(
-                            nullptr,
-                            QSharedPointer<ApplicationController>(
-                                new upstart::ApplicationController()))),
-                    QSharedPointer<DesktopFileReader::Factory>(
-                        new DesktopFileReader::Factory()));
+    static QSharedPointer<ApplicationManager> instance;
+    if (!instance) {
+        Factory appFactory;
+        instance = appFactory.create();
     }
-    return the_application_manager;
+    return instance.data();
 }
 
 ApplicationManager::ApplicationManager(
         const QSharedPointer<TaskController>& taskController,
         const QSharedPointer<DesktopFileReader::Factory>& desktopFileReaderFactory,
+        const QSharedPointer<ProcInfo>& procInfo,
+        const std::shared_ptr<mir::shell::FocusController> & controller,
+        const QSize & displaySize,
         QObject *parent)
     : ApplicationManagerInterface(parent)
     , m_focusedApplication(nullptr)
@@ -79,63 +187,18 @@
     , m_msApplicationToBeFocused(nullptr)
     , m_ssApplicationToBeFocused(nullptr)
     , m_lifecycleExceptions(QStringList() << "com.ubuntu.music")
+    , m_focusController(controller)
+    , m_dbusWindowStack(new DBusWindowStack(this))
     , m_taskController(taskController)
     , m_desktopFileReaderFactory(desktopFileReaderFactory)
+    , m_procInfo(procInfo)
     , m_gridUnitPx(8)
     , m_fenceNext(false)
+    , m_displaySize(displaySize)
     , m_panelHeight(54)
 {
     DLOG("ApplicationManager::ApplicationManager (this=%p)", this);
 
-    QMirServerApplication* mirServerApplication = dynamic_cast<QMirServerApplication*>(QCoreApplication::instance());
-    if (mirServerApplication == NULL) {
-        LOG("Need to use QMirServerApplication");
-        QCoreApplication::quit();
-        return;
-    }
-    m_mirServer = mirServerApplication->server();
-
-    QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionStarting,
-                     this, &ApplicationManager::onSessionStarting);
-    QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionStopping,
-                     this, &ApplicationManager::onSessionStopping);
-    QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionFocused,
-                     this, &ApplicationManager::onSessionFocused, Qt::QueuedConnection);
-    QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionUnfocused,
-                     this, &ApplicationManager::onSessionUnfocused);
-    QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionCreatedSurface,
-                     this, &ApplicationManager::onSessionCreatedSurface);
-    QObject::connect(m_mirServer->sessionAuthorizer(), &SessionAuthorizer::requestAuthorizationForSession,
-                     this, &ApplicationManager::authorizeSession, Qt::BlockingQueuedConnection);
-    QObject::connect(m_mirServer->placementStrategy(), &InitialSurfacePlacementStrategy::requestPlacementForSession,
-                     this, &ApplicationManager::placeSession, Qt::DirectConnection);
-
-    QObject::connect(m_taskController.data(), &TaskController::processStartReport,
-                     this, &ApplicationManager::onProcessStartReportReceived);
-    QObject::connect(m_taskController.data(), &TaskController::processStopped,
-                     this, &ApplicationManager::onProcessStopped);
-    QObject::connect(m_taskController.data(), &TaskController::requestFocus,
-                     this, &ApplicationManager::onFocusRequested);
-    QObject::connect(m_taskController.data(), &TaskController::requestResume,
-                     this, &ApplicationManager::onResumeRequested);
-
-    m_dbusWindowStack = new DBusWindowStack(this);
-
-    std::shared_ptr<mir::graphics::Display> mirDisplay = m_mirServer->the_display();
-
-    // Obtain display size
-    mir::geometry::Rectangles view_area;
-    mirDisplay->for_each_display_buffer(
-        [&view_area](mir::graphics::DisplayBuffer const& db)
-        {
-            view_area.add(db.view_area());
-        });
-    
-    m_displaySize = QSize(
-        view_area.bounding_rectangle().size.width.as_uint32_t(),
-        view_area.bounding_rectangle().size.height.as_uint32_t()
-        );
-
     // Setup panel height
     QByteArray gridUnitString = qgetenv("GRID_UNIT_PX");
     if (!gridUnitString.isEmpty()) {
@@ -222,6 +285,7 @@
     if (application == nullptr)
         return;
 
+    DLOG("ApplicationManager::suspend(this=%p, application(%p)->appId(%s) )",this, application, qPrintable(application->appId()));
     // Present in exceptions list, return.
     if (!m_lifecycleExceptions.filter(application->appId().section('_',0,0)).empty())
         return;
@@ -232,8 +296,8 @@
 
 bool ApplicationManager::focusApplication(const QString &appId)
 {
-    DLOG("ApplicationManager::focusApplication (this=%p, appId=%s)", this, qPrintable(appId));
     Application *application = findApplication(appId);
+    DLOG("ApplicationManager::focusApplication (this=%p, application=%p, appId=%s)", this, application, qPrintable(appId));
 
     if (!application) {
         DLOG("No such running application '%s'", qPrintable(appId));
@@ -256,7 +320,7 @@
         move(from, m_applications.length()-1);
     } else {
         if (application->session())
-            m_mirServer->the_focus_controller()->set_focus_to(application->session());
+            m_focusController->set_focus_to(application->session());
     }
 
     // FIXME(dandrader): lying here. The operation is async. So we will only know whether
@@ -275,7 +339,7 @@
     // Clear both stages
     m_msApplicationToBeFocused = nullptr;
     m_ssApplicationToBeFocused = nullptr;
-    m_mirServer->the_focus_controller()->set_focus_to(NULL); //FIXME(greyback)
+    m_focusController->set_focus_to(NULL); //FIXME(greyback)
 }
 
 Application* ApplicationManager::startApplication(const QString &appId,
@@ -294,6 +358,16 @@
         return nullptr;
     }
 
+    {
+        Application * application = findApplication(appId);
+        if (application)
+        {
+            DLOG("ApplicationManager::startApplication - application already "
+                 "exists: (this=%p, app=%p, appId=%s)",
+                 this, application, qPrintable(appId));
+        }
+    }
+
     Application* application = new Application(
                 m_taskController,
                 m_desktopFileReaderFactory->createInstanceForAppId(appId),
@@ -320,7 +394,9 @@
          this, qPrintable(appId), (failure) ? 'Y' : 'N');
 
     if (failure) {
-        onProcessStopped(appId, true);
+        DLOG("ApplicationManager::onProcessStartReportReceived handling failure:");
+        stopStartingApplication(appId);
+        return;
     }
 
     Application *application = findApplication(appId);
@@ -338,30 +414,23 @@
         add(application);
         Q_EMIT focusRequested(appId);
     }
+    else {
+        DLOG("ApplicationManager::onProcessStartReportReceived application already found: (app=%p, appId=%s)", application, qPrintable(appId));
+    }
 }
 
 bool ApplicationManager::stopApplication(const QString &appId)
 {
-    DLOG("ApplicationManager::stopApplication (this=%p, appId=%s)", this, qPrintable(appId));
-
     Application *application = findApplication(appId);
+    DLOG("ApplicationManager::stopApplication (this=%p, application=%p, appId=%s)", this, application, qPrintable(appId));
 
     if (!application) {
         DLOG("No such running application '%s'", qPrintable(appId));
         return false;
     }
 
-    if (application == m_focusedApplication) {
-        // TODO(greyback) What to do?? Focus next app, or unfocus everything??
-        m_focusedApplication = NULL;
-        Q_EMIT focusedApplicationIdChanged();
-    }
+    checkFocusOnRemovedApplication(application);
 
-    if (application == m_mainStageApplication)
-        m_mainStageApplication = nullptr;
-    if (application == m_sideStageApplication)
-        m_sideStageApplication = nullptr;
-    
     remove(application);
     m_dbusWindowStack->WindowDestroyed(0, application->appId());
 
@@ -376,37 +445,28 @@
     return result;
 }
 
+void ApplicationManager::stopStartingApplication(const QString &appId)
+{
+    Application *application = findApplication(appId);
+
+    if (application && application->state() == Application::Starting) {
+        shutdownApplication(application);
+    }
+    else if (application) {
+        DLOG("onProcessStartReportReceived failure - but application=%p, appId=%s is not in Starting state",application, qPrintable(appId));
+    }
+}
+
 void ApplicationManager::onProcessStopped(const QString &appId, const bool unexpected)
 {
     Application *application = findApplication(appId);
+    DLOG("ApplicationManager::onProcessStopped (this=%p, application=%p, appId=%s)", this, application, qPrintable(appId));
 
     // if shell did not stop the application, but upstart says it died, we assume the process has been
     // killed, so it can be respawned later. Only exception is if that application is focused or running
     // as then it most likely crashed. Update this logic when upstart gives some failure info.
     if (application) {
-        bool removeApplication = false;
-
-        if (application == m_focusedApplication) {
-            // Very bad case where focused application dies. Remove from list. Should give error message
-            m_focusedApplication = nullptr;
-            Q_EMIT focusedApplicationIdChanged();
-            removeApplication = true;
-        }
-
-        if (application->state() == Application::Running || application->state() == Application::Starting) {
-            // Application probably crashed, else OOM killer struck. Either way state wasn't saved
-            // so just remove application
-            removeApplication = true;
-        } else if (application->state() == Application::Suspended) {
-            application->setState(Application::Stopped);
-            application->setSession(nullptr);
-        }
-
-        if (removeApplication) {
-            remove(application);
-            m_dbusWindowStack->WindowDestroyed(0, application->appId());
-            delete application;
-        }
+        shutdownApplication(application);
     }
 
     if (unexpected) {
@@ -415,6 +475,27 @@
     }
 }
 
+void ApplicationManager::shutdownApplication(Application* application)
+{
+    bool removeApplication = checkFocusOnRemovedApplication(application);
+
+    if (application->state() == Application::Running || application->state() == Application::Starting) {
+        // Application probably crashed, else OOM killer struck. Either way state wasn't saved
+        // so just remove application
+        removeApplication = true;
+    } else if (application->state() == Application::Suspended) {
+        application->setState(Application::Stopped);
+        application->setSession(nullptr);
+    }
+
+    if (removeApplication) {
+        remove(application);
+        m_dbusWindowStack->WindowDestroyed(0, application->appId());
+        delete application;
+    }
+
+}
+
 void ApplicationManager::onFocusRequested(const QString& appId)
 {
     DLOG("ApplicationManager::onFocusRequested (this=%p, appId=%s)", this, qPrintable(appId));
@@ -424,9 +505,9 @@
 
 void ApplicationManager::onResumeRequested(const QString& appId)
 {
-    DLOG("ApplicationManager::onResumeRequested (this=%p, appId=%s)", this, qPrintable(appId));
-
     Application *application = findApplication(appId);
+    DLOG("ApplicationManager::onResumeRequested (this=%p, application=%p, appId=%s)", this, application, qPrintable(appId));
+
 
     if (!application) {
         DLOG("ApplicationManager::onResumeRequested: No such running application '%s'", qPrintable(appId));
@@ -452,6 +533,7 @@
         if (app->state() == Application::Starting
                 && m_taskController->appIdHasProcessId(app->appId(), pid)) {
             app->setPid(pid);
+            DLOG("ApplicationManager::authorizeSession - connecting: application=%p and pid=%lld", app, pid);
             authorized = true;
             return;
         }
@@ -463,41 +545,35 @@
      * notify shell it is starting an application and so shell should allow it. Also reads
      * the --stage parameter to determine the desired stage
      */
-    QFile cmdline(QString("/proc/%1/cmdline").arg(pid));
-    if (!cmdline.open(QIODevice::ReadOnly | QIODevice::Text)) {
+    std::unique_ptr<ProcInfo::CommandLine> info = m_procInfo->command_line(pid);
+    if (!info) {
         DLOG("ApplicationManager REJECTED connection from app with pid %lld as unable to read process command", pid);
         return;
     }
 
-    QByteArray command = cmdline.readLine().replace('\0', ' ');
-
-    // FIXME: special exception for the OSK - maliit-server - not very secure
-    if (command.startsWith("maliit-server") || command.startsWith("/usr/lib/arm-linux-gnueabihf/qt5/libexec/QtWebProcess")
-        || command.startsWith("/usr/bin/signon-ui")) {
+    if (info->starts_with("maliit-server") || info->starts_with("/usr/lib/arm-linux-gnueabihf/qt5/libexec/QtWebProcess")
+        || info->starts_with("/usr/bin/signon-ui")) {
         authorized = true;
         m_fenceNext = true;
         return;
     }
 
-    QString pattern = QRegularExpression::escape("--desktop_file_hint=") + "(\\S+)";
-    QRegularExpression regExp(pattern);
-    QRegularExpressionMatch regExpMatch = regExp.match(command);
+    boost::optional<QString> desktopFileName{ info->get_parameter("--desktop_file_hint=") };
 
-    if (!regExpMatch.hasMatch()) {
+    if (!desktopFileName) {
         LOG("ApplicationManager REJECTED connection from app with pid %lld as no desktop_file_hint specified", pid);
         return;
     }
 
-    QString desktopFileName = regExpMatch.captured(1);
-    DLOG("Process supplied desktop_file_hint, loading '%s'", desktopFileName.toLatin1().data());
+    DLOG("Process supplied desktop_file_hint, loading '%s'", desktopFileName.get().toLatin1().data());
 
     // FIXME: right now we support --desktop_file_hint=appId for historical reasons. So let's try that in
     // case we didn't get an existing .desktop file path
     DesktopFileReader* desktopData;
-    if (QFileInfo(desktopFileName).exists()) {
-        desktopData = m_desktopFileReaderFactory->createInstanceForDesktopFile(QFileInfo(desktopFileName));
+    if (QFileInfo(desktopFileName.get()).exists()) {
+        desktopData = m_desktopFileReaderFactory->createInstanceForDesktopFile(QFileInfo(desktopFileName.get()));
     } else {
-        desktopData = m_desktopFileReaderFactory->createInstanceForAppId(desktopFileName);
+        desktopData = m_desktopFileReaderFactory->createInstanceForAppId(desktopFileName.get());
     }
 
     if (!desktopData->loaded()) {
@@ -521,18 +597,15 @@
 
     // if stage supplied in CLI, fetch that
     Application::Stage stage = Application::MainStage;
-    pattern = QRegularExpression::escape("--stage_hint=") + "(\\S+)";
-    regExp.setPattern(pattern);
-    regExpMatch = regExp.match(command);
+    boost::optional<QString> stageParam = info->get_parameter("--stage_hint=");
 
-    if (regExpMatch.hasMatch() && regExpMatch.captured(1) == "side_stage") {
+    if (stageParam && stageParam.get() == "side_stage") {
         stage = Application::SideStage;
     }
 
     DLOG("Existing process with pid %lld appeared, adding '%s' to application lists", pid, desktopData->name().toLatin1().data());
 
-    QString argStr(command.data());
-    QStringList arguments(argStr.split(' '));
+    QStringList arguments(info->as_string_list());
     application = new Application(m_taskController, desktopData, Application::Starting, arguments, this);
     application->setPid(pid);
     application->setStage(stage);
@@ -542,9 +615,9 @@
 
 void ApplicationManager::placeSession(msh::Session const* session, uint32_t &x, uint32_t &y)
 {
-    DLOG("ApplicationManager::placeSession (this=%p, session=%p)", this, session);
+    Application* application = findApplicationWithSession(session);
+    DLOG("ApplicationManager::placeSession (this=%p, application=%p, session=%p, name=%s)", this, application, session, session?(session->name().c_str()):"null");
     
-    Application* application = findApplicationWithSession(session);
 
     // Application defaults 
     x = 0;
@@ -569,7 +642,7 @@
 
 void ApplicationManager::onSessionStarting(std::shared_ptr<msh::Session> const& session)
 {
-    DLOG("ApplicationManager::onSessionStarting (this=%p, application=%s)", this, session->name().c_str());
+    DLOG("ApplicationManager::onSessionStarting (this=%p, application=%s)", this, session?session->name().c_str():"null");
 
     if (m_fenceNext) {
         m_fenceNext = false;
@@ -592,10 +665,11 @@
 
 void ApplicationManager::onSessionStopping(std::shared_ptr<msh::Session> const& session)
 {
-    DLOG("ApplicationManager::onSessionStopping (this=%p, application=%s)", this, session->name().c_str());
-
     // in case application closed not by hand of shell, check again here:
     Application* application = findApplicationWithSession(session);
+
+    DLOG("ApplicationManager::onSessionStopping (this=%p, application=%p, appId=%s, session name=%s)", this, application, application?qPrintable(application->appId()):"null", session?session->name().c_str():"null");
+
     if (application) {
         bool removeApplication = true;
 
@@ -604,7 +678,7 @@
             application->setSession(nullptr);
             m_dbusWindowStack->WindowDestroyed(0, application->appId());
             if (application != m_focusedApplication) {
-	            removeApplication = false;
+                removeApplication = false;
             }
         }
 
@@ -626,8 +700,8 @@
 
 void ApplicationManager::onSessionFocused(std::shared_ptr<msh::Session> const& session)
 {
-    DLOG("ApplicationManager::onSessionFocused (this=%p, session=%p)", this, session.get());
     Application* application = findApplicationWithSession(session);
+    DLOG("ApplicationManager::onSessionFocused (this=%p, application=%p, appId=%s, session name=%s)", this, application, application?qPrintable(application->appId()):"null", session?session->name().c_str():"null");
 
     // Don't give application focus until it has created it's surface, when it is set as state "Running"
     // and only notify shell of focus changes that it actually expects
@@ -649,7 +723,7 @@
 
 void ApplicationManager::onSessionUnfocused()
 {
-    DLOG("ApplicationManager::onSessionUnfocused (this=%p)", this);
+    DLOG("ApplicationManager::onSessionUnfocused (this=%p, application=%p)", this, m_focusedApplication);
     if (NULL != m_focusedApplication) {
         Q_ASSERT(m_focusedApplication->focused());
         m_focusedApplication->setFocused(false);
@@ -683,7 +757,7 @@
 
 void ApplicationManager::setFocused(Application *application)
 {
-    DLOG("ApplicationManager::setFocused (appId=%s)", qPrintable(application->appId()));
+    DLOG("ApplicationManager::setFocused (application=%p, appId=%s)", application, qPrintable(application->appId()));
 
     if (application == m_focusedApplication)
         return;
@@ -769,6 +843,11 @@
     DASSERT(application != NULL);
     DLOG("ApplicationManager::remove (this=%p, application='%s')", this, qPrintable(application->name()));
 
+    if (application == m_sideStageApplication)
+        m_sideStageApplication = nullptr;
+    if (application == m_mainStageApplication)
+        m_mainStageApplication = nullptr;
+
     int i = m_applications.indexOf(application);
     if (i != -1) {
         beginRemoveRows(QModelIndex(), i, i);
@@ -803,3 +882,16 @@
 
     return QModelIndex();
 }
+
+bool ApplicationManager::checkFocusOnRemovedApplication(Application * application)
+{
+    if (application == m_focusedApplication) {
+        // TODO(greyback) What to do?? Focus next app, or unfocus everything??
+        m_focusedApplication = nullptr;
+        Q_EMIT focusedApplicationIdChanged();
+        return true;
+    }
+    return false;
+}
+
+} // namespace unitymir

=== modified file 'src/modules/Unity/Application/application_manager.h'
--- src/modules/Unity/Application/application_manager.h	2014-01-27 11:29:44 +0000
+++ src/modules/Unity/Application/application_manager.h	2014-02-26 21:35:04 +0000
@@ -34,11 +34,6 @@
 // local
 #include "application.h"
 
-class ShellServerConfiguration;
-class DBusWindowStack;
-class MirSurfaceManager;
-class TaskController;
-
 namespace mir {
     namespace geometry {
         class Size;
@@ -46,15 +41,30 @@
     namespace shell {
         class Session;
         class Surface;
+        class FocusController;
     }
 }
 
+class ShellServerConfiguration;
+
+namespace unitymir
+{
+class DBusWindowStack;
+class MirSurfaceManager;
+class TaskController;
+class ProcInfo;
+
 class ApplicationManager : public unity::shell::application::ApplicationManagerInterface
 {
     Q_OBJECT
     Q_FLAGS(ExecFlags)
 
 public:
+    class Factory
+    {
+    public:
+        QSharedPointer<ApplicationManager> create();
+    };
     // Mapping enums to Ubuntu Platform API enums.
     enum Flag {
         NoFlag = 0x0,
@@ -66,28 +76,31 @@
 
     explicit ApplicationManager(const QSharedPointer<TaskController>& taskController,
                                 const QSharedPointer<DesktopFileReader::Factory>& desktopFileReaderFactory,
+                                const QSharedPointer<ProcInfo>& processInfo,
+                                std::shared_ptr<mir::shell::FocusController> const& controller,
+                                QSize const& displaySize,
                                 QObject *parent = 0);
     virtual ~ApplicationManager();
 
     // ApplicationManagerInterface
     QString focusedApplicationId() const override;
-    Q_INVOKABLE Application* get(int index) const override;
-    Q_INVOKABLE Application* findApplication(const QString &appId) const override;
+    Q_INVOKABLE unitymir::Application* get(int index) const override;
+    Q_INVOKABLE unitymir::Application* findApplication(const QString &appId) const override;
     Q_INVOKABLE bool focusApplication(const QString &appId) override;
     Q_INVOKABLE void unfocusCurrentApplication() override;
-    Q_INVOKABLE Application* startApplication(const QString &appId, const QStringList &arguments) override;
+    Q_INVOKABLE unitymir::Application* startApplication(const QString &appId, const QStringList &arguments) override;
     Q_INVOKABLE bool stopApplication(const QString &appId) override;
 
     // QAbstractListModel
     int rowCount(const QModelIndex & parent = QModelIndex()) const override;
     QVariant data(const QModelIndex & index, int role = Qt::DisplayRole) const override;
 
-    Q_INVOKABLE Application *startApplication(const QString &appId, ExecFlags flags,
-                                              const QStringList &arguments = QStringList());
+    Q_INVOKABLE unitymir::Application *startApplication(const QString &appId, ExecFlags flags,
+                                                        const QStringList &arguments = QStringList());
     Q_INVOKABLE void move(int from, int to);
 
     const QList<Application*> &list() const { return m_applications; }
-    Application* findApplicationWithPid(const qint64 pid);
+    unitymir::Application* findApplicationWithPid(const qint64 pid);
 
     // Internal helpers
     void suspendApplication(Application *application);
@@ -122,6 +135,9 @@
     Application* findLastExecutedApplication();
     Application* applicationForStage(Application::Stage stage);
     QModelIndex findIndex(Application* application);
+    bool checkFocusOnRemovedApplication(Application* application);
+    void shutdownApplication(Application* application);
+    void stopStartingApplication(const QString &appId);
 
     QList<Application*> m_applications;
     Application* m_focusedApplication; // remove as Mir has API for this
@@ -130,11 +146,11 @@
     Application* m_msApplicationToBeFocused; // placeholder store for async focusing
     Application* m_ssApplicationToBeFocused; // placeholder store for async focusing
     QStringList m_lifecycleExceptions;
-    ShellServerConfiguration* m_mirServer;
+    std::shared_ptr<mir::shell::FocusController> m_focusController;
     DBusWindowStack* m_dbusWindowStack;
     QSharedPointer<TaskController> m_taskController;
     QSharedPointer<DesktopFileReader::Factory> m_desktopFileReaderFactory;
-    static ApplicationManager* the_application_manager;
+    QSharedPointer<ProcInfo> m_procInfo;
     int m_gridUnitPx;
     bool m_fenceNext;
     QSize m_displaySize;
@@ -144,6 +160,8 @@
     friend class MirSurfaceManager;
 };
 
-Q_DECLARE_METATYPE(ApplicationManager*)
+} // namespace unitymir
+
+Q_DECLARE_METATYPE(unitymir::ApplicationManager*)
 
 #endif // APPLICATIONMANAGER_H

=== modified file 'src/modules/Unity/Application/applicationcontroller.h'
--- src/modules/Unity/Application/applicationcontroller.h	2014-01-27 11:29:44 +0000
+++ src/modules/Unity/Application/applicationcontroller.h	2014-02-26 21:35:04 +0000
@@ -22,6 +22,9 @@
 #include <QString>
 #include <QStringList>
 
+namespace unitymir
+{
+
 class ApplicationController : public QObject
 {
     Q_OBJECT
@@ -57,4 +60,6 @@
     ApplicationController() = default;
 };
 
+} // namespace unitymir
+
 #endif // APPLICATION_CONTROLLER_H

=== modified file 'src/modules/Unity/Application/applicationscreenshotprovider.cpp'
--- src/modules/Unity/Application/applicationscreenshotprovider.cpp	2013-12-20 03:38:43 +0000
+++ src/modules/Unity/Application/applicationscreenshotprovider.cpp	2014-02-26 21:35:04 +0000
@@ -25,6 +25,9 @@
 // mir
 #include "mirserver/mir/shell/session.h"
 
+namespace unitymir
+{
+
 ApplicationScreenshotProvider::ApplicationScreenshotProvider(ApplicationManager *appManager)
     : QQuickImageProvider(QQuickImageProvider::Image)
     , m_appManager(appManager)
@@ -92,3 +95,5 @@
     mutex.unlock();
     return image;
 }
+
+} // namespace unitymir

=== modified file 'src/modules/Unity/Application/applicationscreenshotprovider.h'
--- src/modules/Unity/Application/applicationscreenshotprovider.h	2013-08-14 14:24:17 +0000
+++ src/modules/Unity/Application/applicationscreenshotprovider.h	2014-02-26 21:35:04 +0000
@@ -19,7 +19,10 @@
 
 #include <QQuickImageProvider>
 
+namespace unitymir
+{
 class ApplicationManager;
+
 class ApplicationScreenshotProvider : public QQuickImageProvider
 {
 public:
@@ -33,4 +36,6 @@
     int m_panelHeight;
 };
 
+} // namespace unitymir
+
 #endif // APPLICATIONSCREENSHOTPROVIDER_H

=== modified file 'src/modules/Unity/Application/dbuswindowstack.cpp'
--- src/modules/Unity/Application/dbuswindowstack.cpp	2013-10-09 09:02:23 +0000
+++ src/modules/Unity/Application/dbuswindowstack.cpp	2014-02-26 21:35:04 +0000
@@ -22,6 +22,9 @@
 #include <QDBusConnection>
 #include <QDBusMetaType>
 
+namespace unitymir
+{
+
 DBusWindowStack::DBusWindowStack(ApplicationManager *parent) : QObject(parent)
 {
     qRegisterMetaType<AppIdDesktopFile>();
@@ -110,3 +113,5 @@
 
     return a;
 }
+
+} // namespace unitymir

=== modified file 'src/modules/Unity/Application/dbuswindowstack.h'
--- src/modules/Unity/Application/dbuswindowstack.h	2014-01-09 08:40:51 +0000
+++ src/modules/Unity/Application/dbuswindowstack.h	2014-02-26 21:35:04 +0000
@@ -20,6 +20,9 @@
 #include <QObject>
 #include <QDBusArgument>
 
+namespace unitymir
+{
+
 class ApplicationManager;
 
 class AppIdDesktopFile
@@ -52,8 +55,8 @@
     explicit DBusWindowStack(ApplicationManager* parent);
     ~DBusWindowStack();
 
-    Q_INVOKABLE Q_SCRIPTABLE AppIdDesktopFile GetAppIdFromPid(unsigned int pid);
-    Q_INVOKABLE Q_SCRIPTABLE QList<WindowInfo> GetWindowStack();
+    Q_INVOKABLE Q_SCRIPTABLE unitymir::AppIdDesktopFile GetAppIdFromPid(unsigned int pid);
+    Q_INVOKABLE Q_SCRIPTABLE QList<unitymir::WindowInfo> GetWindowStack();
     Q_INVOKABLE Q_SCRIPTABLE QStringList GetWindowProperties(unsigned int window_id, const QString &app_id, const QStringList &names);
 
 signals:
@@ -62,7 +65,9 @@
     void WindowDestroyed(unsigned int window_id, const QString &app_id);
 };
 
-Q_DECLARE_METATYPE(AppIdDesktopFile)
-Q_DECLARE_METATYPE(WindowInfo)
+} // namespace unitymir
+
+Q_DECLARE_METATYPE(unitymir::AppIdDesktopFile)
+Q_DECLARE_METATYPE(unitymir::WindowInfo)
 
 #endif // DBUSWINDOWSTACK_H

=== modified file 'src/modules/Unity/Application/desktopfilereader.cpp'
--- src/modules/Unity/Application/desktopfilereader.cpp	2014-01-13 11:13:40 +0000
+++ src/modules/Unity/Application/desktopfilereader.cpp	2014-02-26 21:35:04 +0000
@@ -25,6 +25,9 @@
 #include <QDir>
 #include <QStandardPaths>
 
+namespace unitymir
+{
+
 DesktopFileReader::Factory::Factory()
 {
 }
@@ -187,3 +190,5 @@
         return false;
     }
 }
+
+} // namespace unitymir

=== modified file 'src/modules/Unity/Application/desktopfilereader.h'
--- src/modules/Unity/Application/desktopfilereader.h	2014-01-13 11:13:40 +0000
+++ src/modules/Unity/Application/desktopfilereader.h	2014-02-26 21:35:04 +0000
@@ -21,6 +21,9 @@
 #include <QVector>
 #include <QFileInfo>
 
+namespace unitymir
+{
+
 class DesktopFileReader {
 public:
     class Factory
@@ -72,4 +75,6 @@
     bool loaded_;
 };
 
+} // namespace unitymir
+
 #endif // DESKTOPFILEREADER_H

=== modified file 'src/modules/Unity/Application/inputarea.cpp'
--- src/modules/Unity/Application/inputarea.cpp	2013-11-26 08:56:08 +0000
+++ src/modules/Unity/Application/inputarea.cpp	2014-02-26 21:35:04 +0000
@@ -31,6 +31,9 @@
 #include "surfacefactory.h"
 #include "logging.h"
 
+namespace unitymir
+{
+
 InputArea::InputArea(QQuickItem *parent)
     : QQuickItem(parent)
     , m_enabled(true)
@@ -187,3 +190,5 @@
         m_surface->installInputArea(this);
     }
 }
+
+} // namespace unitymir

=== modified file 'src/modules/Unity/Application/inputarea.h'
--- src/modules/Unity/Application/inputarea.h	2013-11-26 08:56:08 +0000
+++ src/modules/Unity/Application/inputarea.h	2014-02-26 21:35:04 +0000
@@ -25,8 +25,12 @@
 // mir
 #include <mircommon/mir/geometry/rectangle.h>
 
+namespace mir { namespace shell { class Surface; }}
+
+namespace unitymir
+{
 class MirSurface;
-namespace mir { namespace shell { class Surface; }}
+
 class InputArea : public QQuickItem
 {
     Q_OBJECT
@@ -70,4 +74,6 @@
     friend class MirSurface;
 };
 
+} // namespace unitymir
+
 #endif // INPUTAREA_H

=== modified file 'src/modules/Unity/Application/inputfilterarea.cpp'
--- src/modules/Unity/Application/inputfilterarea.cpp	2013-08-29 14:46:43 +0000
+++ src/modules/Unity/Application/inputfilterarea.cpp	2014-02-26 21:35:04 +0000
@@ -23,6 +23,9 @@
 // Qt
 #include <QDebug>
 
+namespace unitymir
+{
+
 InputFilterArea::InputFilterArea(QQuickItem *parent) : InputArea(parent)
 {
     auto surface = MirSurfaceManager::singleton()->shellSurface();
@@ -56,3 +59,5 @@
 {
     setEnabled(enable);
 }
+
+} // namespace unitymir

=== modified file 'src/modules/Unity/Application/inputfilterarea.h'
--- src/modules/Unity/Application/inputfilterarea.h	2013-08-29 14:46:43 +0000
+++ src/modules/Unity/Application/inputfilterarea.h	2014-02-26 21:35:04 +0000
@@ -19,6 +19,8 @@
 
 #include "inputarea.h"
 
+namespace unitymir
+{
 class MirSurface;
 
 /*
@@ -50,4 +52,6 @@
     void setShellSurface(MirSurface *surface);
 };
 
+} // namespace unitymir
+
 #endif // INPUTFILTERAREA_H

=== modified file 'src/modules/Unity/Application/mirsurface.cpp'
--- src/modules/Unity/Application/mirsurface.cpp	2013-12-20 04:48:14 +0000
+++ src/modules/Unity/Application/mirsurface.cpp	2014-02-26 21:35:04 +0000
@@ -27,6 +27,9 @@
 
 namespace mg = mir::geometry;
 
+namespace unitymir
+{
+
 MirSurface::MirSurface(std::shared_ptr<mir::shell::Surface> surface, Application* application, QQuickItem *parent)
     : QQuickItem(parent)
     , m_surface(surface)
@@ -223,3 +226,4 @@
     }
 }
 
+} // namespace unitymir

=== modified file 'src/modules/Unity/Application/mirsurface.h'
--- src/modules/Unity/Application/mirsurface.h	2013-09-06 05:34:01 +0000
+++ src/modules/Unity/Application/mirsurface.h	2014-02-26 21:35:04 +0000
@@ -26,6 +26,9 @@
 #include <mir_toolkit/common.h>
 
 namespace mir { namespace geometry { struct Rectangle; }}
+
+namespace unitymir
+{
 class MirSurfaceManager;
 class InputArea;
 class Application;
@@ -127,6 +130,8 @@
     friend class InputArea;
 };
 
-Q_DECLARE_METATYPE(MirSurface*)
+} // namespace unitymir
+
+Q_DECLARE_METATYPE(unitymir::MirSurface*)
 
 #endif // MIRSURFACE_H

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.cpp'
--- src/modules/Unity/Application/mirsurfacemanager.cpp	2013-12-20 03:38:43 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.cpp	2014-02-26 21:35:04 +0000
@@ -36,6 +36,9 @@
 
 namespace msh = mir::shell;
 
+namespace unitymir
+{
+
 MirSurfaceManager *MirSurfaceManager::the_surface_manager = nullptr;
 
 MirSurfaceManager* MirSurfaceManager::singleton()
@@ -161,3 +164,5 @@
         }
     }
 }
+
+} // namespace unitymir

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.h'
--- src/modules/Unity/Application/mirsurfacemanager.h	2013-11-15 17:40:27 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.h	2014-02-26 21:35:04 +0000
@@ -29,8 +29,11 @@
 // local
 #include "mirsurface.h"
 
+namespace mir { namespace shell { class Surface; class Session; }}
 class ShellServerConfiguration;
-namespace mir { namespace shell { class Surface; class Session; }}
+
+namespace unitymir
+{
 
 class MirSurfaceManager : public QObject
 {
@@ -67,4 +70,6 @@
     static MirSurfaceManager *the_surface_manager;
 };
 
+} // namespace unitymir
+
 #endif // MIR_SURFACE_MANAGER_H

=== modified file 'src/modules/Unity/Application/plugin.cpp'
--- src/modules/Unity/Application/plugin.cpp	2013-11-19 16:42:52 +0000
+++ src/modules/Unity/Application/plugin.cpp	2014-02-26 21:35:04 +0000
@@ -36,14 +36,14 @@
     Q_UNUSED(scriptEngine);
     DLOG("applicationManagerSingleton (engine=%p, scriptEngine=%p)", engine, scriptEngine);
 
-    return ApplicationManager::singleton();
+    return unitymir::ApplicationManager::singleton();
 }
 
 static QObject* surfaceManagerSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {
     Q_UNUSED(engine);
     Q_UNUSED(scriptEngine);
     DLOG("surfaceManagerSingleton (engine=%p, scriptEngine=%p)", engine, scriptEngine);
-    return MirSurfaceManager::singleton();
+    return unitymir::MirSurfaceManager::singleton();
 }
 
 class UnityApplicationPlugin : public QQmlExtensionPlugin {
@@ -55,32 +55,34 @@
         DLOG("UnityApplicationPlugin::registerTypes (this=%p, uri='%s')", this, uri);
         ASSERT(QLatin1String(uri) == QLatin1String("Unity.Application"));
 
-        qRegisterMetaType<ApplicationManager*>("ApplicationManager*"); //need for queueing signals
+        qRegisterMetaType<unitymir::ApplicationManager*>("ApplicationManager*"); //need for queueing signals
 
         qmlRegisterUncreatableType<unity::shell::application::ApplicationManagerInterface>(
                     uri, 0, 1, "ApplicationManagerInterface", "Abstract interface. Cannot be created in QML");
-        qmlRegisterSingletonType<ApplicationManager>(
+        qmlRegisterSingletonType<unitymir::ApplicationManager>(
                     uri, 0, 1, "ApplicationManager", applicationManagerSingleton);
         qmlRegisterUncreatableType<unity::shell::application::ApplicationInfoInterface>(
                     uri, 0, 1, "ApplicationInfoInterface", "Abstract interface. Cannot be created in QML");
-        qmlRegisterUncreatableType<Application>(
+        qmlRegisterUncreatableType<unitymir::Application>(
                     uri, 0, 1, "ApplicationInfo", "ApplicationInfo can't be instantiated");
-        qmlRegisterSingletonType<MirSurfaceManager>(
+        qmlRegisterSingletonType<unitymir::MirSurfaceManager>(
                     uri, 0, 1, "SurfaceManager", surfaceManagerSingleton);
-        qmlRegisterUncreatableType<MirSurface>(
+        qmlRegisterUncreatableType<unitymir::MirSurface>(
                     uri, 0, 1, "MirSurface", "MirSurface can't be instantiated");
-        qmlRegisterType<InputArea>(uri, 0, 1, "InputArea");
-        qmlRegisterType<ShellInputArea>(uri, 0, 1, "ShellInputArea");
-        qmlRegisterType<InputFilterArea>(uri, 0, 1, "InputFilterArea");
-        qmlRegisterType<UbuntuKeyboardInfo>(uri, 0, 1, "UbuntuKeyboardInfo");
+        qmlRegisterType<unitymir::InputArea>(uri, 0, 1, "InputArea");
+        qmlRegisterType<unitymir::ShellInputArea>(uri, 0, 1, "ShellInputArea");
+        qmlRegisterType<unitymir::InputFilterArea>(uri, 0, 1, "InputFilterArea");
+        qmlRegisterType<unitymir::UbuntuKeyboardInfo>(uri, 0, 1, "UbuntuKeyboardInfo");
     }
 
     virtual void initializeEngine(QQmlEngine *engine, const char *uri)
     {
         QQmlExtensionPlugin::initializeEngine(engine, uri);
 
-        ApplicationManager* appManager = static_cast<ApplicationManager*>(applicationManagerSingleton(engine, NULL));
-        engine->addImageProvider(QLatin1String("screenshot"), new ApplicationScreenshotProvider(appManager));
+        unitymir::ApplicationManager* appManager =
+                static_cast<unitymir::ApplicationManager*>(applicationManagerSingleton(engine, NULL));
+        engine->addImageProvider(QLatin1String("screenshot"),
+                                 new unitymir::ApplicationScreenshotProvider(appManager));
     }
 };
 

=== added file 'src/modules/Unity/Application/proc_info.cpp'
--- src/modules/Unity/Application/proc_info.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/proc_info.cpp	2014-02-26 21:35:04 +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/>.
+ */
+
+#include "proc_info.h"
+
+#include <QFile>
+#include <QRegularExpression>
+
+namespace unitymir
+{
+
+ProcInfo::~ProcInfo() {
+}
+
+std::unique_ptr<ProcInfo::CommandLine> ProcInfo::command_line(quint64 pid) {
+    QFile cmdline(QString("/proc/%1/cmdline").arg(pid));
+    if (!cmdline.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        return nullptr;
+    }
+
+    return std::unique_ptr<CommandLine>(new CommandLine{ cmdline.readLine().replace('\0', ' ') });
+}
+QStringList ProcInfo::CommandLine::as_string_list() const {
+    return QString(command.data()).split(' ');
+}
+
+bool ProcInfo::CommandLine::starts_with(char const* prefix) const {
+    return command.startsWith(prefix);
+}
+
+boost::optional<QString> ProcInfo::CommandLine::get_parameter(const char* name) const {
+    QString pattern = QRegularExpression::escape(name) + "(\\S+)";
+    QRegularExpression regExp(pattern);
+    QRegularExpressionMatch regExpMatch = regExp.match(command);
+
+    if (!regExpMatch.hasMatch()) {
+        return boost::optional<QString>{};
+    }
+
+    return boost::optional<QString>{regExpMatch.captured(1)};
+}
+
+} // namespace unitymir

=== added file 'src/modules/Unity/Application/proc_info.h'
--- src/modules/Unity/Application/proc_info.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/proc_info.h	2014-02-26 21:35:04 +0000
@@ -0,0 +1,52 @@
+/*
+ * 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/>.
+ */
+
+// Process Information
+
+#ifndef PROC_INFO_H
+#define PROC_INFO_H
+
+#include <memory>
+
+#include <boost/optional.hpp>
+
+#include <QByteArray>
+#include <QStringList>
+
+class QString;
+
+namespace unitymir
+{
+
+class ProcInfo
+{
+public:
+    class CommandLine
+    {
+    public:
+        QByteArray command;
+
+        bool starts_with(const char* prefix) const;
+        boost::optional<QString> get_parameter(const char* name) const;
+        QStringList as_string_list() const;
+    };
+    virtual std::unique_ptr<CommandLine> command_line(quint64 pid);
+    virtual ~ProcInfo();
+};
+
+} // namespace unitymir
+
+#endif

=== modified file 'src/modules/Unity/Application/processcontroller.cpp'
--- src/modules/Unity/Application/processcontroller.cpp	2014-01-29 09:14:01 +0000
+++ src/modules/Unity/Application/processcontroller.cpp	2014-02-26 21:35:04 +0000
@@ -31,6 +31,9 @@
 
 namespace plpp = core::posix::linux::proc::process;
 
+namespace unitymir
+{
+
 ProcessController::OomController::OomController()
 {
 }
@@ -126,3 +129,5 @@
 {
     return -1 != kill(-pid, SIGCONT);
 }
+
+} // namespace unitymir

=== modified file 'src/modules/Unity/Application/processcontroller.h'
--- src/modules/Unity/Application/processcontroller.h	2014-01-29 09:14:01 +0000
+++ src/modules/Unity/Application/processcontroller.h	2014-02-26 21:35:04 +0000
@@ -22,6 +22,9 @@
 
 #include <sys/types.h>
 
+namespace unitymir
+{
+
 class ProcessController
 {
 public:
@@ -53,4 +56,6 @@
     QSharedPointer<OomController> m_oomController;
 };
 
+} // namespace unitymir
+
 #endif // PROCESS_CONTROLLER_H

=== modified file 'src/modules/Unity/Application/shellinputarea.cpp'
--- src/modules/Unity/Application/shellinputarea.cpp	2013-08-29 14:46:43 +0000
+++ src/modules/Unity/Application/shellinputarea.cpp	2014-02-26 21:35:04 +0000
@@ -23,6 +23,9 @@
 // Qt
 #include <QDebug>
 
+namespace unitymir
+{
+
 ShellInputArea::ShellInputArea(QQuickItem *parent) : InputArea(parent)
 {
     auto surface = MirSurfaceManager::singleton()->shellSurface();
@@ -43,3 +46,5 @@
 {
     doSetSurface(surface);
 }
+
+} // namespace unitymir

=== modified file 'src/modules/Unity/Application/shellinputarea.h'
--- src/modules/Unity/Application/shellinputarea.h	2013-08-29 14:46:43 +0000
+++ src/modules/Unity/Application/shellinputarea.h	2014-02-26 21:35:04 +0000
@@ -19,6 +19,8 @@
 
 #include "inputarea.h"
 
+namespace unitymir
+{
 class MirSurface;
 
 class ShellInputArea : public InputArea
@@ -34,4 +36,6 @@
     void setShellSurface(MirSurface *surface);
 };
 
+} // namespace unitymir
+
 #endif // SHELLINPUTAREA_H

=== modified file 'src/modules/Unity/Application/taskcontroller.cpp'
--- src/modules/Unity/Application/taskcontroller.cpp	2014-01-29 09:30:45 +0000
+++ src/modules/Unity/Application/taskcontroller.cpp	2014-02-26 21:35:04 +0000
@@ -41,7 +41,8 @@
 #include <signal.h>
 #include <unistd.h>
 
-
+namespace unitymir
+{
 
 TaskController::TaskController(
         QObject* parent,
@@ -183,3 +184,5 @@
     // Is this really the signal we want to emit?
     Q_EMIT requestResume(id);
 }
+
+} // namespace unitymir

=== modified file 'src/modules/Unity/Application/taskcontroller.h'
--- src/modules/Unity/Application/taskcontroller.h	2014-01-27 11:47:14 +0000
+++ src/modules/Unity/Application/taskcontroller.h	2014-02-26 21:35:04 +0000
@@ -25,6 +25,9 @@
 #include "applicationcontroller.h"
 #include "processcontroller.h"
 
+namespace unitymir
+{
+
 class TaskController : public QObject
 {
     Q_OBJECT
@@ -63,4 +66,6 @@
     QSharedPointer<ProcessController> m_processController;
 };
 
+} // namespace unitymir
+
 #endif // TASKCONTROLLER_H

=== modified file 'src/modules/Unity/Application/ubuntukeyboardinfo.cpp'
--- src/modules/Unity/Application/ubuntukeyboardinfo.cpp	2013-10-14 18:39:55 +0000
+++ src/modules/Unity/Application/ubuntukeyboardinfo.cpp	2014-02-26 21:35:04 +0000
@@ -24,6 +24,9 @@
     const char gServerName[] = "ubuntu-keyboard-info";
 }
 
+namespace unitymir
+{
+
 UbuntuKeyboardInfo::UbuntuKeyboardInfo(QObject *parent)
     : QObject(parent),
     m_consecutiveAttempts(0),
@@ -151,3 +154,5 @@
     }
 
 }
+
+} // namespace unitymir

=== modified file 'src/modules/Unity/Application/ubuntukeyboardinfo.h'
--- src/modules/Unity/Application/ubuntukeyboardinfo.h	2013-10-14 18:39:55 +0000
+++ src/modules/Unity/Application/ubuntukeyboardinfo.h	2014-02-26 21:35:04 +0000
@@ -20,6 +20,9 @@
 #include <QLocalSocket>
 #include <QTimer>
 
+namespace unitymir
+{
+
 // Temporary solution to get information about the onscreen keyboard
 // This shouldn't be needed once the OSK is a properly sized surface
 // instead of a fullscreen one.
@@ -75,4 +78,6 @@
     QString m_socketFilePath;
 };
 
+} // namespace unitymir
+
 #endif // UBUNTU_KEYBOARD_INFO_H

=== modified file 'src/modules/Unity/Application/upstart/applicationcontroller.cpp'
--- src/modules/Unity/Application/upstart/applicationcontroller.cpp	2014-01-30 06:59:33 +0000
+++ src/modules/Unity/Application/upstart/applicationcontroller.cpp	2014-02-26 21:35:04 +0000
@@ -25,7 +25,12 @@
     #include "upstart-app-launch.h"
 }
 
-struct upstart::ApplicationController::Private
+namespace unitymir
+{
+namespace upstart
+{
+
+struct ApplicationController::Private
 {
     upstart_app_launch_app_observer_t preStartCallback = nullptr;
     upstart_app_launch_app_observer_t startedCallback = nullptr;
@@ -35,32 +40,32 @@
     upstart_app_launch_app_failed_observer_t failureCallback = nullptr;
 };
 
-upstart::ApplicationController::ApplicationController()
-    : ::ApplicationController(),
+ApplicationController::ApplicationController()
+    : unitymir::ApplicationController(),
       impl(new Private())
 {
     impl->preStartCallback = [](const gchar * appId, gpointer userData) {
-        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        auto thiz = static_cast<ApplicationController*>(userData);
         Q_EMIT(thiz->applicationAboutToBeStarted(appId));
     };
 
     impl->startedCallback = [](const gchar * appId, gpointer userData) {
-        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        auto thiz = static_cast<ApplicationController*>(userData);
         Q_EMIT(thiz->applicationStarted(appId));
     };
 
     impl->stopCallback = [](const gchar * appId, gpointer userData) {
-        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        auto thiz = static_cast<ApplicationController*>(userData);
         Q_EMIT(thiz->applicationStopped(appId));
     };
 
     impl->focusCallback = [](const gchar * appId, gpointer userData) {
-        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        auto thiz = static_cast<ApplicationController*>(userData);
         Q_EMIT(thiz->applicationFocusRequest(appId));
     };
 
     impl->resumeCallback = [](const gchar * appId, gpointer userData) {
-        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        auto thiz = static_cast<ApplicationController*>(userData);
         Q_EMIT(thiz->applicationResumeRequest(appId));
     };
 
@@ -72,7 +77,7 @@
         case UPSTART_APP_LAUNCH_APP_FAILED_START_FAILURE: error = ApplicationController::Error::APPLICATION_FAILED_TO_START;
         }
 
-        auto thiz = static_cast<upstart::ApplicationController*>(userData);
+        auto thiz = static_cast<ApplicationController*>(userData);
         Q_EMIT(thiz->applicationError(appId, error));
     };
 
@@ -84,7 +89,7 @@
     upstart_app_launch_observer_add_app_failed(impl->failureCallback, this);
 }
 
-upstart::ApplicationController::~ApplicationController()
+ApplicationController::~ApplicationController()
 {
     upstart_app_launch_observer_delete_app_starting(impl->preStartCallback, this);
     upstart_app_launch_observer_delete_app_started(impl->startedCallback, this);
@@ -94,7 +99,7 @@
     upstart_app_launch_observer_delete_app_failed(impl->failureCallback, this);
 }
 
-pid_t upstart::ApplicationController::primaryPidForAppId(const QString& appId)
+pid_t 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));
@@ -102,19 +107,19 @@
     return pid;
 }
 
-bool upstart::ApplicationController::appIdHasProcessId(pid_t pid, const QString& appId)
+bool 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)
+bool 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));
+    DLOG_IF(!result, "ApplicationController::stopApplicationWithAppId appId='%s' FAILED", qPrintable(appId));
     return result;
 }
 
-bool upstart::ApplicationController::startApplicationWithAppIdAndArgs(const QString& appId, const QStringList& arguments)
+bool 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());
@@ -129,6 +134,9 @@
 
     g_free(upstartArgs);
 
-    DLOG_IF(!result, "upstart::Application::Controller::startApplicationWithAppIdAndArgs appId='%s' FAILED", qPrintable(appId));
+    DLOG_IF(!result, "Application::Controller::startApplicationWithAppIdAndArgs appId='%s' FAILED", qPrintable(appId));
     return result;
 }
+
+} // namespace upstart
+} // namespace unitymir

=== modified file 'src/modules/Unity/Application/upstart/applicationcontroller.h'
--- src/modules/Unity/Application/upstart/applicationcontroller.h	2014-01-27 11:29:44 +0000
+++ src/modules/Unity/Application/upstart/applicationcontroller.h	2014-02-26 21:35:04 +0000
@@ -20,9 +20,12 @@
 
 #include "../applicationcontroller.h"
 
+namespace unitymir
+{
 namespace upstart
 {
-class ApplicationController : public ::ApplicationController
+
+class ApplicationController : public unitymir::ApplicationController
 {
 public:
     ApplicationController();
@@ -38,6 +41,8 @@
     struct Private;
     QScopedPointer<Private> impl;
 };
-}
+
+} // namespace upstart
+} // namespace unitymir
 
 #endif // UPSTART_APPLICATION_CONTROLLER_H

=== modified file 'src/unity-mir/CMakeLists.txt'
--- src/unity-mir/CMakeLists.txt	2014-02-07 16:10:12 +0000
+++ src/unity-mir/CMakeLists.txt	2014-02-26 21:35:04 +0000
@@ -74,12 +74,10 @@
 
   ${CMAKE_THREAD_LIBS_INIT}
 
-  ${UBUNTU_PLATFORM_API_LIBRARIES}
-  ${MIRCOMMON_LIBRARIES}
-  ${MIRSERVER_LIBRARIES}
+  ${UBUNTU_PLATFORM_API_LDFLAGS}
+  ${MIRSERVER_LDFLAGS}
   ${PROTOBUF_LIBRARIES}
-
-  boost_system
+  ${Boost_SYSTEM_LIBRARY_RELEASE}
 
   ubuntu_application_api_mirserver)
 

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-01-27 11:29:44 +0000
+++ tests/CMakeLists.txt	2014-02-26 21:35:04 +0000
@@ -20,6 +20,7 @@
   ${CMAKE_SOURCE_DIR}/src/modules
   ${GMOCK_INCLUDE_DIR}
   ${GTEST_INCLUDE_DIR}
+  ${MIRSERVER_INCLUDE_DIRS}
 )
 
 add_executable(

=== modified file 'tests/application_manager_test.cpp'
--- tests/application_manager_test.cpp	2014-01-27 11:29:44 +0000
+++ tests/application_manager_test.cpp	2014-02-26 21:35:04 +0000
@@ -19,6 +19,7 @@
 
 #include <Unity/Application/applicationcontroller.h>
 #include <Unity/Application/taskcontroller.h>
+#include <Unity/Application/proc_info.h>
 
 #include <core/posix/linux/proc/process/oom_score_adj.h>
 
@@ -29,43 +30,55 @@
 #include "mock_desktop_file_reader.h"
 #include "mock_oom_controller.h"
 #include "mock_process_controller.h"
-
-TEST(ApplicationManager, SuspendingAndResumingARunningApplicationResultsInOomScoreAdjustment)
+#include "mock_proc_info.h"
+#include "mock_session.h"
+#include "mock_focus_controller.h"
+
+using namespace unitymir;
+
+class ApplicationManagerTests : public ::testing::Test
 {
-    using namespace ::testing;
-
-    const QString appId("com.canonical.does.not.exist");
-
-    NiceMock<testing::MockOomController> oomController;
-    QSharedPointer<ProcessController::OomController> oomControllerPtr(
+public:
+    ApplicationManagerTests()
+        : processController{
+            QSharedPointer<ProcessController::OomController> (
                 &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(
+                [](ProcessController::OomController*){})
+        },
+        applicationManager{
+            QSharedPointer<TaskController>{
                 new TaskController(
                     nullptr,
-                    appControllerPtr,
-                    processControllerPtr
-                    ));
-
-    NiceMock<MockDesktopFileReaderFactory> desktopFileReaderFactory;
-    QSharedPointer<DesktopFileReader::Factory> desktopFileReaderFactoryPtr(
+                    QSharedPointer<ApplicationController>(
+                        &appController,
+                        [](ApplicationController*){}),
+                    QSharedPointer<ProcessController>(
+                        &processController,
+                        [](ProcessController*){})
+                    )},
+            QSharedPointer<DesktopFileReader::Factory>(
                 &desktopFileReaderFactory,
-                [](DesktopFileReader::Factory*){});
-
-    ApplicationManager applicationManager(
-                taskController,
-                desktopFileReaderFactoryPtr);
+                [](DesktopFileReader::Factory*){}),
+            QSharedPointer<ProcInfo>(&procInfo,[](ProcInfo *){}),
+            std::shared_ptr<mir::shell::FocusController>(&focusController, [](void*){}),
+            QSize(400,400)
+        }
+    {
+    }
+    testing::NiceMock<testing::MockOomController> oomController;
+    testing::NiceMock<testing::MockProcessController> processController;
+    testing::NiceMock<testing::MockApplicationController> appController;
+    testing::NiceMock<testing::MockProcInfo> procInfo;
+    testing::NiceMock<testing::MockDesktopFileReaderFactory> desktopFileReaderFactory;
+    testing::NiceMock<testing::MockFocusController> focusController;
+    ApplicationManager applicationManager;
+};
+
+TEST_F(ApplicationManagerTests, SuspendingAndResumingARunningApplicationResultsInOomScoreAdjustment)
+{
+    using namespace ::testing;
+
+    const QString appId("com.canonical.does.not.exist");
 
     EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(_, _)).Times(1);
 
@@ -86,43 +99,12 @@
 }
 
 // Currently disabled as we need to make sure that we have a corresponding mir session, too.
-TEST(ApplicationManager, DISABLED_FocusingRunningApplicationResultsInOomScoreAdjustment)
+TEST_F(ApplicationManagerTests, 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++)
@@ -135,6 +117,9 @@
                     ApplicationManager::NoFlag,
                     QStringList());
 
+        std::shared_ptr<mir::shell::Session> mirSession = std::make_shared<MockSession>(appIdFormat.toStdString(), i);
+        applicationManager.onSessionStarting( mirSession );
+
         EXPECT_NE(nullptr, application);
 
         appIds.insert(appId);
@@ -149,3 +134,92 @@
         applicationManager.focusApplication(appId);
     }
 }
+
+
+TEST_F(ApplicationManagerTests,bug_case_1240400_second_dialer_app_fails_to_authorize_and_gets_mixed_up_with_first_one)
+{
+    using namespace ::testing;
+    std::shared_ptr<mir::shell::Surface> aSurface(nullptr);
+    quint64 firstProcId = 5921;
+    quint64 secondProcId = 5922;
+    const char dialer_app_id[] = "dialer-app";
+    QByteArray cmdLine( "/usr/bin/dialer-app --desktop_file_hint=dialer-app");
+    QByteArray secondcmdLine( "/usr/bin/dialer-app");
+
+    EXPECT_CALL(procInfo,command_line_(firstProcId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+    EXPECT_CALL(procInfo,command_line_(secondProcId))
+        .Times(1)
+        .WillOnce(Return(secondcmdLine));
+
+    bool authed = true;
+
+    std::shared_ptr<mir::shell::Session> mirSession = std::make_shared<MockSession>(dialer_app_id, firstProcId);
+    applicationManager.authorizeSession(firstProcId, authed);
+    EXPECT_EQ(true, authed);
+    applicationManager.onSessionStarting(mirSession);
+    applicationManager.onSessionCreatedSurface(mirSession.get(),aSurface);
+    Application * app = applicationManager.findApplication(dialer_app_id);
+    EXPECT_NE(nullptr,app);
+
+    // now a second session without desktop file is launched:
+    applicationManager.authorizeSession(secondProcId, authed);
+    applicationManager.onProcessStartReportReceived(dialer_app_id, true);
+
+    EXPECT_EQ(false,authed);
+    EXPECT_EQ(app,applicationManager.findApplication(dialer_app_id));
+    EXPECT_EQ(QString(dialer_app_id),applicationManager.focusedApplicationId());
+}
+
+TEST_F(ApplicationManagerTests,application_dies_while_starting)
+{
+    using namespace ::testing;
+    quint64 procId = 5921;
+    const char app_id[] = "my-app";
+    QByteArray cmdLine( "/usr/bin/my-app --desktop_file_hint=my-app");
+
+    EXPECT_CALL(procInfo,command_line_(procId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    bool authed = true;
+
+    std::shared_ptr<mir::shell::Session> mirSession = std::make_shared<MockSession>(app_id, procId);
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(mirSession);
+    Application * beforeFailure = applicationManager.findApplication(app_id);
+    applicationManager.onProcessStartReportReceived(app_id,true);
+    Application * afterFailure = applicationManager.findApplication(app_id);
+
+    EXPECT_EQ(true, authed);
+    EXPECT_NE(nullptr, beforeFailure);
+    EXPECT_EQ(nullptr, afterFailure);
+}
+
+TEST_F(ApplicationManagerTests,application_start_failure_after_starting)
+{
+    using namespace ::testing;
+    quint64 procId = 5921;
+    std::shared_ptr<mir::shell::Surface> aSurface(nullptr);
+    const char app_id[] = "my-app";
+    QByteArray cmdLine( "/usr/bin/my-app --desktop_file_hint=my-app");
+
+    EXPECT_CALL(procInfo,command_line_(procId))
+        .Times(1)
+        .WillOnce(Return(cmdLine));
+
+    bool authed = true;
+
+    std::shared_ptr<mir::shell::Session> mirSession = std::make_shared<MockSession>(app_id, procId);
+    applicationManager.authorizeSession(procId, authed);
+    applicationManager.onSessionStarting(mirSession);
+    Application * beforeFailure = applicationManager.findApplication(app_id);
+    applicationManager.onSessionCreatedSurface(mirSession.get(), aSurface);
+    applicationManager.onProcessStartReportReceived(app_id, true);
+    Application * afterFailure = applicationManager.findApplication(app_id);
+
+    EXPECT_EQ(true, authed);
+    EXPECT_NE(nullptr, beforeFailure);
+    EXPECT_EQ(beforeFailure, afterFailure);
+}

=== modified file 'tests/auto/modules/Unity/Application/CMakeLists.txt'
--- tests/auto/modules/Unity/Application/CMakeLists.txt	2014-01-27 11:29:44 +0000
+++ tests/auto/modules/Unity/Application/CMakeLists.txt	2014-02-26 21:35:04 +0000
@@ -19,8 +19,8 @@
     unity-mir
     unityapplicationplugin
 
-    ${MIRSERVER_LIBRARIES}
-    ${UPSTART_APP_LAUNCH_LIBRARIES})
+    ${MIRSERVER_LDFLAGS}
+    ${UPSTART_APP_LAUNCH_LDFLAGS})
 
 install(
     TARGETS unity-mir-test-app

=== modified file 'tests/auto/modules/Unity/Application/main.cpp'
--- tests/auto/modules/Unity/Application/main.cpp	2014-01-27 11:29:44 +0000
+++ tests/auto/modules/Unity/Application/main.cpp	2014-02-26 21:35:04 +0000
@@ -18,6 +18,7 @@
 
 #include "application_manager.h"
 #include "processcontroller.h"
+#include "proc_info.h"
 #include "taskcontroller.h"
 #include "upstart/applicationcontroller.h"
 
@@ -26,6 +27,8 @@
 
 #include <signal.h>
 
+using namespace unitymir;
+
 static QString pidCommandLine(qint64 pid)
 {
     QFile cmdline(QString("/proc/%1/cmdline").arg(pid));
@@ -44,12 +47,10 @@
 
 void ApplicationManagerTests::testStartStop()
 {
-    QSharedPointer<upstart::ApplicationController> appController(new upstart::ApplicationController());
-    QSharedPointer<TaskController> taskController(new TaskController(nullptr, appController));
-    QSharedPointer<DesktopFileReader::Factory> fileReaderFactory(new DesktopFileReader::Factory());
+    ApplicationManager::Factory appFactory;
+    QSharedPointer<ApplicationManager> manager{appFactory.create()};
 
-    ApplicationManager manager(taskController, fileReaderFactory);
-    Application *app = manager.startApplication("unity-mir-test-helper-app", QStringList());
+    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"));
     QCOMPARE(app->name(), QString("My Fake App"));
@@ -61,7 +62,7 @@
     QString simplifiedCommand = pidCommandLine(app->pid());
     QCOMPARE(simplifiedCommand, QString("unity-mir-test-helper-app"));
 
-    manager.stopApplication(app->appId());
+    manager->stopApplication(app->appId());
 
     QDir d;
     QTRY_VERIFY(!d.exists(QString("/proc/%1").arg(app->pid())));

=== modified file 'tests/mock_application_controller.h'
--- tests/mock_application_controller.h	2014-01-27 11:29:44 +0000
+++ tests/mock_application_controller.h	2014-02-26 21:35:04 +0000
@@ -26,7 +26,7 @@
 
 namespace testing
 {
-struct MockApplicationController : public ApplicationController
+struct MockApplicationController : public unitymir::ApplicationController
 {
     MOCK_METHOD1(primaryPidForAppId, pid_t(const QString& appId));
     MOCK_METHOD2(appIdHasProcessId, bool(pid_t, const QString&));

=== modified file 'tests/mock_desktop_file_reader.h'
--- tests/mock_desktop_file_reader.h	2014-01-23 11:30:52 +0000
+++ tests/mock_desktop_file_reader.h	2014-02-26 21:35:04 +0000
@@ -24,10 +24,10 @@
 
 namespace testing
 {
-struct MockDesktopFileReader : public DesktopFileReader
+struct MockDesktopFileReader : public unitymir::DesktopFileReader
 {
     MockDesktopFileReader(const QString& appId)
-        : DesktopFileReader(appId)
+        : unitymir::DesktopFileReader(appId)
     {
         using namespace ::testing;
 
@@ -122,7 +122,7 @@
     }
 };
 
-struct MockDesktopFileReaderFactory : public DesktopFileReader::Factory
+struct MockDesktopFileReaderFactory : public unitymir::DesktopFileReader::Factory
 {
     MockDesktopFileReaderFactory()
     {
@@ -139,7 +139,7 @@
                         &MockDesktopFileReaderFactory::doCreateInstanceForDesktopFile));
     }
 
-    virtual DesktopFileReader* doCreateInstanceForAppId(const QString& appId)
+    virtual unitymir::DesktopFileReader* doCreateInstanceForAppId(const QString& appId)
     {
         using namespace ::testing;
         auto instance = new NiceMock<MockDesktopFileReader>(appId);
@@ -148,7 +148,7 @@
         return instance;
     }
 
-    virtual DesktopFileReader* doCreateInstanceForDesktopFile(const QFileInfo& fi)
+    virtual unitymir::DesktopFileReader* doCreateInstanceForDesktopFile(const QFileInfo& fi)
     {
         using namespace ::testing;
         auto instance = new NiceMock<MockDesktopFileReader>(fi);
@@ -157,8 +157,8 @@
         return instance;
     }
 
-    MOCK_METHOD1(createInstanceForAppId, DesktopFileReader*(const QString&));
-    MOCK_METHOD1(createInstanceForDesktopFile, DesktopFileReader*(const QFileInfo&));
+    MOCK_METHOD1(createInstanceForAppId, unitymir::DesktopFileReader*(const QString&));
+    MOCK_METHOD1(createInstanceForDesktopFile, unitymir::DesktopFileReader*(const QFileInfo&));
 };
 }
 

=== added file 'tests/mock_focus_controller.h'
--- tests/mock_focus_controller.h	1970-01-01 00:00:00 +0000
+++ tests/mock_focus_controller.h	2014-02-26 21:35:04 +0000
@@ -0,0 +1,37 @@
+/*
+ * 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 MOCK_MIR_SHELL_FOCUS_CONTROLLER_H
+#define MOCK_MIR_SHELL_FOCUS_CONTROLLER_H
+
+#include <mir/shell/focus_controller.h>
+#include <gmock/gmock.h>
+
+#include <string>
+
+namespace testing
+{
+class MockFocusController : public mir::shell::FocusController
+{
+public:
+    MOCK_METHOD0(focus_next, void());
+    MOCK_CONST_METHOD0(focussed_application, std::weak_ptr<mir::shell::Session>());
+    MOCK_METHOD1(set_focus_to, void(std::shared_ptr<mir::shell::Session>const&));
+};
+}
+
+#endif // MOCK_MIR_SHELL_FOCUS_CONTROLLER_H_

=== modified file 'tests/mock_oom_controller.h'
--- tests/mock_oom_controller.h	2014-01-27 11:29:44 +0000
+++ tests/mock_oom_controller.h	2014-02-26 21:35:04 +0000
@@ -23,7 +23,7 @@
 
 namespace testing
 {
-struct MockOomController : public ProcessController::OomController
+struct MockOomController : public unitymir::ProcessController::OomController
 {
     MOCK_METHOD1(ensureProcessLikelyToBeKilled, void(pid_t));
     MOCK_METHOD1(ensureProcessUnlikelyToBeKilled, void(pid_t));

=== added file 'tests/mock_proc_info.h'
--- tests/mock_proc_info.h	1970-01-01 00:00:00 +0000
+++ tests/mock_proc_info.h	2014-02-26 21:35:04 +0000
@@ -0,0 +1,37 @@
+/*
+ * 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 MOCK_PROC_INFO_H
+#define MOCK_PROC_INFO_H
+
+#include <Unity/Application/proc_info.h>
+
+#include <gmock/gmock.h>
+
+namespace testing
+{
+struct MockProcInfo : public unitymir::ProcInfo
+{
+    MOCK_METHOD1(command_line_, QByteArray(quint64));
+    std::unique_ptr<CommandLine> command_line(quint64 pid)
+    {
+      return std::unique_ptr<CommandLine>(new CommandLine{command_line_(pid)});
+    }
+};
+}
+
+#endif // MOCK_OOM_CONTROLLER_H

=== modified file 'tests/mock_process_controller.h'
--- tests/mock_process_controller.h	2014-01-27 11:29:44 +0000
+++ tests/mock_process_controller.h	2014-02-26 21:35:04 +0000
@@ -23,14 +23,14 @@
 
 namespace testing
 {
-struct MockProcessController : public ProcessController
+struct MockProcessController : public unitymir::ProcessController
 {
-    MockProcessController(const QSharedPointer<ProcessController::OomController>& oomController)
+    MockProcessController(const QSharedPointer<unitymir::ProcessController::OomController>& oomController)
         : m_oomController(oomController)
     {
     }
 
-    const QSharedPointer<OomController>& oomController() const
+    const QSharedPointer<unitymir::ProcessController::OomController>& oomController() const
     {
         return m_oomController;
     }
@@ -38,7 +38,7 @@
     MOCK_CONST_METHOD1(sigStopProcessGroupForPid, bool(pid_t));
     MOCK_CONST_METHOD1(sigContinueProcessGroupForPid, bool(pid_t));
 
-    QSharedPointer<ProcessController::OomController> m_oomController;
+    QSharedPointer<unitymir::ProcessController::OomController> m_oomController;
 };
 }
 

=== added file 'tests/mock_session.h'
--- tests/mock_session.h	1970-01-01 00:00:00 +0000
+++ tests/mock_session.h	2014-02-26 21:35:04 +0000
@@ -0,0 +1,69 @@
+/*
+ * 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 MOCK_MIR_SHELL_SESSION_H
+#define MOCK_MIR_SHELL_SESSION_H
+
+#include <mir/shell/session.h>
+#include <mir/graphics/display_configuration.h>
+#include <mir/shell/surface_creation_parameters.h>
+#include <gmock/gmock.h>
+
+#include <string>
+
+namespace testing
+{
+struct MockSession : public mir::shell::Session
+{
+    MockSession() {}
+    MockSession(std::string const& sessionName, pid_t processId) 
+        : m_sessionName(sessionName), m_sessionId(processId)
+    {}
+
+    std::string name() const override
+    {
+        return m_sessionName;
+    }
+
+    pid_t process_id() const override
+    {
+        return m_sessionId;
+    }
+
+    typedef mir::frontend::SurfaceId SurfaceId;
+
+    MOCK_METHOD0(force_requests_to_complete, void());
+
+    MOCK_CONST_METHOD0(default_surface, std::shared_ptr<mir::shell::Surface>());
+    MOCK_CONST_METHOD1(get_surface, std::shared_ptr<mir::frontend::Surface>(SurfaceId));
+
+    MOCK_METHOD1(take_snapshot, void(mir::shell::SnapshotCallback const&));
+    MOCK_METHOD1(set_lifecycle_state, void(MirLifecycleState));
+    MOCK_METHOD1(create_surface, SurfaceId(mir::shell::SurfaceCreationParameters const&));
+    MOCK_METHOD1(destroy_surface, void (SurfaceId));
+
+    MOCK_METHOD0(hide, void());
+    MOCK_METHOD0(show, void());
+    MOCK_METHOD1(send_display_config, void(mir::graphics::DisplayConfiguration const&));
+    MOCK_METHOD3(configure_surface, int(SurfaceId, MirSurfaceAttrib, int));
+private:
+    std::string m_sessionName;
+    pid_t m_sessionId;
+};
+}
+
+#endif // MOCK_MIR_SHELL_SESSION_H

=== modified file 'tests/taskcontroller_test.cpp'
--- tests/taskcontroller_test.cpp	2014-01-27 08:01:40 +0000
+++ tests/taskcontroller_test.cpp	2014-02-26 21:35:04 +0000
@@ -28,6 +28,7 @@
 
 namespace
 {
+using namespace unitymir;
 
 struct TriggerableApplicationController : public ApplicationController
 {