Merge lp:~andreas-pokorny/unity-mir/fix-1240400 into lp:unity-mir

[Andreas Pokorny]

Bugfix for unity-mir crash when multiple application instances with the same appId get started & stopped.

This change also introduces further mocks for mir and unity-mir classes and a refactored ApplicationManager. The log traces where extended with more information on the touched application objects.

Bugfix for unity-mir crash when multiple application instances with the same appId get started & stopped.

This change solves the issue to some degree - but cannot solve it entirely - since there is no API yet to get something like an instance id. So closing one application may still close the wrong application.

ApplicationManager had to be refactored. The constructor no longer accesses the QApplication object or connects itself to all the signal sources. This is now encapsulated into a factory class, which also reduces the dependency on mir structures to the FocusController.

[lp:~andreas-pokorny/unity-mir/fix-1240400]

181. By Alberto Aguirre on 2014-02-21

[cmake] Use XXX_LDFLAGS for libraries found with pkg_check_modules.

Using the pkg given LDFLAGS resolves linking issues when cross-compiling

182. By Alberto Aguirre on 2014-02-21

Add dev scripts to support cross-compilation

These scripts are adapted from the mir project.
The build dependencies are parsed from debian/control and
given to debootstrap to setup a basic armhf chroot environment for cross-compilation.

These scripts are intended for development purposes only

183. By Andreas Pokorny on 2014-02-26

more log traces

184. By Andreas Pokorny on 2014-02-26

Adding Proc Info and Mock and a Mir Session Mock for unit testing

185. By Andreas Pokorny on 2014-02-26

Fixes Unity8 crash when two instances of the same application are launched
and the second one stops.

There is still misbehavior that cannot be resolved without further changes in
upstart-app-launch. I.e. when the second instance is shutdown the existing one
will be closed too, since they use the same appId.

The changes in the construction of ApplicationManager where neceessary to
replace the external parts of ApplicationManager with mock objects.

186. By Andreas Pokorny on 2014-02-26

review findings address

187. By Andreas Pokorny on 2014-02-28

Code style changes were not reflected in MockProcInfo

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-02-14 15:42:49 +0000
+++ CMakeLists.txt	2014-02-19 21:10:08 +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-19 21:10:08 +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-19 21:10:08 +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-19 21:10:08 +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-19 21:10:08 +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-19 21:10:08 +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-19 21:10:08 +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-19 21:10:08 +0000
@@ -52,7 +52,7 @@
 
 Application::~Application()
 {
-    DLOG("Application::~Application");
+    DLOG("Application::~Application (this=%p)", this);
     delete m_desktopData;
 }
 

=== 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-19 21:10:08 +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,130 @@
 
 using namespace unity::shell::application;
 
-ApplicationManager *ApplicationManager::the_application_manager = nullptr;
+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 +184,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 +282,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 +293,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 +317,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 +336,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 +355,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 +391,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 +411,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 +442,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 +472,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 +502,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 +530,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 +542,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 +594,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 +612,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 +639,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 +662,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 +675,7 @@
             application->setSession(nullptr);
             m_dbusWindowStack->WindowDestroyed(0, application->appId());
             if (application != m_focusedApplication) {
-	            removeApplication = false;
+                removeApplication = false;
             }
         }
 
@@ -626,8 +697,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 +720,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 +754,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 +840,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 +879,14 @@
 
     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;
+}

=== 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-19 21:10:08 +0000
@@ -38,6 +38,7 @@
 class DBusWindowStack;
 class MirSurfaceManager;
 class TaskController;
+class ProcInfo;
 
 namespace mir {
     namespace geometry {
@@ -46,6 +47,7 @@
     namespace shell {
         class Session;
         class Surface;
+        class FocusController;
     }
 }
 
@@ -55,6 +57,11 @@
     Q_FLAGS(ExecFlags)
 
 public:
+    class Factory
+    {
+    public:
+        QSharedPointer<ApplicationManager> create();
+    };
     // Mapping enums to Ubuntu Platform API enums.
     enum Flag {
         NoFlag = 0x0,
@@ -66,6 +73,9 @@
 
     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();
 
@@ -122,6 +132,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 +143,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;

=== 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-19 21:10:08 +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/>.
+ */
+
+#include "proc_info.h"
+
+#include <QFile>
+#include <QRegularExpression>
+
+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)};
+}
+

=== 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-19 21:10:08 +0000
@@ -0,0 +1,48 @@
+/*
+ * 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;
+
+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();
+};
+
+#endif
+

=== 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-19 21:10:08 +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-19 21:10:08 +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-19 21:10:08 +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,54 @@
 #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"
+
+
+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 +98,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 +116,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 +133,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-19 21:10:08 +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-19 21:10:08 +0000
@@ -18,6 +18,7 @@
 
 #include "application_manager.h"
 #include "processcontroller.h"
+#include "proc_info.h"
 #include "taskcontroller.h"
 #include "upstart/applicationcontroller.h"
 
@@ -44,12 +45,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 +60,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())));

=== 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-19 21:10:08 +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_

=== 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-19 21:10:08 +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 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

=== added file 'tests/mock_session.h'
--- tests/mock_session.h	1970-01-01 00:00:00 +0000
+++ tests/mock_session.h	2014-02-19 21:10:08 +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