Merge lp:~mzanetti/unity-mir/appimage-sourcesize-rotate-n7 into lp:unity-mir

[Michael Zanetti]

export AppImage's sourceSize

[lp:~mzanetti/unity-mir/appimage-sourcesize-rotate-n7]

180. By Michael Zanetti on 2014-02-21

merge upstream

181. By Michael Zanetti on 2014-02-21

keep the aspect ratio also when cropping

Unmerged revisions

181. By Michael Zanetti on 2014-02-21

keep the aspect ratio also when cropping

180. By Michael Zanetti on 2014-02-21

merge upstream

179. By Michael Zanetti on 2014-02-21

export ApplicationImage's sourceSize

178. By Gerry Boland on 2014-02-19

Fix for OSK on Manta

177. By Gerry Boland on 2014-02-19

Hacky fix for InputArea positioning with a rotated shell

176. By Gerry Boland on 2014-02-19

Fix OSK positioning on manta & flo

175. By Gerry Boland on 2014-02-13

Merge trunk

174. By Daniel d'Andrada on 2014-02-13

ApplicationImage - rotate image to compensate for shell rotation

173. By Daniel d'Andrada on 2014-02-11

Take app window placement information from given QQuickItems

Benefits:
 - no more hardcoded values (like panel height)
 - supports unity shell in any rotation

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-02-14 15:42:49 +0000
+++ CMakeLists.txt	2014-02-21 16:48:46 +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-21 16:48:46 +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-21 16:48:46 +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-21 16:48:46 +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-21 16:48:46 +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-21 16:48:46 +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/ApplicationImage.qml'
--- src/modules/Unity/Application/ApplicationImage.qml	2013-10-01 17:45:26 +0000
+++ src/modules/Unity/Application/ApplicationImage.qml	2014-02-21 16:48:46 +0000
@@ -15,11 +15,14 @@
  */
 
 import QtQuick 2.0
+import QtQuick.Window 2.0
+import Ubuntu.Components 0.1
 
 Item {
     id: root
     property var source: null
     readonly property bool ready: source && (image.status == Image.Ready)
+    property var sourceSize: orientationHelper.orientationAngle == 0 ? image.sourceSize : Qt.size(image.sourceSize.height, image.sourceSize.width)
 
     function scheduleUpdate() {
         image.source = "";
@@ -34,10 +37,14 @@
         scheduleUpdate();
     }
 
-    Image {
-        id: image
-        anchors.fill: parent
-        source: (root.source) ? "image://screenshot/" + root.source.appId : ""
-        cache: false
+    OrientationHelper {
+        orientationAngle: Screen.angleBetween(Screen.primaryOrientation, nativeOrientation) // compensate for Shell rotation
+        transitionEnabled: false
+        Image {
+            id: image
+            anchors.fill: parent
+            source: (root.source) ? "image://screenshot/" + root.source.appId : ""
+            cache: false
+        }
     }
 }

=== 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-21 16:48:46 +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-21 16:48:46 +0000
@@ -40,6 +40,7 @@
     , m_state(state)
     , m_focused(false)
     , m_fullscreen(false)
+    , m_visible(false)
     , m_arguments(arguments)
     , m_suspendTimer(new QTimer(this))
 {
@@ -52,7 +53,7 @@
 
 Application::~Application()
 {
-    DLOG("Application::~Application");
+    DLOG("Application::~Application (this=%p)", this);
     delete m_desktopData;
 }
 
@@ -125,6 +126,11 @@
     return m_session;
 }
 
+bool Application::visible() const
+{
+    return m_visible;
+}
+
 pid_t Application::pid() const
 {
     return m_pid;
@@ -141,6 +147,7 @@
 
     // TODO(greyback) what if called with new surface?
     m_session = session;
+    m_visible = true; // bit of an assumption that, but no other way to deduce an actual Surface has been created
 }
 
 void Application::setSessionName(const QString& name)
@@ -216,6 +223,21 @@
     }
 }
 
+void Application::setVisible(const bool visible)
+{
+    DLOG("Application::setVisible (this=%p, visible=%s)", this, visible ? "yes" : "no");
+    // FIXME: this is bad, as should a MirSurface of this app exist, it won't be notified of the visiblity change.
+    if (visible != m_visible) {
+        if (visible) {
+            m_session->show();
+        } else {
+            m_session->hide();
+        }
+        m_visible = visible;
+        Q_EMIT visibleChanged();
+    }
+}
+
 void Application::suspend()
 {
     DLOG("Application::suspend (this=%p)", this);

=== 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-21 16:48:46 +0000
@@ -38,6 +38,7 @@
     Q_PROPERTY(QString desktopFile READ desktopFile CONSTANT)
     Q_PROPERTY(QString exec READ exec CONSTANT)
     Q_PROPERTY(bool fullscreen READ fullscreen NOTIFY fullscreenChanged)
+    Q_PROPERTY(bool visible READ visible WRITE setVisible NOTIFY visibleChanged)
     Q_PROPERTY(Stage stage READ stage WRITE setStage NOTIFY stageChanged)
 
 public:
@@ -57,7 +58,10 @@
     State state() const override;
     bool focused() const override;
 
+    bool visible() const;
+
     void setStage(Stage stage);
+    void setVisible(const bool);
 
     bool isValid() const;
     QString desktopFile() const;
@@ -74,6 +78,7 @@
 Q_SIGNALS:
     void fullscreenChanged();
     void stageChanged(Stage stage);
+    void visibleChanged();
 
 private:
     void setPid(pid_t pid);
@@ -90,6 +95,7 @@
     State m_state;
     bool m_focused;
     bool m_fullscreen;
+    bool m_visible; // duplicating internal Mir data :(
     std::shared_ptr<mir::shell::Session> m_session;
     QString m_sessionName;
     QStringList m_arguments;

=== 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-21 16:48:46 +0000
@@ -16,6 +16,7 @@
 
 // local
 #include "application_manager.h"
+#include "proc_info.h"
 #include "application.h"
 #include "desktopfilereader.h"
 #include "dbuswindowstack.h"
@@ -44,33 +45,134 @@
 // Qt
 #include <QCoreApplication>
 
-// Default element sizes
-#define SIDE_STAGE_WIDTH_GU 40
-
 namespace msh = mir::shell;
 
 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 +181,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()) {
@@ -143,12 +200,9 @@
         int value = gridUnitString.toInt(&ok);
         if (ok) {
             m_gridUnitPx = value;
+            m_panelHeight = (3 * m_gridUnitPx) + static_cast<int>(2 * qFloor(static_cast<float>(m_gridUnitPx) / 8));
         }
     }
-
-    int densityPixelPx = qFloor( (float)m_gridUnitPx / 8 );
-
-    m_panelHeight = 3 * m_gridUnitPx + 2 * densityPixelPx;
 }
 
 ApplicationManager::~ApplicationManager()
@@ -156,11 +210,6 @@
     DLOG("ApplicationManager::~ApplicationManager");
 }
 
-int ApplicationManager::panelHeight()
-{
-    return m_panelHeight;
-}
-
 int ApplicationManager::rowCount(const QModelIndex &parent) const
 {
     return !parent.isValid() ? m_applications.size() : 0;
@@ -222,6 +271,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 +282,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 +306,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 +325,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 +344,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 +380,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 +400,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 +431,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 +461,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 +491,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 +519,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 +531,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 +583,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,44 +601,50 @@
 
 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 defaults 
     x = 0;
-    y = m_panelHeight;
+    y = 0;
 
-    // Shell client override
-    if (!session) {
-        y = 0;
-        return;
+    if (application && !application->fullscreen() && session) {
+        if (application->stage() == Application::SideStage && !m_sideStageAppRect.isNull()) {
+            QRectF localRect(0., 0., m_sideStageAppRect->width(), m_sideStageAppRect->height());
+            QRectF sceneRect = m_sideStageAppRect->mapRectToScene(localRect);
+            x = (uint32_t)(sceneRect.x());
+            y = (uint32_t)(sceneRect.y());
+        } else if (!m_mainStageAppRect.isNull()) {
+            QRectF localRect(0., 0., m_sideStageAppRect->width(), m_mainStageAppRect->height());
+            QRectF sceneRect = m_mainStageAppRect->mapRectToScene(localRect);
+            x = (uint32_t)(sceneRect.x());
+            y = (uint32_t)(sceneRect.y());
+        }
+    } else if (session) { // if a valid session, but no application associated, it must be a helper like OSK
+        if (qgetenv("NATIVE_ORIENTATION") == "landscape") {
+            x = 0;
+            y = 0;
+        } else {
+            x = 0;
+            y = m_panelHeight;
+        }
     }
 
-    // Fullscreen applications override
-    if (application && application->fullscreen())
-        y = 0;
-
-    // SideStage override
-    if (application && application->stage() == Application::SideStage)
-        x = m_displaySize.width() - (SIDE_STAGE_WIDTH_GU * m_gridUnitPx);
-    
     DLOG("ApplicationManager::placeSession (x=%d, y=%d)", x, y);
 }
 
 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;
         return;
     }
 
-    //FIXME(greyback) Mir not supplying any identifier that we can use to link the PID to the session
-    // so am assuming that the *most recently* launched application session is the one that connects
-    Application* application = findLastExecutedApplication();
-    if (application && application->state() != Application::Running) {
+    Application* application = findApplicationWithPid(session->process_id());
+    if (application && application->state() != Application::Running &&
+        !application->session()) {
         application->setSession(session);
         if (application->stage() == Application::MainStage)
             m_msApplicationToBeFocused = application;
@@ -592,10 +657,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 +670,7 @@
             application->setSession(nullptr);
             m_dbusWindowStack->WindowDestroyed(0, application->appId());
             if (application != m_focusedApplication) {
-	            removeApplication = false;
+                removeApplication = false;
             }
         }
 
@@ -626,8 +692,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 +715,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);
@@ -666,7 +732,7 @@
 }
 
 void ApplicationManager::onSessionCreatedSurface(msh::Session const* session,
-                                               std::shared_ptr<msh::Surface> const& surface)
+                                                 std::shared_ptr<msh::Surface> const& surface)
 {
     DLOG("ApplicationManager::onSessionCreatedSurface (this=%p)", this);
     Q_UNUSED(surface);
@@ -683,7 +749,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;
@@ -734,15 +800,6 @@
     return nullptr;
 }
 
-Application* ApplicationManager::findLastExecutedApplication()
-{
-    if (m_applications.length() > 0) {
-        return m_applications.last();
-    } else {
-        return NULL;
-    }
-}
-
 Application* ApplicationManager::applicationForStage(Application::Stage stage)
 {
     DLOG("ApplicationManager::focusedApplicationForStage(this=%p)", this);
@@ -769,6 +826,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);
@@ -793,6 +855,16 @@
     }
 }
 
+void ApplicationManager::setMainStageAppRect(QQuickItem *item)
+{
+    m_mainStageAppRect = item;
+}
+
+void ApplicationManager::setSideStageAppRect(QQuickItem *item)
+{
+    m_sideStageAppRect = item;
+}
+
 QModelIndex ApplicationManager::findIndex(Application* application)
 {
     for (int i = 0; i < m_applications.size(); ++i) {
@@ -803,3 +875,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-21 16:48:46 +0000
@@ -25,6 +25,8 @@
 
 // Qt
 #include <QObject>
+#include <QPointer>
+#include <QQuickItem>
 #include <QSharedPointer>
 #include <QStringList>
 
@@ -38,6 +40,7 @@
 class DBusWindowStack;
 class MirSurfaceManager;
 class TaskController;
+class ProcInfo;
 
 namespace mir {
     namespace geometry {
@@ -46,6 +49,7 @@
     namespace shell {
         class Session;
         class Surface;
+        class FocusController;
     }
 }
 
@@ -55,6 +59,11 @@
     Q_FLAGS(ExecFlags)
 
 public:
+    class Factory
+    {
+    public:
+        QSharedPointer<ApplicationManager> create();
+    };
     // Mapping enums to Ubuntu Platform API enums.
     enum Flag {
         NoFlag = 0x0,
@@ -66,6 +75,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();
 
@@ -86,12 +98,14 @@
                                               const QStringList &arguments = QStringList());
     Q_INVOKABLE void move(int from, int to);
 
+    Q_INVOKABLE void setMainStageAppRect(QQuickItem *item);
+    Q_INVOKABLE void setSideStageAppRect(QQuickItem *item);
+
     const QList<Application*> &list() const { return m_applications; }
     Application* findApplicationWithPid(const qint64 pid);
 
     // Internal helpers
     void suspendApplication(Application *application);
-    int panelHeight();
     QSize displaySize() const { return m_displaySize; }
 
 public Q_SLOTS:
@@ -119,9 +133,11 @@
     void remove(Application* application);
     Application* findApplicationWithSession(const std::shared_ptr<mir::shell::Session> &session);
     Application* findApplicationWithSession(const mir::shell::Session *session);
-    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,16 +146,21 @@
     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;
     int m_panelHeight;
 
+    // The rectangular area that should be occupied by an application on the main
+    // or side stage.
+    QPointer<QQuickItem> m_mainStageAppRect;
+    QPointer<QQuickItem> m_sideStageAppRect;
+
     friend class DBusWindowStack;
     friend class MirSurfaceManager;
 };

=== 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-21 16:48:46 +0000
@@ -28,7 +28,6 @@
 ApplicationScreenshotProvider::ApplicationScreenshotProvider(ApplicationManager *appManager)
     : QQuickImageProvider(QQuickImageProvider::Image)
     , m_appManager(appManager)
-    , m_panelHeight(m_appManager->panelHeight())
 {
 }
 

=== 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-21 16:48:46 +0000
@@ -30,7 +30,6 @@
 
 private:
     ApplicationManager* m_appManager;
-    int m_panelHeight;
 };
 
 #endif // APPLICATIONSCREENSHOTPROVIDER_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-21 16:48:46 +0000
@@ -176,12 +176,38 @@
 {
     DLOG("InputArea::setMirInputArea (this=%p, x=%lf, y=%lf, width=%lf, height=%lf)", this, relativeGeometry.x(), relativeGeometry.y(), relativeGeometry.width(), relativeGeometry.height());
     using namespace mir::geometry;
-    const QRect rect = parentItem()->mapRectToScene(relativeGeometry).toRect();
-
-    m_mirInputArea.top_left.x = X{rect.x()};
-    m_mirInputArea.top_left.y = Y{rect.y()};
-    m_mirInputArea.size.width = Width{rect.width()};
-    m_mirInputArea.size.height = Height{rect.height()};
+    QQuickItem* parent = parentItem();
+    bool shellFound = false;
+    const bool landscape = qgetenv("NATIVE_ORIENTATION") == "landscape";
+
+    // FIXME: It seems Qt's mapRectToScene/Item returns incorrect position coordinates once rotations are performed.
+    // As a work around, we try to find the "shell" Item, find the InputArea geometry relative to that, and then
+    // manually perform the rotation for landscape mode.
+    while (landscape && parent) {
+        if (parent->objectName() == "shell") {
+            shellFound = true;
+            break;
+        }
+        parent = parent->parentItem();
+    }
+
+    QRect rect;
+
+    if (landscape && shellFound) {
+        rect = mapRectToItem(parent, relativeGeometry).toRect();
+
+        m_mirInputArea.top_left.x = X{parent->height() - rect.y() - rect.height()};
+        m_mirInputArea.top_left.y = Y{rect.x()};
+        m_mirInputArea.size.width = Width{rect.height()};
+        m_mirInputArea.size.height = Height{rect.width()};
+    } else { // position relative to scene as usual
+        rect = parentItem()->mapRectToScene(relativeGeometry).toRect();
+
+        m_mirInputArea.top_left.x = X{rect.x()};
+        m_mirInputArea.top_left.y = Y{rect.y()};
+        m_mirInputArea.size.width = Width{rect.width()};
+        m_mirInputArea.size.height = Height{rect.height()};
+    }
 
     if (m_surface) {
         m_surface->installInputArea(this);

=== 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-21 16:48:46 +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-21 16:48:46 +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-21 16:48:46 +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-21 16:48:46 +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-21 16:48:46 +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,141 @@
         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);
+}
+
+TEST_F(ApplicationManagerTests,bug_case_1281075_session_ptrs_always_distributed_to_last_started_app)
+{
+    using namespace ::testing;
+    quint64 first_procId = 5921;
+    quint64 second_procId = 5922;
+    quint64 third_procId = 5923;
+    std::shared_ptr<mir::shell::Surface> aSurface(nullptr);
+    const char first_app_id[] = "app1";
+    QByteArray first_cmdLine( "/usr/bin/app1 --desktop_file_hint=app1");
+    const char second_app_id[] = "app2";
+    QByteArray second_cmdLine( "/usr/bin/app2--desktop_file_hint=app2");
+    const char third_app_id[] = "app3";
+    QByteArray third_cmdLine( "/usr/bin/app3 --desktop_file_hint=app3");
+
+    EXPECT_CALL(procInfo,command_line_(first_procId))
+        .Times(1)
+        .WillOnce(Return(first_cmdLine));
+
+    ON_CALL(appController,appIdHasProcessId(_,_)).WillByDefault(Return(false));
+
+    EXPECT_CALL(procInfo,command_line_(second_procId))
+        .Times(1)
+        .WillOnce(Return(second_cmdLine));
+
+    EXPECT_CALL(procInfo,command_line_(third_procId))
+        .Times(1)
+        .WillOnce(Return(third_cmdLine));
+
+    bool authed = true;
+
+    std::shared_ptr<mir::shell::Session> first_session = std::make_shared<MockSession>("Oo", first_procId);
+    std::shared_ptr<mir::shell::Session> second_session = std::make_shared<MockSession>("oO", second_procId);
+    std::shared_ptr<mir::shell::Session> third_session = std::make_shared<MockSession>("OO", third_procId);
+    applicationManager.authorizeSession(first_procId, authed);
+    applicationManager.authorizeSession(second_procId, authed);
+    applicationManager.authorizeSession(third_procId, authed);
+    applicationManager.onSessionStarting(first_session);
+    applicationManager.onSessionStarting(third_session);
+    applicationManager.onSessionStarting(second_session);
+
+    Application * firstApp = applicationManager.findApplication(first_app_id);
+    Application * secondApp = applicationManager.findApplication(second_app_id);
+    Application * thirdApp = applicationManager.findApplication(third_app_id);
+
+    EXPECT_EQ(first_session, firstApp->session());
+    EXPECT_EQ(second_session, secondApp->session());
+    EXPECT_EQ(third_session, thirdApp->session());
+}

=== 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-21 16:48:46 +0000
@@ -11,7 +11,7 @@
     unity-mir-test-app
     main.cpp)
 
-qt5_use_modules(unity-mir-test-app Test DBus Gui)
+qt5_use_modules(unity-mir-test-app Test DBus Gui Quick)
 
 target_link_libraries(
     unity-mir-test-app
@@ -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-21 16:48:46 +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-21 16:48:46 +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-21 16:48:46 +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-21 16:48:46 +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