Merge lp:~nick-dedekind/unity-mir/unity-mir.trusted_sessions into lp:unity-mir

[Nick Dedekind]

=== 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-26 10:27:46 +0000
@@ -40,4 +40,12 @@
         source: (root.source) ? "image://screenshot/" + root.source.appId : ""
         cache: false
     }
+
+    Connections {
+        target: source
+        onSessionChanged: {
+            console.log("SESSION CHANGED");
+            scheduleUpdate();
+        }
+    }
 }

=== modified file 'src/modules/Unity/Application/CMakeLists.txt'
--- src/modules/Unity/Application/CMakeLists.txt	2014-01-27 11:29:44 +0000
+++ src/modules/Unity/Application/CMakeLists.txt	2014-02-26 10:27:46 +0000
@@ -32,6 +32,7 @@
   processcontroller.h
   processcontroller.cpp
   shellinputarea.cpp
+  session.cpp
   ubuntukeyboardinfo.cpp
 
   upstart/applicationcontroller.h
@@ -47,10 +48,11 @@
   mirsurface.h
   mirsurfacemanager.h
   shellinputarea.h
+  session.h
   inputarea.h
   inputfilterarea.h
   ubuntukeyboardinfo.h
-  
+
   # We need to pull in some external header files
   /usr/include/unity/shell/application/ApplicationManagerInterface.h
   /usr/include/unity/shell/application/ApplicationInfoInterface.h
@@ -62,7 +64,7 @@
 
 target_link_libraries(
   unityapplicationplugin
-  
+
   unity-mir
 
   ubuntu_application_api_mirserver

=== modified file 'src/modules/Unity/Application/application.cpp'
--- src/modules/Unity/Application/application.cpp	2014-01-27 11:29:44 +0000
+++ src/modules/Unity/Application/application.cpp	2014-02-26 10:27:46 +0000
@@ -22,11 +22,13 @@
 
 // unity-mir
 #include "logging.h"
+#include "session.h"
 
 // mir
-#include <mir/shell/session.h>
 #include <mir/shell/snapshot.h>
 
+#include <QDebug>
+
 Application::Application(const QSharedPointer<TaskController>& taskController,
                          DesktopFileReader *desktopFileReader,
                          State state,
@@ -120,9 +122,16 @@
     return m_fullscreen;
 }
 
-std::shared_ptr<mir::shell::Session> Application::session() const
-{
-    return m_session;
+QSharedPointer<Session> Application::session() const
+{
+    if (!m_overrideSession.isNull())
+        return m_overrideSession;
+    return m_session.toStrongRef();
+}
+
+QSharedPointer<Session> Application::overrideSession() const
+{
+    return m_overrideSession;
 }
 
 pid_t Application::pid() const
@@ -135,12 +144,25 @@
     m_pid = pid;
 }
 
-void Application::setSession(const std::shared_ptr<mir::shell::Session>& session)
+void Application::setSession(const QSharedPointer<Session>& new_session)
 {
-    DLOG("Application::setSession (this=%p, session=%p)", this, session.get());
+    DLOG("Application::setSession (this=%p, session=%p)", this, new_session ? new_session->mirSession().get() : nullptr);
 
     // TODO(greyback) what if called with new surface?
-    m_session = session;
+    m_session = new_session.toWeakRef();
+    if (session()) {
+        Q_EMIT sessionChanged();
+    }
+}
+
+void Application::setOverrideSession(const QSharedPointer<Session>& override_session)
+{
+    DLOG("Application::setOverrideSession (this=%p, session=%p)", this, override_session ? override_session->mirSession().get() : nullptr);
+
+    m_overrideSession = override_session;
+    if (session()) {
+        Q_EMIT sessionChanged();
+    }
 }
 
 void Application::setSessionName(const QString& name)
@@ -169,8 +191,8 @@
         switch (state)
         {
         case Application::Suspended:
-            if (m_state == Application::Running) {
-                session()->set_lifecycle_state(mir_lifecycle_state_will_suspend);
+            if (session() && m_state == Application::Running) {
+                session()->setLifecycleState(mir_lifecycle_state_will_suspend);
                 m_suspendTimer->start(3000);
             }
             break;
@@ -178,9 +200,9 @@
             if (m_suspendTimer->isActive())
                 m_suspendTimer->stop();
 
-            if (m_state == Application::Suspended) {
+            if (session() && m_state == Application::Suspended) {
                 resume();
-                session()->set_lifecycle_state(mir_lifecycle_state_resumed);
+                session()->setLifecycleState(mir_lifecycle_state_resumed);
             } else if (m_state == Application::Stopped) {
                 respawn();
                 state = Application::Starting;

=== modified file 'src/modules/Unity/Application/application.h'
--- src/modules/Unity/Application/application.h	2014-01-27 11:29:44 +0000
+++ src/modules/Unity/Application/application.h	2014-02-26 10:27:46 +0000
@@ -31,7 +31,14 @@
 class QImage;
 class DesktopFileReader;
 class TaskController;
-namespace mir { namespace shell { class Session; }}
+class Session;
+namespace mir
+{
+namespace shell
+{
+class TrustedSession;
+}
+}
 
 class Application : public unity::shell::application::ApplicationInfoInterface {
     Q_OBJECT
@@ -63,9 +70,11 @@
     QString desktopFile() const;
     QString exec() const;
     bool fullscreen() const;
-    std::shared_ptr<mir::shell::Session> session() const;
     pid_t pid() const;
 
+    QSharedPointer<Session> session() const;
+    QSharedPointer<Session> overrideSession() const;
+
 public Q_SLOTS:
     void suspend();
     void resume();
@@ -74,15 +83,18 @@
 Q_SIGNALS:
     void fullscreenChanged();
     void stageChanged(Stage stage);
+    void sessionChanged();
 
 private:
     void setPid(pid_t pid);
     void setState(State state);
     void setFocused(bool focus);
     void setFullscreen(bool fullscreen);
-    void setSession(const std::shared_ptr<mir::shell::Session>& session);
     void setSessionName(const QString& name);
 
+    void setSession(const QSharedPointer<Session>& session);
+    void setOverrideSession(const QSharedPointer<Session>& session);
+
     QSharedPointer<TaskController> m_taskController;
     DesktopFileReader* m_desktopData;
     qint64 m_pid;
@@ -90,7 +102,9 @@
     State m_state;
     bool m_focused;
     bool m_fullscreen;
-    std::shared_ptr<mir::shell::Session> m_session;
+    QWeakPointer<Session> m_session;
+    QSharedPointer<Session> m_overrideSession;
+
     QString m_sessionName;
     QStringList m_arguments;
     QTimer* m_suspendTimer;

=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2014-02-11 09:47:56 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2014-02-26 10:27:46 +0000
@@ -31,15 +31,18 @@
 #include "surfacefactory.h"
 #include "taskcontroller.h"
 #include "logging.h"
+#include "session.h"
 
 // mir
 #include <mir/scene/depth_id.h>
 #include <mir/shell/session.h>
 #include <mir/shell/focus_controller.h>
 #include <mir/shell/surface.h>
+#include <mir/shell/trusted_session.h>
 #include <mir/graphics/display.h>
 #include <mir/graphics/display_buffer.h>
 #include <mircommon/mir/geometry/rectangles.h>
+#include <mir/frontend/shell.h>
 
 // Qt
 #include <QCoreApplication>
@@ -53,6 +56,11 @@
 
 ApplicationManager *ApplicationManager::the_application_manager = nullptr;
 
+QList<QByteArray> ApplicationManager::whiteListApps({ "maliit-server",
+                                                      "/usr/lib/arm-linux-gnueabihf/qt5/libexec/QtWebProcess",
+                                                      "/usr/bin/signon-ui",
+                                                      "/usr/bin/mir_demo_client_trusted_session_trusted" });
+
 ApplicationManager* ApplicationManager::singleton()
 {
     if (!the_application_manager) {
@@ -82,7 +90,6 @@
     , m_taskController(taskController)
     , m_desktopFileReaderFactory(desktopFileReaderFactory)
     , m_gridUnitPx(8)
-    , m_fenceNext(false)
     , m_panelHeight(54)
 {
     DLOG("ApplicationManager::ApplicationManager (this=%p)", this);
@@ -105,6 +112,10 @@
                      this, &ApplicationManager::onSessionUnfocused);
     QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionCreatedSurface,
                      this, &ApplicationManager::onSessionCreatedSurface);
+    QObject::connect(m_mirServer->sessionListener(), &SessionListener::trustedSessionStarted,
+                     this, &ApplicationManager::onTrustedSessionStarted);
+    QObject::connect(m_mirServer->sessionListener(), &SessionListener::trustedSessionStopped,
+                     this, &ApplicationManager::onTrustedSessionStopped);
     QObject::connect(m_mirServer->sessionAuthorizer(), &SessionAuthorizer::requestAuthorizationForSession,
                      this, &ApplicationManager::authorizeSession, Qt::BlockingQueuedConnection);
     QObject::connect(m_mirServer->placementStrategy(), &InitialSurfacePlacementStrategy::requestPlacementForSession,
@@ -130,7 +141,7 @@
         {
             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()
@@ -239,15 +250,15 @@
         DLOG("No such running application '%s'", qPrintable(appId));
         return false;
     }
-   
+
     if (application->stage() == Application::MainStage && m_sideStageApplication)
         suspendApplication(m_sideStageApplication);
-    
+
     if (application->stage() == Application::MainStage)
         m_msApplicationToBeFocused = application;
     else
         m_ssApplicationToBeFocused = application;
-    
+
     if (application->state() == Application::Stopped) {
         // Respawning this app, move to end of application list so onSessionStarting works ok
         // FIXME: this happens pretty late, shell could request respawn earlier
@@ -255,8 +266,9 @@
         int from = m_applications.indexOf(application);
         move(from, m_applications.length()-1);
     } else {
-        if (application->session())
-            m_mirServer->the_focus_controller()->set_focus_to(application->session());
+        if (application->session()) {
+            m_mirServer->the_focus_controller()->set_focus_to(application->session()->mirSession());
+        }
     }
 
     // FIXME(dandrader): lying here. The operation is async. So we will only know whether
@@ -353,15 +365,24 @@
 
     if (application == m_focusedApplication) {
         // TODO(greyback) What to do?? Focus next app, or unfocus everything??
+        auto lastFocusedApp = m_focusedApplication;
         m_focusedApplication = NULL;
         Q_EMIT focusedApplicationIdChanged();
+
+        // stop trusted session when focus changes.
+        if (lastFocusedApp && lastFocusedApp->overrideSession()) {
+            auto overrideMirSession = lastFocusedApp->overrideSession()->mirSession();
+            if (overrideMirSession->get_trusted_session()) {
+                m_mirServer->the_frontend_shell()->stop_trusted_session(overrideMirSession->get_trusted_session()->id());
+            }
+        }
     }
 
     if (application == m_mainStageApplication)
         m_mainStageApplication = nullptr;
     if (application == m_sideStageApplication)
         m_sideStageApplication = nullptr;
-    
+
     remove(application);
     m_dbusWindowStack->WindowDestroyed(0, application->appId());
 
@@ -388,9 +409,18 @@
 
         if (application == m_focusedApplication) {
             // Very bad case where focused application dies. Remove from list. Should give error message
+            auto lastFocusedApp = m_focusedApplication;
             m_focusedApplication = nullptr;
             Q_EMIT focusedApplicationIdChanged();
             removeApplication = true;
+
+            // stop trusted session when focus changes.
+            if (lastFocusedApp && lastFocusedApp->overrideSession()) {
+                auto overrideMirSession = lastFocusedApp->overrideSession()->mirSession();
+                if (overrideMirSession->get_trusted_session()) {
+                    m_mirServer->the_frontend_shell()->stop_trusted_session(overrideMirSession->get_trusted_session()->id());
+                }
+            }
         }
 
         if (application->state() == Application::Running || application->state() == Application::Starting) {
@@ -399,7 +429,7 @@
             removeApplication = true;
         } else if (application->state() == Application::Suspended) {
             application->setState(Application::Stopped);
-            application->setSession(nullptr);
+            application->setSession(QSharedPointer<Session>());
         }
 
         if (removeApplication) {
@@ -471,12 +501,14 @@
 
     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")) {
-        authorized = true;
-        m_fenceNext = true;
-        return;
+    // FIXME: special exceptions - not very secure
+    for( auto const& whiteListApp : whiteListApps) {
+        if (command.startsWith(whiteListApp)) {
+            DLOG("ApplicationManager ACCEPTED connection from white-list app with pid %lld", pid);
+            authorized = true;
+            m_fencePIDs << pid;
+            return;
+        }
     }
 
     QString pattern = QRegularExpression::escape("--desktop_file_hint=") + "(\\S+)";
@@ -484,7 +516,7 @@
     QRegularExpressionMatch regExpMatch = regExp.match(command);
 
     if (!regExpMatch.hasMatch()) {
-        LOG("ApplicationManager REJECTED connection from app with pid %lld as no desktop_file_hint specified", pid);
+        LOG("ApplicationManager REJECTED connection from app with pid %lld (%s) as no desktop_file_hint specified", pid, command.data());
         return;
     }
 
@@ -543,10 +575,10 @@
 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);
-
-    // Application defaults 
+
+    Application* application = findApplicationWithSession(session, true);
+
+    // Application defaults
     x = 0;
     y = m_panelHeight;
 
@@ -563,7 +595,7 @@
     // 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);
 }
 
@@ -571,21 +603,22 @@
 {
     DLOG("ApplicationManager::onSessionStarting (this=%p, application=%s)", this, session->name().c_str());
 
-    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();
+    pid_t pid = session->process_id();
+
+    QSharedPointer<Session> new_session(new Session(session));
+    m_sessions[pid] = new_session;
+
+    Application* application = findApplicationWithPid(session->process_id(), false);
     if (application && application->state() != Application::Running) {
-        application->setSession(session);
+        application->setSession(new_session);
         if (application->stage() == Application::MainStage)
             m_msApplicationToBeFocused = application;
         else
             m_ssApplicationToBeFocused = application;
     } else {
+        if (m_fencePIDs.contains(pid)) {
+            return;
+        }
         DLOG("ApplicationManager::onSessionStarting - unauthorized application!!");
     }
 }
@@ -594,44 +627,56 @@
 {
     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);
-    if (application) {
-        bool removeApplication = true;
-
-        if (application->state() != Application::Starting) {
-            application->setState(Application::Stopped);
-            application->setSession(nullptr);
-            m_dbusWindowStack->WindowDestroyed(0, application->appId());
-            if (application != m_focusedApplication) {
-	            removeApplication = false;
-            }
-        }
-
-        if (m_mainStageApplication == application)
-            m_mainStageApplication = nullptr;
-        
-        if (m_sideStageApplication == application)
-            m_sideStageApplication = nullptr;
-
-        if (removeApplication) {
-            // TODO(greyback) What to do?? Focus next app, or unfocus everything??
-            m_focusedApplication = NULL;
-            remove(application);
-            delete application;
-            Q_EMIT focusedApplicationIdChanged();
-        }
+    auto sit = m_sessions.find(session->process_id());
+    if (sit != m_sessions.end()) {
+        QSharedPointer<Session> localSession = sit.value();
+
+        // in case application closed not by hand of shell, check again here:
+        Application* application = findApplicationWithSession(session, false); // only check app sessions
+        if (application) {
+
+            if (session->get_trusted_session()) {
+                m_mirServer->the_frontend_shell()->stop_trusted_session(session->get_trusted_session()->id());
+            }
+
+            bool removeApplication = true;
+            if (application->state() != Application::Starting) {
+                application->setState(Application::Stopped);
+                application->setSession(QSharedPointer<Session>());
+                m_dbusWindowStack->WindowDestroyed(0, application->appId());
+                if (application != m_focusedApplication) {
+    	            removeApplication = false;
+                }
+            }
+
+            if (m_mainStageApplication == application)
+                m_mainStageApplication = nullptr;
+
+            if (m_sideStageApplication == application)
+                m_sideStageApplication = nullptr;
+
+            if (removeApplication) {
+                // TODO(greyback) What to do?? Focus next app, or unfocus everything??
+                m_focusedApplication = NULL;
+                remove(application);
+                delete application;
+                Q_EMIT focusedApplicationIdChanged();
+            }
+        }
+
+        m_sessions.erase(sit);
+        m_fencePIDs.removeAll(session->process_id());
     }
 }
 
 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=%s)", this, session->name().c_str());
+    Application* application = findApplicationWithSession(session, true);
 
     // 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
-    if (application && application->state() != Application::Starting && 
+    if (application && application->state() != Application::Starting &&
         (application == m_msApplicationToBeFocused ||
          application == m_ssApplicationToBeFocused)
             && application != m_focusedApplication) {
@@ -640,9 +685,10 @@
         Q_EMIT dataChanged(appIndex, appIndex, QVector<int>() << RoleFocused);
     } else {
         if (application == nullptr) {
-            DLOG("Invalid application focused, discarding the event");
-            if (NULL != m_focusedApplication)
+            DLOG("Invalid application focused, discarding the event (m_focusedApplication=%p)", m_focusedApplication);
+            if (NULL != m_focusedApplication) {
                 focusApplication(m_focusedApplication->appId());
+            }
         }
     }
 }
@@ -653,7 +699,8 @@
     if (NULL != m_focusedApplication) {
         Q_ASSERT(m_focusedApplication->focused());
         m_focusedApplication->setFocused(false);
-        
+
+        auto lastFocusedApp = m_focusedApplication;
         suspendApplication(m_focusedApplication);
 
         m_focusedApplication = NULL;
@@ -662,16 +709,23 @@
 
         QModelIndex appIndex = findIndex(m_focusedApplication);
         Q_EMIT dataChanged(appIndex, appIndex, QVector<int>() << RoleFocused << RoleState);
+
+        if (lastFocusedApp->overrideSession()) {
+            auto overrideMirSession = lastFocusedApp->overrideSession()->mirSession();
+            if (overrideMirSession->get_trusted_session()) {
+                m_mirServer->the_frontend_shell()->stop_trusted_session(overrideMirSession->get_trusted_session()->id());
+            }
+        }
     }
 }
 
 void ApplicationManager::onSessionCreatedSurface(msh::Session const* session,
                                                std::shared_ptr<msh::Surface> const& surface)
 {
-    DLOG("ApplicationManager::onSessionCreatedSurface (this=%p)", this);
+    DLOG("ApplicationManager::onSessionCreatedSurface (this=%p, application=%p)", this, session->name().c_str());
     Q_UNUSED(surface);
 
-    Application* application = findApplicationWithSession(session);
+    Application* application = findApplicationWithSession(session, true);
     if (application && application->state() == Application::Starting) {
         m_dbusWindowStack->WindowCreated(0, application->appId());
         // only when Session creates a Surface will we actually mark it focused
@@ -681,6 +735,51 @@
     }
 }
 
+void ApplicationManager::onTrustedSessionStarted(std::shared_ptr<mir::shell::TrustedSession> const& mir_trusted_session)
+{
+    DLOG("ApplicationManager::onTrustedSessionStarted (this=%p, application=%p)", this, mir_trusted_session->name().c_str());
+
+    QSharedPointer<Session> trusted_session(new Session(mir_trusted_session));
+
+    bool overrideSet = false;
+    std::vector<pid_t> trusted_apps = mir_trusted_session->get_applications();
+    for (pid_t pid : trusted_apps) {
+        Application* app = findApplicationWithPid(pid, false);
+        if (!app) {
+            continue;
+        }
+
+        overrideSet = true;
+        app->setOverrideSession(trusted_session);
+
+        if (m_focusedApplication == app) {
+            focusApplication(app->appId());
+        }
+    }
+
+    if (!overrideSet) {
+        DLOG("ApplicationManager::onTrustedSessionStarted - no trusted helper to start");
+    }
+}
+
+void ApplicationManager::onTrustedSessionStopped(std::shared_ptr<mir::shell::TrustedSession> const& trusted_session)
+{
+    auto trusted_helper = trusted_session->get_trusted_helper();
+    DLOG("ApplicationManager::onTrustedSessionStopped (this=%p, application=%s)", this, trusted_helper->name().c_str());
+
+    for (Application *app : m_applications) {
+
+        if (app->overrideSession() && app->overrideSession()->mirSession() == trusted_session) {
+            app->setOverrideSession(QSharedPointer<Session>());
+        }
+
+        if (m_focusedApplication == app) {
+            focusApplication(app->appId());
+        }
+    }
+}
+
+
 void ApplicationManager::setFocused(Application *application)
 {
     DLOG("ApplicationManager::setFocused (appId=%s)", qPrintable(application->appId()));
@@ -699,29 +798,34 @@
     else
         m_sideStageApplication = application;
 
+    auto lastFocusedApp = m_focusedApplication;
     m_focusedApplication = application;
     m_focusedApplication->setFocused(true);
     m_focusedApplication->setState(Application::Running);
     Q_EMIT focusedApplicationIdChanged();
     m_dbusWindowStack->FocusedWindowChanged(0, application->appId(), application->stage());
-}
-
-Application* ApplicationManager::findApplicationWithSession(const std::shared_ptr<msh::Session> &session)
-{
-    return findApplicationWithSession(session.get());
-}
-
-Application* ApplicationManager::findApplicationWithSession(const msh::Session *session)
-{
-    for (Application *app : m_applications) {
-        if (app->session().get() == session) {
-            return app;
+
+    // stop trusted session when focus changes.
+    if (lastFocusedApp && lastFocusedApp->overrideSession()) {
+        auto overrideMirSession = lastFocusedApp->overrideSession()->mirSession();
+        if (overrideMirSession->get_trusted_session()) {
+            m_mirServer->the_frontend_shell()->stop_trusted_session(overrideMirSession->get_trusted_session()->id());
         }
     }
-    return nullptr;
-}
-
-Application* ApplicationManager::findApplicationWithPid(const qint64 pid)
+}
+
+Application* ApplicationManager::findApplicationWithSession(const std::shared_ptr<msh::Session> &session, bool checkSessions)
+{
+    return findApplicationWithSession(session.get(), checkSessions);
+}
+
+Application* ApplicationManager::findApplicationWithSession(const msh::Session *session, bool checkSessions)
+{
+    if (!session) { return NULL; }
+    return findApplicationWithPid(session->process_id(), checkSessions);
+}
+
+Application* ApplicationManager::findApplicationWithPid(const qint64 pid, bool checkSessions)
 {
     if (pid <= 0)
         return nullptr;
@@ -730,17 +834,23 @@
         if (app->m_pid == pid) {
             return app;
         }
+
+        if (checkSessions && app->session()) {
+            if (app->session()->hasProcess(pid)) {
+                return app;
+            }
+        }
     }
     return nullptr;
 }
 
-Application* ApplicationManager::findLastExecutedApplication()
+QSharedPointer<Session> ApplicationManager::findSessionForPid(pid_t pid)
 {
-    if (m_applications.length() > 0) {
-        return m_applications.last();
-    } else {
-        return NULL;
+    auto iter = m_sessions.find(pid);
+    if (iter != m_sessions.end()) {
+        return *iter;
     }
+    return QSharedPointer<Session>();
 }
 
 Application* ApplicationManager::applicationForStage(Application::Stage stage)

=== modified file 'src/modules/Unity/Application/application_manager.h'
--- src/modules/Unity/Application/application_manager.h	2014-01-27 11:29:44 +0000
+++ src/modules/Unity/Application/application_manager.h	2014-02-26 10:27:46 +0000
@@ -46,6 +46,7 @@
     namespace shell {
         class Session;
         class Surface;
+        class TrustedSession;
     }
 }
 
@@ -87,7 +88,7 @@
     Q_INVOKABLE void move(int from, int to);
 
     const QList<Application*> &list() const { return m_applications; }
-    Application* findApplicationWithPid(const qint64 pid);
+    Application* findApplicationWithPid(const qint64 pid, bool checkSessions);
 
     // Internal helpers
     void suspendApplication(Application *application);
@@ -97,11 +98,13 @@
 public Q_SLOTS:
     void authorizeSession(const quint64 pid, bool &authorized);
     void placeSession(mir::shell::Session const*, uint32_t &x, uint32_t &y);
-    
+
     void onSessionStarting(std::shared_ptr<mir::shell::Session> const& session);
     void onSessionStopping(std::shared_ptr<mir::shell::Session> const& session);
     void onSessionFocused(std::shared_ptr<mir::shell::Session> const& session);
     void onSessionUnfocused();
+    void onTrustedSessionStarted(std::shared_ptr<mir::shell::TrustedSession> const& trusted_session);
+    void onTrustedSessionStopped(std::shared_ptr<mir::shell::TrustedSession> const& trusted_session);
 
     void onSessionCreatedSurface(mir::shell::Session const*, std::shared_ptr<mir::shell::Surface> const&);
 
@@ -117,11 +120,11 @@
     void setFocused(Application *application);
     void add(Application *application);
     void remove(Application* application);
-    Application* findApplicationWithSession(const std::shared_ptr<mir::shell::Session> &session);
-    Application* findApplicationWithSession(const mir::shell::Session *session);
-    Application* findLastExecutedApplication();
+    Application* findApplicationWithSession(const std::shared_ptr<mir::shell::Session> &session, bool checkSessions);
+    Application* findApplicationWithSession(const mir::shell::Session *session, bool checkSessions);
     Application* applicationForStage(Application::Stage stage);
     QModelIndex findIndex(Application* application);
+    QSharedPointer<Session> findSessionForPid(pid_t pid);
 
     QList<Application*> m_applications;
     Application* m_focusedApplication; // remove as Mir has API for this
@@ -135,8 +138,10 @@
     QSharedPointer<TaskController> m_taskController;
     QSharedPointer<DesktopFileReader::Factory> m_desktopFileReaderFactory;
     static ApplicationManager* the_application_manager;
+    static QList<QByteArray> whiteListApps;
     int m_gridUnitPx;
-    bool m_fenceNext;
+    QList<pid_t> m_fencePIDs;
+    QMap<pid_t, QSharedPointer<Session>> m_sessions;
     QSize m_displaySize;
     int m_panelHeight;
 

=== modified file 'src/modules/Unity/Application/applicationscreenshotprovider.cpp'
--- src/modules/Unity/Application/applicationscreenshotprovider.cpp	2013-12-20 03:38:43 +0000
+++ src/modules/Unity/Application/applicationscreenshotprovider.cpp	2014-02-26 10:27:46 +0000
@@ -20,6 +20,7 @@
 #include "application.h"
 
 // unity-mir
+#include "session.h"
 #include "logging.h"
 
 // mir
@@ -51,7 +52,8 @@
 
     // TODO: if app not ready, return an app-provided splash image. If app has been stopped with saved state
     // return the screenshot that was saved to disk.
-    if (!app->session() || !app->session()->default_surface()) {
+    QSharedPointer<Session> session = app->session();
+    if (!session || !session->mirSession() || !session->mirSession()->default_surface()) {
         LOG("ApplicationScreenshotProvider - app session not found - taking screenshot too early");
         return QImage();
     }
@@ -67,7 +69,7 @@
 
     QImage image;
 
-    app->session()->take_snapshot(
+    session->mirSession()->take_snapshot(
         [&](mir::shell::Snapshot const& snapshot)
         {
             DLOG("ApplicationScreenshotProvider - Mir snapshot ready with size %d x %d",

=== modified file 'src/modules/Unity/Application/dbuswindowstack.cpp'
--- src/modules/Unity/Application/dbuswindowstack.cpp	2013-10-09 09:02:23 +0000
+++ src/modules/Unity/Application/dbuswindowstack.cpp	2014-02-26 10:27:46 +0000
@@ -44,7 +44,7 @@
 {
     AppIdDesktopFile res;
     ApplicationManager *appMgr = static_cast<ApplicationManager*>(parent());
-    const Application* app = static_cast<Application*>(appMgr->findApplicationWithPid(pid));
+    const Application* app = static_cast<Application*>(appMgr->findApplicationWithPid(pid, false));
     if (app) {
         res.app_id = app->appId();
         res.desktop_file = app->desktopFile();

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.cpp'
--- src/modules/Unity/Application/mirsurfacemanager.cpp	2013-12-20 03:38:43 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.cpp	2014-02-26 10:27:46 +0000
@@ -103,8 +103,8 @@
 {
     DLOG("MirSurfaceManager::sessionCreatedSurface (this=%p) with surface name '%s'", this, surface->name().c_str());
     ApplicationManager* appMgr = static_cast<ApplicationManager*>(ApplicationManager::singleton());
-    Application* application = appMgr->findApplicationWithSession(session);
-    
+    Application* application = appMgr->findApplicationWithSession(session, true);
+
     auto qmlSurface = new MirSurface(surface, application);
     m_surfaces.insert(surface.get(), qmlSurface);
     Q_EMIT surfaceCreated(qmlSurface);
@@ -134,7 +134,7 @@
     if (fs) {
         fs->set_default_keyboard_target(surface);
     }
-    
+
     Q_EMIT shellSurfaceChanged(m_shellSurface);
 }
 
@@ -145,18 +145,21 @@
 
     auto it = m_surfaces.find(surface);
     if (it != m_surfaces.end()) {
-        it.value()->setAttribute(attribute, value);
+        auto const& surface = it.value();
+
+        surface->setAttribute(attribute, value);
         if (attribute == mir_surface_attrib_state &&
                 value == mir_surface_state_fullscreen) {
+
             // Only screen-wide applications are allowed to go fullscreen
-            if (it.value()->application()->stage() == Application::MainStage) {
-                it.value()->application()->setFullscreen(static_cast<bool>(value));
+            if (surface->application() && surface->application()->stage() == Application::MainStage) {
+                surface->application()->setFullscreen(static_cast<bool>(value));
                 ApplicationManager* appMgr = static_cast<ApplicationManager*>(ApplicationManager::singleton());
                 QSize displaySize = appMgr->displaySize();
-                it.value()->setWidth(displaySize.width());
-                it.value()->setHeight(displaySize.height());
-                it.value()->setX(0);
-                it.value()->setY(0);
+                surface->setWidth(displaySize.width());
+                surface->setHeight(displaySize.height());
+                surface->setX(0);
+                surface->setY(0);
             }
         }
     }

=== added file 'src/modules/Unity/Application/session.cpp'
--- src/modules/Unity/Application/session.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/session.cpp	2014-02-26 10:27:46 +0000
@@ -0,0 +1,70 @@
+/*
+ * 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 "session.h"
+
+// mir
+#include <mir/shell/session.h>
+#include <mir/shell/trusted_session.h>
+
+Session::Session(const std::shared_ptr<mir::shell::Session>& session)
+:   m_session(session)
+,   m_application(NULL)
+{
+}
+
+Session::~Session()
+{
+}
+
+std::shared_ptr<mir::shell::Session> Session::mirSession() const
+{
+    return m_session;
+}
+
+void Session::setLifecycleState(MirLifecycleState state)
+{
+    m_session->set_lifecycle_state(state);
+}
+
+void Session::setApplication(Application* application)
+{
+    m_application = application;
+}
+
+Application* Session::application() const
+{
+    return m_application;
+}
+
+bool Session::hasProcess(pid_t pid) const
+{
+    if (mirSession()->process_id() == pid) {
+        return true;
+    }
+    auto trusted_session = mirSession()->get_trusted_session();
+    if (trusted_session) {
+        if (trusted_session->get_trusted_helper()->process_id() == pid) {
+            return true;
+        }
+        for (pid_t application_pid : trusted_session->get_applications()) {
+            if (application_pid == pid) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
\ No newline at end of file

=== added file 'src/modules/Unity/Application/session.h'
--- src/modules/Unity/Application/session.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/session.h	2014-02-26 10:27:46 +0000
@@ -0,0 +1,60 @@
+/*
+ * 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 SESSION_H
+#define SESSION_H
+
+// std
+#include <memory>
+
+// Mir
+#include <mir_toolkit/common.h>
+
+ // Qt
+#include <QSharedPointer>
+
+class Application;
+namespace mir
+{
+namespace shell
+{
+class Session;
+}
+}
+
+class Session {
+public:
+    Session(const std::shared_ptr<mir::shell::Session>& session);
+    virtual ~Session();
+
+    std::shared_ptr<mir::shell::Session> mirSession() const;
+
+    void setLifecycleState(MirLifecycleState state);
+
+    void setApplication(Application* application);
+    Application* application() const;
+
+    bool hasProcess(pid_t pid) const;
+
+protected:
+    void setParent(const QSharedPointer<Session>& parent);
+
+private:
+    std::shared_ptr<mir::shell::Session> m_session;
+    Application* m_application;
+};
+
+#endif  // SESSION_H

=== modified file 'src/unity-mir/sessionlistener.cpp'
--- src/unity-mir/sessionlistener.cpp	2013-11-20 14:39:50 +0000
+++ src/unity-mir/sessionlistener.cpp	2014-02-26 10:27:46 +0000
@@ -27,6 +27,7 @@
     DLOG("SessionListener::SessionListener (this=%p)", this);
     // need to register type to send over threads with signal/slot
     qRegisterMetaType<std::shared_ptr<msh::Session>>("std::shared_ptr<mir::shell::Session>");
+    qRegisterMetaType<std::shared_ptr<msh::TrustedSession>>("std::shared_ptr<mir::shell::TrustedSession>");
 }
 
 SessionListener::~SessionListener()
@@ -71,3 +72,15 @@
     DLOG("SessionListener::destroying_surface (this=%p, session=%p, surface=%p)", this, &session, (void*)surface.get());
     Q_EMIT sessionDestroyingSurface(&session, surface);
 }
+
+void SessionListener::trusted_session_started(std::shared_ptr<mir::shell::TrustedSession> const& trusted_session)
+{
+    DLOG("SessionListener::trusted_session_started (this=%p, trusted_session=%p)", this, (void*)trusted_session.get());
+    Q_EMIT trustedSessionStarted(trusted_session);
+}
+
+void SessionListener::trusted_session_stopped(std::shared_ptr<mir::shell::TrustedSession> const& trusted_session)
+{
+    DLOG("SessionListener::trusted_session_stopped (this=%p, session=%p)", this, (void*)trusted_session.get());
+    Q_EMIT trustedSessionStopped(trusted_session);
+}

=== modified file 'src/unity-mir/sessionlistener.h'
--- src/unity-mir/sessionlistener.h	2013-11-15 17:40:27 +0000
+++ src/unity-mir/sessionlistener.h	2014-02-26 10:27:46 +0000
@@ -36,6 +36,9 @@
     void surface_created(mir::shell::Session&, std::shared_ptr<mir::shell::Surface> const&) override;
     void destroying_surface(mir::shell::Session&, std::shared_ptr<mir::shell::Surface> const&) override;
 
+    void trusted_session_started(std::shared_ptr<mir::shell::TrustedSession> const& trusted_session) override;
+    void trusted_session_stopped(std::shared_ptr<mir::shell::TrustedSession> const& trusted_session) override;
+
 Q_SIGNALS:
     void sessionStarting(std::shared_ptr<mir::shell::Session> const& session);
     void sessionStopping(std::shared_ptr<mir::shell::Session> const& session);
@@ -44,6 +47,9 @@
 
     void sessionCreatedSurface(mir::shell::Session const*, std::shared_ptr<mir::shell::Surface> const&);
     void sessionDestroyingSurface(mir::shell::Session const*, std::shared_ptr<mir::shell::Surface> const&);
+
+    void trustedSessionStarted(std::shared_ptr<mir::shell::TrustedSession> const&);
+    void trustedSessionStopped(std::shared_ptr<mir::shell::TrustedSession> const&);
 };
 
 #endif // SESSIONLISTENER_H

=== modified file 'src/unity-mir/shellserverconfiguration.cpp'
--- src/unity-mir/shellserverconfiguration.cpp	2014-02-07 16:10:12 +0000
+++ src/unity-mir/shellserverconfiguration.cpp	2014-02-26 10:27:46 +0000
@@ -136,7 +136,7 @@
 // The rationale is that if when you do
 //     the_session_authorizer()
 // get a pointer that is unique means that Mir is not
-// holding the pointer and thus when we return from the 
+// holding the pointer and thus when we return from the
 //     sessionAuthorizer()
 // scope the unique pointer will be destroyed so we return 0
 //