Merge lp:~nick-dedekind/qtmir/prompt_sessions into lp:qtmir

[Nick Dedekind]

Added support for prompt sessions

Prompt Session providers are added as "surface children" of the application surface, affecting a "surface tree".

[Gerry Boland (gerboland)]

+ if (info->contains("trust-session-demo-trusted-helper") ||
+ info->contains("unity8")) {
you removed this from unity-mir, why need it here?

[Gerry Boland (gerboland)]

The Application constructor in unity-mir has this line added:
    connect(this, &Application::foregroundSessionChanged, this, &Application::updateScreenshot);
Do you not need the same here?

[Gerry Boland (gerboland)]

> The Application constructor in unity-mir has this line added:
> connect(this, &Application::foregroundSessionChanged, this,
> &Application::updateScreenshot);
> Do you not need the same here?
No you don't. Sorry, do ignore :)

[Gerry Boland (gerboland)]

+ while(iter.hasNext()) {
+ if (iter.next() == promptSession) {
+ iter.remove();
+ }
https://qt-project.org/doc/qt-5/qlist.html#removeOne ?

[Gerry Boland (gerboland)]

    if (info->startsWith("maliit-server") || info->contains("qt5/libexec/QtWebProcess")) {
        authorized = true;
- m_fenceNExt = true;
+ m_hiddenPIDs << pid;
        return;
    }

That was done in unity-mir, needed here too, no?

[Gerry Boland (gerboland)]

void ApplicationManager::onPromptProviderAdded
void ApplicationManager::onPromptProviderRemoved
These have gone away (comparing with unity-mir)?

[Gerry Boland (gerboland)]

+void MirSurfaceItem::addChildSurface(MirSurfaceItem* surface)
there's nothing preventing a surface being made a child of the same parent twice. Mind adding a quick check for that?

+QList<QObject*> MirSurfaceItem::childSurfaces() const
+{
+ QList<QObject*> children;
+ foreachChildSurface([&](MirSurfaceItem* child) { children.append(child); });
+ return children;
+}
Why being cast to QObjects? MirSurfaceItems are registered with the qml engine.

[Gerry Boland (gerboland)]

> void ApplicationManager::onPromptProviderAdded
> void ApplicationManager::onPromptProviderRemoved
> These have gone away (comparing with unity-mir)?
Ignore me again

[Gerry Boland (gerboland)]

+void getSurfaceDecendents(MirSurfaceItem* item, QList<MirSurfaceItem*>& surfaceChildren)
am not a fan of returning the list via the argument. Why did you decide to do that? Why not just create & return a list?

+void MirSurfaceManager::refreshPromptSessionSurfaces(const Application* application)
Totally not obvious what this is doing, comment please

+ qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::rehostPromptSessionSurfaces - appId=" << application->name();
comment cites incorrect method. Happens in 2 other places too.

+ MirSurfaceItem *surfaceItem = NULL;
nullptr please

+for(MirSurfaceItem* item
nit-pick: space after "for"

[Gerry Boland (gerboland)]

You added tests for this in unity-mir, I'd like the same tests added to this please.

review: Needs Fixing

[Nick Dedekind (nick-dedekind)]

> +void MirSurfaceItem::addChildSurface(MirSurfaceItem* surface)
> there's nothing preventing a surface being made a child of the same parent
> twice. Mind adding a quick check for that?
>
>
> +QList<QObject*> MirSurfaceItem::childSurfaces() const
> +{
> + QList<QObject*> children;
> + foreachChildSurface([&](MirSurfaceItem* child) { children.append(child); });
> + return children;
> +}
> Why being cast to QObjects? MirSurfaceItems are registered with the qml
> engine.

Doesn't work as an object array in qml unfortunately. Only converts QList<QObject*> properly.
QQmlListPropery<MirSurfaceItems> coulb be used, but they don't work as models for a repeater.

[Nick Dedekind (nick-dedekind)]

> + if (info->contains("trust-session-demo-trusted-helper") ||
> + info->contains("unity8")) {
> you removed this from unity-mir, why need it here?

Yes, need to remove. Did this before we had the trusted socket work in.

[Nick Dedekind (nick-dedekind)]

> if (info->startsWith("maliit-server") ||
> info->contains("qt5/libexec/QtWebProcess")) {
> authorized = true;
> - m_fenceNExt = true;
> + m_hiddenPIDs << pid;
> return;
> }
>
> That was done in unity-mir, needed here too, no?

Yep

[Nick Dedekind (nick-dedekind)]

> +void MirSurfaceItem::addChildSurface(MirSurfaceItem* surface)
> there's nothing preventing a surface being made a child of the same parent
> twice. Mind adding a quick check for that?

Private method. The check is made in public MirSurfaceItem::setParentSurface.

[Nick Dedekind (nick-dedekind)]

> +void getSurfaceDecendents(MirSurfaceItem* item, QList<MirSurfaceItem*>&
> surfaceChildren)
> am not a fan of returning the list via the argument. Why did you decide to do
> that? Why not just create & return a list?
>

Not the biggest fan either, but the method is recursive; and it's more efficient than concatenating lists together for each recursion.

[lp:~nick-dedekind/qtmir/prompt_sessions]

184. By Nick Dedekind on 2014-07-21

review comments

[Gerry Boland (gerboland)]

> > +void getSurfaceDecendents(MirSurfaceItem* item, QList<MirSurfaceItem*>&
> > surfaceChildren)
> > am not a fan of returning the list via the argument. Why did you decide to
> do
> > that? Why not just create & return a list?
> >
>
> Not the biggest fan either, but the method is recursive; and it's more
> efficient than concatenating lists together for each recursion.
Ok, but do please add a quick comment saying it's used in recursion

[Gerry Boland (gerboland)]

> > Why being cast to QObjects? MirSurfaceItems are registered with the qml
> > engine.
>
> Doesn't work as an object array in qml unfortunately. Only converts
> QList<QObject*> properly.
> QQmlListPropery<MirSurfaceItems> coulb be used, but they don't work as models
> for a repeater.
/me suspects this is possible. Maybe we can register QList<MirSurfaceItems*> as a qml type? If no luck, I'd like a TODO or FIXME explaining why the casting

[Gerry Boland (gerboland)]

This breaks the test run:

./taskcontroller_test: symbol lookup error: /home/phablet/dev/qtmir/prompt_sessions/build-android/tests/modules/TaskController/../../../src/modules/Unity/Application/libunityapplicationplugin.so: undefined symbol: _ZN21PromptSessionListener21promptSessionStartingERKSt10shared_ptrIN3mir5scene13PromptSessionEE

review: Needs Fixing

[Nick Dedekind (nick-dedekind)]

773 + delete item;

This is wrong. shouldn't be deleting items since we're not setting the application surface to null.. hmm.

[lp:~nick-dedekind/qtmir/prompt_sessions]

185. By Nick Dedekind on 2014-07-21

Added test for prompt session tracking

[Nick Dedekind (nick-dedekind)]

> You added tests for this in unity-mir, I'd like the same tests added to this
> please.

I've added a test for prompt session track, however, the surface tracking is next to impossible to mock with MAJOR effort. So I've left it for now.

[Nick Dedekind (nick-dedekind)]

review: Needs Fixing

[lp:~nick-dedekind/qtmir/prompt_sessions]

186. By Nick Dedekind on 2014-07-22

stop on destroy. disable input on surface destroy. emit removed signal rather than unparenting surfaces

[Nick Dedekind (nick-dedekind)]

review: Abstain

[lp:~nick-dedekind/qtmir/prompt_sessions]

187. By Nick Dedekind on 2014-07-22

rebased

188. By Nick Dedekind on 2014-07-22

removeOne promptSession

189. By Nick Dedekind on 2014-07-22

removeAll promptSession

[Gerry Boland (gerboland)]

+++ src/modules/Unity/Application/mirsurfaceitem.h
+ void removed();
how is removed different from being destroyed? I don't understand what this is for

review: Needs Information

[Nick Dedekind (nick-dedekind)]

> +++ src/modules/Unity/Application/mirsurfaceitem.h
> + void removed();
> how is removed different from being destroyed? I don't understand what this is
> for

If we destroy the surface, or remove it from the children, we will not be able to animate removal of the child items.
We can only do that once the UI says it's done with the surface.

[Nick Dedekind (nick-dedekind)]

> This breaks the test run:
>
> ./taskcontroller_test: symbol lookup error:
> /home/phablet/dev/qtmir/prompt_sessions/build-android/tests/modules/TaskContro
> ller/../../../src/modules/Unity/Application/libunityapplicationplugin.so:
> undefined symbol: _ZN21PromptSessionListener21promptSessionStartingERKSt10shar
> ed_ptrIN3mir5scene13PromptSessionEE

Not introduced by this MP. Exists in trunk.

ldd ./src/modules/Unity/Application/libunityapplicationplugin.so | grep qpa
        libqpa-mirserver.so => /usr/lib/x86_64-linux-gnu/qt5/plugins/platforms/libqpa-mirserver.so (0x00007f470de67000)

possibly something to do with:
src/modules/Unity/Application/Application.pro
QMAKE_RPATHDIR += $$[QT_INSTALL_PLUGINS]/platforms # where libqpa-mirserver.so is installed

[Nick Dedekind (nick-dedekind)]

> + while(iter.hasNext()) {
> + if (iter.next() == promptSession) {
> + iter.remove();
> + }
> https://qt-project.org/doc/qt-5/qlist.html#removeOne ?

Changed to removeAll

[lp:~nick-dedekind/qtmir/prompt_sessions]

190. By Nick Dedekind on 2014-07-23

added new files to common.pri

191. By Nick Dedekind on 2014-07-23

added fixme for returning QList<QObject*> children

192. By Nick Dedekind on 2014-07-23

use qmlquicklistproperty for children surfaces

[Nick Dedekind (nick-dedekind)]

> > > Why being cast to QObjects? MirSurfaceItems are registered with the qml
> > > engine.
> >
> > Doesn't work as an object array in qml unfortunately. Only converts
> > QList<QObject*> properly.
> > QQmlListPropery<MirSurfaceItems> coulb be used, but they don't work as
> models
> > for a repeater.
> /me suspects this is possible. Maybe we can register QList<MirSurfaceItems*>
> as a qml type? If no luck, I'd like a TODO or FIXME explaining why the casting

Changed to QQmlListPropery<MirSurfaceItem> . problem was with namespacing.

[Gerry Boland (gerboland)]

LGTM

review: Approve

=== modified file 'src/modules/Unity/Application/application.cpp'
--- src/modules/Unity/Application/application.cpp	2014-07-17 12:54:30 +0000
+++ src/modules/Unity/Application/application.cpp	2014-07-23 11:57:58 +0000
@@ -26,6 +26,9 @@
 // mir
 #include <mir/scene/session.h>
 #include <mir/scene/snapshot.h>
+#include <mir/scene/prompt_session_manager.h>
+
+namespace ms = mir::scene;
 
 namespace qtmir
 {
@@ -35,6 +38,7 @@
                          DesktopFileReader *desktopFileReader,
                          State state,
                          const QStringList &arguments,
+                         const std::shared_ptr<ms::PromptSessionManager>& promptSessionManager,
                          ApplicationManager *parent)
     : ApplicationInfoInterface(desktopFileReader->appId(), parent)
     , m_appMgr(parent)
@@ -49,6 +53,7 @@
     , m_arguments(arguments)
     , m_suspendTimer(new QTimer(this))
     , m_surface(nullptr)
+    , m_promptSessionManager(promptSessionManager)
     , m_screenShotGuard(new Guard)
 {
     qCDebug(QTMIR_APPLICATIONS) << "Application::Application - appId=" << desktopFileReader->appId() << "state=" << state;
@@ -75,6 +80,7 @@
         QMutexLocker lk(&screenshotMutex);
         m_screenShotGuard.clear();
     }
+    stopPromptSessions();
     delete m_desktopData;
     delete m_surface;
 }
@@ -244,6 +250,7 @@
         {
         case Application::Suspended:
             if (m_state == Application::Running) {
+                stopPromptSessions();
                 session()->set_lifecycle_state(mir_lifecycle_state_will_suspend);
                 m_suspendTimer->start(3000);
             }
@@ -261,6 +268,7 @@
             }
             break;
         case Application::Stopped:
+            stopPromptSessions();
             if (m_suspendTimer->isActive())
                 m_suspendTimer->stop();
             if (m_surface) {
@@ -406,4 +414,69 @@
     setFullscreen(m_surface && m_surface->state() == MirSurfaceItem::Fullscreen);
 }
 
+void Application::appendPromptSession(const std::shared_ptr<ms::PromptSession>& promptSession)
+{
+    qCDebug(QTMIR_APPLICATIONS) << "Application::appendPromptSession appId=" << appId()
+        << "promptSession=" << (promptSession ? promptSession.get() : nullptr);
+
+    m_promptSessions.append(promptSession);
+}
+
+void Application::removePromptSession(const std::shared_ptr<ms::PromptSession>& promptSession)
+{
+    qCDebug(QTMIR_APPLICATIONS) << "Application::removePromptSession appId=" << appId()
+        << "promptSession=" << (promptSession ? promptSession.get() : nullptr);
+
+    m_promptSessions.removeAll(promptSession);
+}
+
+void Application::stopPromptSessions()
+{
+    QList<std::shared_ptr<ms::PromptSession>> copy(m_promptSessions);
+
+    QListIterator<std::shared_ptr<ms::PromptSession>> it(copy);
+    for ( it.toBack(); it.hasPrevious(); ) {
+        m_promptSessionManager->stop_prompt_session(it.previous());
+    }
+}
+
+std::shared_ptr<ms::PromptSession> Application::activePromptSession() const
+{
+    if (m_promptSessions.count() > 0)
+        return m_promptSessions.back();
+    return nullptr;
+}
+
+void Application::foreachPromptSession(std::function<void(const std::shared_ptr<mir::scene::PromptSession>&)> f) const
+{
+    for (std::shared_ptr<mir::scene::PromptSession> promptSession : m_promptSessions) {
+        f(promptSession);
+    }
+}
+
+bool Application::containsProcess(pid_t pid) const
+{
+    if (m_pid == pid)
+        return true;
+
+    QListIterator<std::shared_ptr<ms::PromptSession>> iter(m_promptSessions);
+    while(iter.hasNext()) {
+        std::shared_ptr<ms::PromptSession> promptSession = iter.next();
+
+        std::shared_ptr<ms::Session> helper = m_promptSessionManager->helper_for(promptSession);
+        if (helper && helper->process_id() == pid)
+            return true;
+
+        bool found = false;
+        m_promptSessionManager->for_each_provider_in(promptSession,
+            [&found, pid](std::shared_ptr<ms::Session> const& provider) {
+                if (provider->process_id() == pid)
+                    found = true;
+            });
+        if (found)
+            return true;
+    }
+    return false;
+}
+
 } // namespace qtmir

=== modified file 'src/modules/Unity/Application/application.h'
--- src/modules/Unity/Application/application.h	2014-07-17 11:47:18 +0000
+++ src/modules/Unity/Application/application.h	2014-07-23 11:57:58 +0000
@@ -31,7 +31,13 @@
 // local
 #include "mirsurfaceitem.h"
 
-namespace mir { namespace scene { class Session; }}
+namespace mir {
+    namespace scene {
+        class Session;
+        class PromptSession;
+        class PromptSessionManager;
+    }
+}
 
 namespace qtmir
 {
@@ -69,6 +75,7 @@
                 DesktopFileReader *desktopFileReader,
                 State state,
                 const QStringList &arguments,
+                const std::shared_ptr<mir::scene::PromptSessionManager>& promptSessionManager,
                 ApplicationManager *parent);
     virtual ~Application();
 
@@ -97,10 +104,14 @@
     QString exec() const;
     bool fullscreen() const;
     std::shared_ptr<mir::scene::Session> session() const;
+    std::shared_ptr<mir::scene::PromptSession> activePromptSession() const;
+    void foreachPromptSession(std::function<void(const std::shared_ptr<mir::scene::PromptSession>&)> f) const;
 
     Stages supportedStages() const;
     SupportedOrientations supportedOrientations() const;
 
+    bool containsProcess(pid_t pid) const;
+
 public Q_SLOTS:
     void suspend();
     void resume();
@@ -127,6 +138,10 @@
     void setSession(const std::shared_ptr<mir::scene::Session>& session);
     void setSurface(MirSurfaceItem *surface);
 
+    void appendPromptSession(const std::shared_ptr<mir::scene::PromptSession>& session);
+    void removePromptSession(const std::shared_ptr<mir::scene::PromptSession>& session);
+    void stopPromptSessions();
+
     void updateFullscreenProperty();
 
     ApplicationManager* m_appMgr;
@@ -147,6 +162,8 @@
     QTimer* m_suspendTimer;
     SupportedOrientations m_supportedOrientations;
     MirSurfaceItem *m_surface;
+    QList<std::shared_ptr<mir::scene::PromptSession>> m_promptSessions;
+    std::shared_ptr<mir::scene::PromptSessionManager> const m_promptSessionManager;
 
     class Guard {};
     QSharedPointer<Guard> m_screenShotGuard;

=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2014-07-21 19:38:54 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2014-07-23 11:57:58 +0000
@@ -28,6 +28,7 @@
 #include "mirserverconfiguration.h"
 #include "nativeinterface.h"
 #include "sessionlistener.h"
+#include "promptsessionlistener.h"
 #include "sessionauthorizer.h"
 #include "taskcontroller.h"
 #include "logging.h"
@@ -35,6 +36,7 @@
 // mir
 #include <mir/scene/surface.h>
 #include <mir/scene/session.h>
+#include <mir/scene/prompt_session_manager.h>
 #include <mir/graphics/display.h>
 #include <mir/graphics/display_buffer.h>
 #include <mircommon/mir/geometry/rectangles.h>
@@ -106,6 +108,14 @@
                      manager, &ApplicationManager::onSessionCreatedSurface);
 }
 
+void connectToPromptSessionListener(ApplicationManager * manager, PromptSessionListener * listener)
+{
+    QObject::connect(listener, &PromptSessionListener::promptSessionStarting,
+                     manager, &ApplicationManager::onPromptSessionStarting);
+    QObject::connect(listener, &PromptSessionListener::promptSessionStopping,
+                     manager, &ApplicationManager::onPromptSessionStopping);
+}
+
 void connectToSessionAuthorizer(ApplicationManager *manager, SessionAuthorizer *authorizer)
 {
     QObject::connect(authorizer, &SessionAuthorizer::requestAuthorizationForSession,
@@ -142,6 +152,7 @@
 
     SessionListener *sessionListener = static_cast<SessionListener*>(nativeInterface->nativeResourceForIntegration("SessionListener"));
     SessionAuthorizer *sessionAuthorizer = static_cast<SessionAuthorizer*>(nativeInterface->nativeResourceForIntegration("SessionAuthorizer"));
+    PromptSessionListener *promptSessionListener = static_cast<PromptSessionListener*>(nativeInterface->nativeResourceForIntegration("PromptSessionListener"));
 
     QSharedPointer<upstart::ApplicationController> appController(new upstart::ApplicationController());
     QSharedPointer<TaskController> taskController(new TaskController(nullptr, appController));
@@ -161,6 +172,7 @@
                                          );
 
     connectToSessionListener(appManager, sessionListener);
+    connectToPromptSessionListener(appManager, promptSessionListener);
     connectToSessionAuthorizer(appManager, sessionAuthorizer);
     connectToTaskController(appManager, taskController.data());
 
@@ -194,7 +206,6 @@
     , m_taskController(taskController)
     , m_desktopFileReaderFactory(desktopFileReaderFactory)
     , m_procInfo(procInfo)
-    , m_fenceNext(false)
     , m_suspended(false)
 {
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::ApplicationManager (this=%p)" << this;
@@ -450,6 +461,7 @@
                 m_desktopFileReaderFactory->createInstance(appId, m_taskController->findDesktopFileForAppId(appId)),
                 Application::Starting,
                 arguments,
+                m_mirConfig->the_prompt_session_manager(),
                 this);
 
     if (!application->isValid()) {
@@ -476,7 +488,9 @@
                     m_taskController,
                     m_desktopFileReaderFactory->createInstance(appId, m_taskController->findDesktopFileForAppId(appId)),
                     Application::Starting,
-                    QStringList(), this);
+                    QStringList(),
+                    m_mirConfig->the_prompt_session_manager(),
+                    this);
 
         if (!application->isValid()) {
             qWarning() << "Unable to instantiate application with appId" << appId;
@@ -690,6 +704,7 @@
 
     if (info->startsWith("maliit-server") || info->contains("qt5/libexec/QtWebProcess")) {
         authorized = true;
+        m_hiddenPIDs << pid;
         return;
     }
 
@@ -748,7 +763,13 @@
                                 << "application list with appId:" << desktopData->appId();
 
     QStringList arguments(info->asStringList());
-    application = new Application(m_taskController, desktopData, Application::Starting, arguments, this);
+    application = new Application(
+        m_taskController,
+        desktopData,
+        Application::Starting,
+        arguments,
+        m_mirConfig->the_prompt_session_manager(),
+        this);
     application->setPid(pid);
     application->setStage(stage);
     application->setCanBeResumed(false);
@@ -760,15 +781,13 @@
 {
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onSessionStarting - sessionName=" <<  session->name().c_str();
 
-    if (m_fenceNext) { // needed to ignore sessions created by non-user processes (e.g. maliit)
-        m_fenceNext = false;
-        return;
-    }
-
-    Application* application = findApplicationWithPid(session->process_id());
+    Application* application = findApplicationWithPid(session->process_id(), false);
     if (application && application->state() != Application::Running) {
         application->setSession(session);
     } else {
+        if (m_hiddenPIDs.contains(session->process_id())) {
+            return;
+        }
         qCWarning(QTMIR_APPLICATIONS) << "ApplicationManager::onSessionStarting - unmanaged application starting";
     }
 }
@@ -778,7 +797,7 @@
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onSessionStopping - sessionName=" << session->name().c_str();
 
     // in case application closed not by hand of shell, check again here:
-    Application* application = findApplicationWithSession(session);
+    Application* application = findApplicationWithSession(session, false);
     if (application) {
         /* Can remove the application from the running apps list immediately in these curcumstances:
          *  1. application is not managed by upstart (this message from Mir is only notice the app has stopped, must do
@@ -805,6 +824,7 @@
             application->setState(Application::Stopped);
         }
     }
+    m_hiddenPIDs.removeOne(session->process_id());
 }
 
 void ApplicationManager::onSessionCreatedSurface(ms::Session const* session,
@@ -813,29 +833,45 @@
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onSessionCreatedSurface - sessionName=" << session->name().c_str();
     Q_UNUSED(surface);
 
-    Application* application = findApplicationWithSession(session);
+    Application* application = findApplicationWithSession(session, false);
     if (application && application->state() == Application::Starting) {
         m_dbusWindowStack->WindowCreated(0, application->appId());
         application->setState(Application::Running);
     }
 }
 
-Application* ApplicationManager::findApplicationWithSession(const std::shared_ptr<ms::Session> &session)
+void ApplicationManager::onPromptSessionStarting(const std::shared_ptr<ms::PromptSession>& promptSession)
 {
-    return findApplicationWithSession(session.get());
+    qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onPromptSessionStarting - promptSession=" << promptSession.get();
+
+    Application* app = findApplicationWithSession(m_mirConfig->the_prompt_session_manager()->application_for(promptSession), false);
+    if (app) {
+        app->appendPromptSession(promptSession);
+    }
 }
 
-Application* ApplicationManager::findApplicationWithSession(const ms::Session *session)
+void ApplicationManager::onPromptSessionStopping(const std::shared_ptr<ms::PromptSession>& promptSession)
 {
+    qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onPromptSessionStopping - promptSession=" << promptSession.get();
+
     for (Application *app : m_applications) {
-        if (app->session().get() == session) {
-            return app;
-        }
+        app->removePromptSession(promptSession);
     }
-    return nullptr;
-}
-
-Application* ApplicationManager::findApplicationWithPid(const qint64 pid)
+}
+
+Application* ApplicationManager::findApplicationWithSession(const std::shared_ptr<ms::Session> &session, bool includeChildSessions)
+{
+    return findApplicationWithSession(session.get(), includeChildSessions);
+}
+
+Application* ApplicationManager::findApplicationWithSession(const ms::Session *session, bool includeChildSessions)
+{
+    if (!session)
+        return nullptr;
+    return findApplicationWithPid(session->process_id(), includeChildSessions);
+}
+
+Application* ApplicationManager::findApplicationWithPid(const qint64 pid, bool includeChildSessions)
 {
     if (pid <= 0)
         return nullptr;
@@ -844,6 +880,24 @@
         if (app->m_pid == pid) {
             return app;
         }
+
+        if (includeChildSessions && app->containsProcess(pid)) {
+            return app;
+        }
+    }
+    return nullptr;
+}
+
+Application* ApplicationManager::findApplicationWithPromptSession(const mir::scene::PromptSession* promptSession)
+{
+    for (Application *app : m_applications) {
+        bool found = false;
+        app->foreachPromptSession([&](const std::shared_ptr<mir::scene::PromptSession>& ps) {
+            if (promptSession == ps.get())
+                found = true;
+        });
+        if (found)
+            return app;
     }
     return nullptr;
 }

=== modified file 'src/modules/Unity/Application/application_manager.h'
--- src/modules/Unity/Application/application_manager.h	2014-07-18 11:27:10 +0000
+++ src/modules/Unity/Application/application_manager.h	2014-07-23 11:57:58 +0000
@@ -35,6 +35,7 @@
     namespace scene {
         class Session;
         class Surface;
+        class PromptSession;
     }
 }
 
@@ -108,7 +109,7 @@
     bool isEmpty() const { return rowCount() == 0; }
 
     const QList<Application*> &list() const { return m_applications; }
-    qtmir::Application* findApplicationWithPid(const qint64 pid);
+    qtmir::Application* findApplicationWithPid(const qint64 pid, bool includeChildSessions);
 
 public Q_SLOTS:
     void authorizeSession(const quint64 pid, bool &authorized);
@@ -118,6 +119,9 @@
 
     void onSessionCreatedSurface(mir::scene::Session const*, std::shared_ptr<mir::scene::Surface> const&);
 
+    void onPromptSessionStarting(const std::shared_ptr<mir::scene::PromptSession>& promptSession);
+    void onPromptSessionStopping(const std::shared_ptr<mir::scene::PromptSession>& promptSession);
+
     void onProcessStarting(const QString& appId);
     void onProcessStopped(const QString& appId);
     void onProcessFailed(const QString& appId, const bool duringStartup);
@@ -135,14 +139,16 @@
     void setFocused(Application *application);
     void add(Application *application);
     void remove(Application* application);
-    Application* findApplicationWithSession(const std::shared_ptr<mir::scene::Session> &session);
-    Application* findApplicationWithSession(const mir::scene::Session *session);
+    Application* findApplicationWithSession(const std::shared_ptr<mir::scene::Session> &session, bool includeChildSessions);
+    Application* findApplicationWithSession(const mir::scene::Session *session, bool includeChildSessions);
     Application* applicationForStage(Application::Stage stage);
     QModelIndex findIndex(Application* application);
     bool suspendApplication(Application *application);
     void resumeApplication(Application *application);
     QString toString() const;
 
+    Application* findApplicationWithPromptSession(const mir::scene::PromptSession* promptSession);
+
     QSharedPointer<MirServerConfiguration> m_mirConfig;
 
     QList<Application*> m_applications;
@@ -155,7 +161,7 @@
     QSharedPointer<DesktopFileReader::Factory> m_desktopFileReaderFactory;
     QSharedPointer<ProcInfo> m_procInfo;
     static ApplicationManager* the_application_manager;
-    bool m_fenceNext;
+    QList<pid_t> m_hiddenPIDs;
     QString m_nextFocusedAppId;
     bool m_suspended;
 

=== modified file 'src/modules/Unity/Application/dbuswindowstack.cpp'
--- src/modules/Unity/Application/dbuswindowstack.cpp	2014-07-17 14:01:08 +0000
+++ src/modules/Unity/Application/dbuswindowstack.cpp	2014-07-23 11:57:58 +0000
@@ -46,7 +46,7 @@
 {
     AppIdDesktopFile res;
     ApplicationManager *appMgr = static_cast<ApplicationManager*>(parent());
-    const Application *app = appMgr->findApplicationWithPid(pid);
+    const Application *app = appMgr->findApplicationWithPid(pid, false);
     if (app) {
         res.app_id = app->appId();
         res.desktop_file = app->desktopFile();

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.cpp'
--- src/modules/Unity/Application/mirsurfaceitem.cpp	2014-07-22 09:48:50 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.cpp	2014-07-23 11:57:58 +0000
@@ -260,6 +260,7 @@
     , m_surface(surface)
     , m_application(application)
     , m_firstFrameDrawn(false)
+    , m_parentSurface(nullptr)
     , m_textureProvider(nullptr)
 {
     qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::MirSurfaceItem";
@@ -319,11 +320,22 @@
     //m_surface->configure(mir_surface_attrib_focus, mir_surface_unfocused);
     connect(this, &QQuickItem::activeFocusChanged, this, &MirSurfaceItem::updateMirSurfaceFocus);
 
-    connect(application.data(), &Application::stateChanged, this, &MirSurfaceItem::onApplicationStateChanged);
+    if (m_application) {
+        connect(application.data(), &Application::stateChanged, this, &MirSurfaceItem::onApplicationStateChanged);
+    }
 }
 
 MirSurfaceItem::~MirSurfaceItem()
 {
+    QList<MirSurfaceItem*> children(m_children);
+    for (MirSurfaceItem* child : children) {
+        child->setParentSurface(nullptr);
+        delete child;
+    }
+    if (m_parentSurface) {
+        m_parentSurface->removeChildSurface(this);
+    }
+
     qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::~MirSurfaceItem - this=" << this;
     QMutexLocker locker(&m_mutex);
     m_surface->remove_observer(m_surfaceObserver);
@@ -335,6 +347,15 @@
 void MirSurfaceItem::release()
 {
     qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::release - this=" << this;
+
+    QList<MirSurfaceItem*> children(m_children);
+    for (MirSurfaceItem* child : children) {
+        child->release();
+    }
+    if (m_parentSurface) {
+        m_parentSurface->removeChildSurface(this);
+    }
+
     if (m_application) {
         m_application->setSurface(nullptr);
     }
@@ -684,6 +705,75 @@
         || !m_application;
 }
 
+void MirSurfaceItem::setParentSurface(MirSurfaceItem* surface)
+{
+    if (m_parentSurface == surface || surface == this)
+        return;
+
+    if (m_parentSurface) {
+        m_parentSurface->removeChildSurface(this);
+    }
+
+    m_parentSurface = surface;
+
+    if (m_parentSurface) {
+        m_parentSurface->addChildSurface(this);
+    }
+    Q_EMIT parentSurfaceChanged(surface);
+}
+
+MirSurfaceItem* MirSurfaceItem::parentSurface() const
+{
+    return m_parentSurface;
+}
+
+void MirSurfaceItem::addChildSurface(MirSurfaceItem* surface)
+{
+    qDebug() << "MirSurfaceItem::addChildSurface " << surface->name() << " to " << name();
+
+    m_children.append(surface);
+    Q_EMIT childSurfacesChanged();
+}
+
+void MirSurfaceItem::removeChildSurface(MirSurfaceItem* surface)
+{
+    if (m_children.contains(surface)) {
+        m_children.removeOne(surface);
+
+        Q_EMIT childSurfacesChanged();
+    }
+}
+
+void MirSurfaceItem::foreachChildSurface(std::function<void(MirSurfaceItem*)> f) const
+{
+    for(MirSurfaceItem* child : m_children) {
+        f(child);
+    }
+}
+
+QQmlListProperty<MirSurfaceItem> MirSurfaceItem::childSurfaces()
+{
+    return QQmlListProperty<MirSurfaceItem>(this,
+                                            0,
+                                            MirSurfaceItem::childSurfaceCount,
+                                            MirSurfaceItem::childSurfaceAt);
+}
+
+int MirSurfaceItem::childSurfaceCount(QQmlListProperty<MirSurfaceItem> *prop)
+{
+    MirSurfaceItem *p = qobject_cast<MirSurfaceItem*>(prop->object);
+    return p->m_children.count();
+}
+
+MirSurfaceItem* MirSurfaceItem::childSurfaceAt(QQmlListProperty<MirSurfaceItem> *prop, int index)
+{
+    MirSurfaceItem *p = qobject_cast<MirSurfaceItem*>(prop->object);
+
+    if (index < 0 || index >= p->m_children.count())
+        return nullptr;
+    return p->m_children[index];
+}
+
 } // namespace qtmir
 
 #include "mirsurfaceitem.moc"

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.h'
--- src/modules/Unity/Application/mirsurfaceitem.h	2014-07-17 12:54:30 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.h	2014-07-23 11:57:58 +0000
@@ -25,6 +25,7 @@
 #include <QSet>
 #include <QQuickItem>
 #include <QTimer>
+#include <QQmlListProperty>
 
 // mir
 #include <mir/scene/surface.h>
@@ -72,6 +73,8 @@
     Q_PROPERTY(Type type READ type NOTIFY typeChanged)
     Q_PROPERTY(State state READ state NOTIFY stateChanged)
     Q_PROPERTY(QString name READ name NOTIFY nameChanged)
+    Q_PROPERTY(MirSurfaceItem *parentSurface READ parentSurface NOTIFY parentSurfaceChanged DESIGNABLE false FINAL)
+    Q_PROPERTY(QQmlListProperty<qtmir::MirSurfaceItem> childSurfaces READ childSurfaces NOTIFY childSurfacesChanged DESIGNABLE false)
 
 public:
     explicit MirSurfaceItem(std::shared_ptr<mir::scene::Surface> surface,
@@ -118,13 +121,21 @@
 
     void setApplication(Application *app);
 
+    void setParentSurface(MirSurfaceItem* surface);
+    MirSurfaceItem* parentSurface() const;
+    void foreachChildSurface(std::function<void(MirSurfaceItem*)> f) const;
+
 Q_SIGNALS:
     void typeChanged();
     void stateChanged();
     void nameChanged();
+    void parentSurfaceChanged(MirSurfaceItem* surface);
+    void childSurfacesChanged();
     void surfaceDestroyed();
     void firstFrameDrawn(MirSurfaceItem *item);
 
+    void removed();
+
 protected Q_SLOTS:
     void onApplicationStateChanged();
 
@@ -141,6 +152,13 @@
 
     QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *);
 
+    void addChildSurface(MirSurfaceItem* surface);
+    void removeChildSurface(MirSurfaceItem* surface);
+
+    QQmlListProperty<MirSurfaceItem> childSurfaces();
+    static int childSurfaceCount(QQmlListProperty<MirSurfaceItem> *prop);
+    static MirSurfaceItem* childSurfaceAt(QQmlListProperty<MirSurfaceItem> *prop, int index);
+
 private Q_SLOTS:
     void surfaceDamaged();
     void dropPendingBuffers();
@@ -175,6 +193,9 @@
     QPointer<Application> m_application;
     bool m_firstFrameDrawn;
 
+    MirSurfaceItem* m_parentSurface;
+    QList<MirSurfaceItem*> m_children;
+
     QMirSurfaceTextureProvider *m_textureProvider;
 
     static UbuntuKeyboardInfo *m_ubuntuKeyboardInfo;

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.cpp'
--- src/modules/Unity/Application/mirsurfacemanager.cpp	2014-07-22 10:24:24 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.cpp	2014-07-23 11:57:58 +0000
@@ -29,6 +29,12 @@
 #include "sessionlistener.h"
 #include "surfaceconfigurator.h"
 #include "logging.h"
+#include "promptsessionlistener.h"
+
+// mir
+#include <mir/scene/prompt_session.h>
+#include <mir/scene/prompt_session_manager.h>
+
 
 Q_LOGGING_CATEGORY(QTMIR_SURFACES, "qtmir.surfaces")
 
@@ -38,38 +44,62 @@
 
 MirSurfaceManager *MirSurfaceManager::the_surface_manager = nullptr;
 
+
+void connectToSessionListener(MirSurfaceManager *manager, SessionListener *listener)
+{
+    QObject::connect(listener, &SessionListener::sessionCreatedSurface,
+                     manager, &MirSurfaceManager::onSessionCreatedSurface);
+    QObject::connect(listener, &SessionListener::sessionDestroyingSurface,
+                     manager, &MirSurfaceManager::onSessionDestroyingSurface);
+}
+
+void connectToSurfaceConfigurator(MirSurfaceManager *manager, SurfaceConfigurator *surfaceConfigurator)
+{
+    QObject::connect(surfaceConfigurator, &SurfaceConfigurator::surfaceAttributeChanged,
+                     manager, &MirSurfaceManager::onSurfaceAttributeChanged);
+}
+
+void connectToPromptSessionListener(MirSurfaceManager * manager, PromptSessionListener * listener)
+{
+    QObject::connect(listener, &PromptSessionListener::promptProviderAdded,
+                     manager, &MirSurfaceManager::onPromptProviderAdded);
+    QObject::connect(listener, &PromptSessionListener::promptProviderRemoved,
+                     manager, &MirSurfaceManager::onPromptProviderRemoved);
+}
+
 MirSurfaceManager* MirSurfaceManager::singleton()
 {
     if (!the_surface_manager) {
-        the_surface_manager = new MirSurfaceManager();
+
+        NativeInterface *nativeInterface = dynamic_cast<NativeInterface*>(QGuiApplication::platformNativeInterface());
+
+        if (!nativeInterface) {
+            qCritical("ERROR: Unity.Application QML plugin requires use of the 'mirserver' QPA plugin");
+            QGuiApplication::quit();
+            return nullptr;
+        }
+
+        SessionListener *sessionListener = static_cast<SessionListener*>(nativeInterface->nativeResourceForIntegration("SessionListener"));
+        SurfaceConfigurator *surfaceConfigurator = static_cast<SurfaceConfigurator*>(nativeInterface->nativeResourceForIntegration("SessionConfigurator"));
+        PromptSessionListener *promptSessionListener = static_cast<PromptSessionListener*>(nativeInterface->nativeResourceForIntegration("PromptSessionListener"));
+
+        the_surface_manager = new MirSurfaceManager(nativeInterface->m_mirConfig);
+
+        connectToSessionListener(the_surface_manager, sessionListener);
+        connectToSurfaceConfigurator(the_surface_manager, surfaceConfigurator);
+        connectToPromptSessionListener(the_surface_manager, promptSessionListener);
     }
     return the_surface_manager;
 }
 
-MirSurfaceManager::MirSurfaceManager(QObject *parent)
+MirSurfaceManager::MirSurfaceManager(
+        const QSharedPointer<MirServerConfiguration>& mirConfig,
+        QObject *parent)
     : QAbstractListModel(parent)
+    , m_mirConfig(mirConfig)
 {
     qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::MirSurfaceManager - this=" << this;
     setObjectName("qtmir::SurfaceManager");
-
-    NativeInterface *nativeInterface = dynamic_cast<NativeInterface*>(QGuiApplication::platformNativeInterface());
-
-    if (!nativeInterface) {
-        qCritical("ERROR: Unity.Application QML plugin requires use of the 'mirserver' QPA plugin");
-        QGuiApplication::quit();
-        return;
-    }
-
-    SessionListener *sessionListener = static_cast<SessionListener*>(nativeInterface->nativeResourceForIntegration("SessionListener"));
-    SurfaceConfigurator *surfaceConfigurator = static_cast<SurfaceConfigurator*>(nativeInterface->nativeResourceForIntegration("SessionConfigurator"));
-
-    QObject::connect(sessionListener, &SessionListener::sessionCreatedSurface,
-                     this, &MirSurfaceManager::onSessionCreatedSurface);
-    QObject::connect(sessionListener, &SessionListener::sessionDestroyingSurface,
-                     this, &MirSurfaceManager::onSessionDestroyingSurface);
-
-    QObject::connect(surfaceConfigurator, &SurfaceConfigurator::surfaceAttributeChanged,
-                     this, &MirSurfaceManager::onSurfaceAttributeChanged);
 }
 
 MirSurfaceManager::~MirSurfaceManager()
@@ -94,11 +124,12 @@
 
     ApplicationManager* appMgr = static_cast<ApplicationManager*>(ApplicationManager::singleton());
 
-    Application* application = appMgr->findApplicationWithSession(session);
+    Application* application = appMgr->findApplicationWithSession(session, false);
     auto qmlSurface = new MirSurfaceItem(surface, application);
     {
         QMutexLocker lock(&m_mutex);
         m_mirSurfaceToItemHash.insert(surface.get(), qmlSurface);
+        m_mirSessionToItemHash.insert(session, qmlSurface);
     }
 
     beginInsertRows(QModelIndex(), 0, 0);
@@ -126,6 +157,7 @@
         {
             QMutexLocker lock(&m_mutex);
             m_mirSurfaceToItemHash.remove(m_mirSurfaceToItemHash.key(mirSurfaceItem));
+            m_mirSessionToItemHash.remove(m_mirSessionToItemHash.key(mirSurfaceItem));
         }
 
         int i = m_surfaceItems.indexOf(mirSurfaceItem);
@@ -136,6 +168,8 @@
             Q_EMIT countChanged();
         }
     });
+
+    refreshPromptSessionSurfaces(session);
 }
 
 void MirSurfaceManager::onSessionDestroyingSurface(const mir::scene::Session *session,
@@ -154,6 +188,7 @@
         {
             QMutexLocker lock(&m_mutex);
             m_mirSurfaceToItemHash.remove(m_mirSurfaceToItemHash.key(item));
+            m_mirSessionToItemHash.remove(m_mirSessionToItemHash.key(item));
         }
 
         int i = m_surfaceItems.indexOf(item);
@@ -163,11 +198,32 @@
             endRemoveRows();
             Q_EMIT countChanged();
         }
+
         return;
     }
 
     qCritical() << "MirSurfaceManager::onSessionDestroyingSurface: unable to find MirSurfaceItem corresponding"
                 << "to surface=" << surface.get() << "surface.name=" << surface->name().c_str();
+
+    refreshPromptSessionSurfaces(session);
+}
+
+void MirSurfaceManager::onPromptProviderAdded(const mir::scene::PromptSession *promptSession,
+                                              const std::shared_ptr<mir::scene::Session> &)
+{
+    ApplicationManager* appMgr = static_cast<ApplicationManager*>(ApplicationManager::singleton());
+    Application* application = appMgr->findApplicationWithPromptSession(promptSession);
+
+    refreshPromptSessionSurfaces(application);
+}
+
+void MirSurfaceManager::onPromptProviderRemoved(const mir::scene::PromptSession *promptSession,
+                                                const std::shared_ptr<mir::scene::Session> &)
+{
+    ApplicationManager* appMgr = static_cast<ApplicationManager*>(ApplicationManager::singleton());
+    Application* application = appMgr->findApplicationWithPromptSession(promptSession);
+
+    refreshPromptSessionSurfaces(application);
 }
 
 // NB: Surface might be a dangling pointer here, so refrain from dereferencing it.
@@ -209,4 +265,73 @@
     return m_surfaceItems[index];
 }
 
+void getSurfaceDecendents(MirSurfaceItem* item, QList<MirSurfaceItem*>& surfaceChildren)
+{
+    // recursive function. fetch all decendent surface items as a list.
+    item->foreachChildSurface([&surfaceChildren](MirSurfaceItem* child) {
+        surfaceChildren.append(child);
+        getSurfaceDecendents(child, surfaceChildren);
+    });
+}
+
+void MirSurfaceManager::refreshPromptSessionSurfaces(const mir::scene::Session* session)
+{
+    ApplicationManager* appMgr = static_cast<ApplicationManager*>(ApplicationManager::singleton());
+    Application* application = appMgr->findApplicationWithSession(session, true);
+
+    refreshPromptSessionSurfaces(application);
+}
+
+void MirSurfaceManager::refreshPromptSessionSurfaces(const Application* application)
+{
+    // Re-contruct the child surface heirachy from prompt session providers.
+    // Each provider becomes the parent surface of the next surface,
+    // with the application surface at the top of the heirachy.
+
+    if (!application)
+        return;
+    qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::refreshPromptSessionSurfaces - appId=" << application->name();
+
+    std::shared_ptr<ms::PromptSessionManager> manager = m_mirConfig->the_prompt_session_manager();
+
+    MirSurfaceItem* parentItem = application->surface();
+    if (!parentItem) {
+        return;
+    }
+
+    QList<MirSurfaceItem*> surfaceChildren;
+    getSurfaceDecendents(parentItem, surfaceChildren);
+
+    auto refreshFn = [&](const std::shared_ptr<mir::scene::PromptSession>& promptSession) {
+
+        manager->for_each_provider_in(promptSession,
+            [&](const std::shared_ptr<ms::Session> &session) {
+                QMutexLocker lock(&m_mutex);
+
+                auto it = m_mirSessionToItemHash.find(session.get());
+                MirSurfaceItem *surfaceItem = nullptr;
+                while (it != m_mirSessionToItemHash.end() && it.key() == session.get()) {
+                    surfaceItem = it.value();
+
+                    qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::refreshPromptSessionSurfaces - " << surfaceItem->name() << "->setParent(" << parentItem->name() << ")";
+                    surfaceItem->setParentSurface(parentItem);
+                    surfaceChildren.removeOne(surfaceItem);
+
+                    ++it;
+                }
+                // last session surface is parent of next provider session surface.
+                if (surfaceItem) {
+                    parentItem = surfaceItem;
+                }
+            });
+
+        for (MirSurfaceItem* item : surfaceChildren) {
+            qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::rehostPromptSessionSurfaces - remove: " << item->name() << " from " << item->parentSurface()->name();
+            Q_EMIT item->removed();
+        }
+    };
+
+    application->foreachPromptSession(refreshFn);
+}
+
 } // namespace qtmir

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.h'
--- src/modules/Unity/Application/mirsurfacemanager.h	2014-07-17 16:20:41 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.h	2014-07-23 11:57:58 +0000
@@ -31,11 +31,19 @@
 // local
 #include "mirsurfaceitem.h"
 
-namespace mir { namespace scene { class Surface; class Session; }}
+namespace mir {
+    namespace scene {
+        class Surface;
+        class Session;
+        class PromptSession;
+    }
+}
+
+class MirServerConfiguration;
 
 namespace qtmir {
 
-class ShellServerConfiguration;
+class Application;
 
 class MirSurfaceManager : public QAbstractListModel
 {
@@ -51,7 +59,6 @@
 
     static MirSurfaceManager* singleton();
 
-    MirSurfaceManager(QObject *parent = 0);
     ~MirSurfaceManager();
 
     // from QAbstractItemModel
@@ -76,10 +83,26 @@
 
     void onSurfaceAttributeChanged(const mir::scene::Surface *, MirSurfaceAttrib, int);
 
+    void onPromptProviderAdded(const mir::scene::PromptSession *, const std::shared_ptr<mir::scene::Session> &);
+    void onPromptProviderRemoved(const mir::scene::PromptSession *, const std::shared_ptr<mir::scene::Session> &);
+
+protected:
+    MirSurfaceManager(
+        const QSharedPointer<MirServerConfiguration>& mirConfig,
+        QObject *parent = 0
+    );
+
+    void refreshPromptSessionSurfaces(const mir::scene::Session *session);
+    void refreshPromptSessionSurfaces(const Application* application);
+
+    void removePromptSessionSurface(MirSurfaceItem* surface);
+
 private:
+    QSharedPointer<MirServerConfiguration> m_mirConfig;
+
     QHash<const mir::scene::Surface *, MirSurfaceItem *> m_mirSurfaceToItemHash;
+    QMultiHash<const mir::scene::Session *, MirSurfaceItem *> m_mirSessionToItemHash;
     QList<MirSurfaceItem*> m_surfaceItems;
-    ShellServerConfiguration* m_mirServer;
     static MirSurfaceManager *the_surface_manager;
     QMutex m_mutex;
 };

=== modified file 'src/modules/Unity/Application/plugin.cpp'
--- src/modules/Unity/Application/plugin.cpp	2014-07-17 17:31:51 +0000
+++ src/modules/Unity/Application/plugin.cpp	2014-07-23 11:57:58 +0000
@@ -54,6 +54,7 @@
         Q_ASSERT(QLatin1String(uri) == QLatin1String("Unity.Application"));
 
         qRegisterMetaType<qtmir::ApplicationManager*>("ApplicationManager*"); //need for queueing signals
+        qRegisterMetaType<qtmir::MirSurfaceItem*>("MirSurfaceItem*");
 
         qmlRegisterUncreatableType<unity::shell::application::ApplicationManagerInterface>(
                     uri, 0, 1, "ApplicationManagerInterface", "Abstract interface. Cannot be created in QML");

=== modified file 'src/platforms/mirserver/mirserver.pro'
--- src/platforms/mirserver/mirserver.pro	2014-07-07 19:36:13 +0000
+++ src/platforms/mirserver/mirserver.pro	2014-07-23 11:57:58 +0000
@@ -28,6 +28,7 @@
     sessionauthorizer.cpp \
     sessionlistener.cpp \
     surfaceconfigurator.cpp \
+    promptsessionlistener.cpp \
     messageprocessor.cpp \
     mirplacementstrategy.cpp \
     mirserverconfiguration.cpp \
@@ -52,6 +53,7 @@
     qmirserver.h \
     sessionauthorizer.h \
     sessionlistener.h \
+    promptsessionlistener.h \
     surfaceconfigurator.h \
     logging.h \
     messageprocessor.h \

=== modified file 'src/platforms/mirserver/mirserverconfiguration.cpp'
--- src/platforms/mirserver/mirserverconfiguration.cpp	2014-07-07 19:33:56 +0000
+++ src/platforms/mirserver/mirserverconfiguration.cpp	2014-07-23 11:57:58 +0000
@@ -22,6 +22,7 @@
 #include "mirglconfig.h"
 #include "mirplacementstrategy.h"
 #include "mirserverstatuslistener.h"
+#include "promptsessionlistener.h"
 #include "sessionlistener.h"
 #include "surfaceconfigurator.h"
 #include "sessionauthorizer.h"
@@ -69,6 +70,16 @@
         });
 }
 
+std::shared_ptr<ms::PromptSessionListener>
+MirServerConfiguration::the_prompt_session_listener()
+{
+    return prompt_session_listener(
+        [this]
+        {
+            return std::make_shared<PromptSessionListener>();
+        });
+}
+
 std::shared_ptr<ms::SurfaceConfigurator>
 MirServerConfiguration::the_surface_configurator()
 {
@@ -186,6 +197,14 @@
     return static_cast<SessionListener*>(sharedPtr.get());
 }
 
+PromptSessionListener *MirServerConfiguration::promptSessionListener()
+{
+    auto sharedPtr = the_prompt_session_listener();
+    if (sharedPtr.unique()) return 0;
+
+    return static_cast<PromptSessionListener*>(sharedPtr.get());
+}
+
 SurfaceConfigurator *MirServerConfiguration::surfaceConfigurator()
 {
     auto sharedPtr = the_surface_configurator();

=== modified file 'src/platforms/mirserver/mirserverconfiguration.h'
--- src/platforms/mirserver/mirserverconfiguration.h	2014-07-02 11:06:22 +0000
+++ src/platforms/mirserver/mirserverconfiguration.h	2014-07-23 11:57:58 +0000
@@ -30,6 +30,7 @@
 class SessionListener;
 class SessionAuthorizer;
 class SurfaceConfigurator;
+class PromptSessionListener;
 
 class MirServerConfiguration : public QObject, public mir::DefaultServerConfiguration
 {
@@ -38,6 +39,7 @@
     Q_PROPERTY(SessionAuthorizer* sessionAuthorizer READ sessionAuthorizer CONSTANT)
     Q_PROPERTY(SessionListener* sessionListener READ sessionListener CONSTANT)
     Q_PROPERTY(SurfaceConfigurator* surfaceConfigurator READ surfaceConfigurator CONSTANT)
+    Q_PROPERTY(PromptSessionListener* promptSessionListener READ promptSessionListener CONSTANT)
 
 public:
     MirServerConfiguration(int argc, char const* argv[], QObject* parent = 0);
@@ -47,6 +49,7 @@
     std::shared_ptr<mir::compositor::Compositor> the_compositor() override;
     std::shared_ptr<mir::scene::PlacementStrategy> the_placement_strategy() override;
     std::shared_ptr<mir::scene::SessionListener> the_session_listener() override;
+    std::shared_ptr<mir::scene::PromptSessionListener> the_prompt_session_listener() override;
     std::shared_ptr<mir::scene::SurfaceConfigurator> the_surface_configurator() override;
     std::shared_ptr<mir::frontend::SessionAuthorizer> the_session_authorizer() override;
     std::shared_ptr<mir::input::InputDispatcher> the_input_dispatcher() override;
@@ -59,6 +62,7 @@
     // getters
     SessionAuthorizer *sessionAuthorizer();
     SessionListener *sessionListener();
+    PromptSessionListener *promptSessionListener();
     SurfaceConfigurator *surfaceConfigurator();
 
 private:

=== modified file 'src/platforms/mirserver/nativeinterface.cpp'
--- src/platforms/mirserver/nativeinterface.cpp	2014-05-16 16:45:00 +0000
+++ src/platforms/mirserver/nativeinterface.cpp	2014-07-23 11:57:58 +0000
@@ -33,6 +33,8 @@
         result = m_mirConfig->surfaceConfigurator();
     else if (resource == "SessionListener")
         result = m_mirConfig->sessionListener();
+    else if (resource == "PromptSessionListener")
+        result = m_mirConfig->promptSessionListener();
 
     return result;
 }

=== added file 'src/platforms/mirserver/promptsessionlistener.cpp'
--- src/platforms/mirserver/promptsessionlistener.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/promptsessionlistener.cpp	2014-07-23 11:57:58 +0000
@@ -0,0 +1,64 @@
+/*
+ * 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 "promptsessionlistener.h"
+#include "logging.h"
+
+namespace ms = mir::scene;
+
+Q_DECLARE_METATYPE(std::shared_ptr<ms::PromptSession>)
+
+PromptSessionListener::PromptSessionListener(QObject *parent) :
+    QObject(parent)
+{
+    qCDebug(QTMIR_MIR_MESSAGES) << "PromptSessionListener::PromptSessionListener - this=" << this;
+    qRegisterMetaType<std::shared_ptr<ms::PromptSession>>("std::shared_ptr<mir::scene::PromptSession>");
+}
+
+PromptSessionListener::~PromptSessionListener()
+{
+    qCDebug(QTMIR_MIR_MESSAGES) << "PromptSessionListener::~PromptSessionListener - this=" << this;
+}
+
+void PromptSessionListener::starting(std::shared_ptr<ms::PromptSession> const& prompt_session)
+{
+    qCDebug(QTMIR_MIR_MESSAGES) << "PromptSessionListener::starting - this=" << this << "prompt_session=" << prompt_session.get();
+    Q_EMIT promptSessionStarting(prompt_session);
+}
+
+void PromptSessionListener::stopping(std::shared_ptr<ms::PromptSession> const& prompt_session)
+{
+    qCDebug(QTMIR_MIR_MESSAGES) << "PromptSessionListener::stopping - this=" << this << "prompt_session=" << prompt_session.get();
+    Q_EMIT promptSessionStopping(prompt_session);
+}
+
+void PromptSessionListener::prompt_provider_added(ms::PromptSession const& prompt_session,
+                                                  std::shared_ptr<ms::Session> const& prompt_provider)
+{
+    qCDebug(QTMIR_MIR_MESSAGES) << "PromptSessionListener::prompt_provider_added - this=" << this
+                                << "prompt_session=" << &prompt_session
+                                << "prompt_provider=" << prompt_provider.get();
+    Q_EMIT promptProviderAdded(&prompt_session, prompt_provider);
+}
+
+void PromptSessionListener::prompt_provider_removed(ms::PromptSession const& prompt_session,
+                                                    std::shared_ptr<ms::Session> const& prompt_provider)
+{
+    qCDebug(QTMIR_MIR_MESSAGES) << "PromptSessionListener::prompt_provider_removed - this=" << this
+                                << "prompt_session=" << &prompt_session
+                                << "prompt_provider=" << prompt_provider.get();
+    Q_EMIT promptProviderRemoved(&prompt_session, prompt_provider);
+}

=== added file 'src/platforms/mirserver/promptsessionlistener.h'
--- src/platforms/mirserver/promptsessionlistener.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/promptsessionlistener.h	2014-07-23 11:57:58 +0000
@@ -0,0 +1,47 @@
+/*
+ * 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 PROMPTSESSIONLISTENER_H
+#define PROMPTSESSIONLISTENER_H
+
+#include <QObject>
+
+#include "mir/scene/prompt_session_listener.h"
+
+class PromptSessionListener : public QObject, public mir::scene::PromptSessionListener
+{
+    Q_OBJECT
+public:
+    explicit PromptSessionListener(QObject *parent = 0);
+    ~PromptSessionListener();
+
+    void starting(std::shared_ptr<mir::scene::PromptSession> const& prompt_session) override;
+    void stopping(std::shared_ptr<mir::scene::PromptSession> const& prompt_session) override;
+
+    void prompt_provider_added(mir::scene::PromptSession const& prompt_session,
+        std::shared_ptr<mir::scene::Session> const& prompt_provider) override;
+    void prompt_provider_removed(mir::scene::PromptSession const& prompt_session,
+        std::shared_ptr<mir::scene::Session> const& prompt_provider) override;
+
+Q_SIGNALS:
+    void promptSessionStarting(std::shared_ptr<mir::scene::PromptSession> const& session);
+    void promptSessionStopping(std::shared_ptr<mir::scene::PromptSession> const& session);
+
+    void promptProviderAdded(mir::scene::PromptSession const*, std::shared_ptr<mir::scene::Session> const&);
+    void promptProviderRemoved(mir::scene::PromptSession const*, std::shared_ptr<mir::scene::Session> const&);
+};
+
+#endif // SESSIONLISTENER_H

=== modified file 'tests/modules/ApplicationManager/application_manager_test.cpp'
--- tests/modules/ApplicationManager/application_manager_test.cpp	2014-07-17 11:47:18 +0000
+++ tests/modules/ApplicationManager/application_manager_test.cpp	2014-07-23 11:57:58 +0000
@@ -37,9 +37,39 @@
 #include "mock_proc_info.h"
 #include "mock_session.h"
 #include "mock_focus_controller.h"
+#include "mock_prompt_session_manager.h"
+#include "mock_prompt_session.h"
 
 using namespace qtmir;
 
+namespace ms = mir::scene;
+
+class TestMirConfiguration: public MirServerConfiguration
+{
+public:
+    TestMirConfiguration()
+    : MirServerConfiguration(0, nullptr)
+    , mock_prompt_session_manager(std::make_shared<testing::MockPromptSessionManager>())
+    {
+    }
+
+    std::shared_ptr<ms::PromptSessionManager> the_prompt_session_manager() override
+    {
+        return prompt_session_manager([this]()
+           ->std::shared_ptr<ms::PromptSessionManager>
+           {
+               return the_mock_prompt_session_manager();
+           });
+    }
+
+    std::shared_ptr<testing::MockPromptSessionManager> the_mock_prompt_session_manager()
+    {
+        return mock_prompt_session_manager;
+    }
+
+    std::shared_ptr<testing::MockPromptSessionManager> mock_prompt_session_manager;
+};
+
 class ApplicationManagerTests : public ::testing::Test
 {
 public:
@@ -50,7 +80,7 @@
                 [](ProcessController::OomController*){})
         }
         , mirConfig{
-              QSharedPointer<MirServerConfiguration> (new MirServerConfiguration(0, nullptr))
+            QSharedPointer<TestMirConfiguration> (new TestMirConfiguration)
         }
         , taskController{
               QSharedPointer<TaskController> (
@@ -111,7 +141,7 @@
     testing::NiceMock<testing::MockApplicationController> appController;
     testing::NiceMock<testing::MockProcInfo> procInfo;
     testing::NiceMock<testing::MockDesktopFileReaderFactory> desktopFileReaderFactory;
-    QSharedPointer<MirServerConfiguration> mirConfig;
+    QSharedPointer<TestMirConfiguration> mirConfig;
     QSharedPointer<TaskController> taskController;
     ApplicationManager applicationManager;
 };
@@ -1901,3 +1931,22 @@
         cv.wait(lk, [&] { return done; } );
     }
 }
+
+TEST_F(ApplicationManagerTests, applicationTracksPromptSession)
+{
+    using namespace testing;
+    quint64 procId1 = 5551;
+
+    auto application = startApplication(procId1, "webapp");
+    auto promptSession = std::make_shared<MockPromptSession>();
+
+    ON_CALL(*mirConfig->the_mock_prompt_session_manager(), application_for(_)).WillByDefault(Return(application->session()));
+
+    applicationManager.onPromptSessionStarting(promptSession);
+
+    EXPECT_EQ(application->activePromptSession(), promptSession);
+
+    applicationManager.onPromptSessionStopping(promptSession);
+
+    EXPECT_EQ(application->activePromptSession(), nullptr);
+}

=== modified file 'tests/modules/common/common.pri'
--- tests/modules/common/common.pri	2014-07-02 23:35:16 +0000
+++ tests/modules/common/common.pri	2014-07-23 11:57:58 +0000
@@ -10,6 +10,8 @@
     ../common/mock_oom_controller.h \
     ../common/mock_process_controller.h \
     ../common/mock_proc_info.h \
+    ../common/mock_prompt_session.h
+    ../common/mock_prompt_session_manager.h
     ../common/mock_session.h
 
 INCLUDEPATH += ../../../src/modules \

=== added file 'tests/modules/common/mock_prompt_session.h'
--- tests/modules/common/mock_prompt_session.h	1970-01-01 00:00:00 +0000
+++ tests/modules/common/mock_prompt_session.h	2014-07-23 11:57:58 +0000
@@ -0,0 +1,31 @@
+/*
+ * 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_PROMPT_SESSION_H
+#define MOCK_MIR_PROMPT_SESSION_H
+
+#include <mir/scene/prompt_session.h>
+#include <gmock/gmock.h>
+
+namespace testing
+{
+struct MockPromptSession : public mir::scene::PromptSession
+{
+};
+}
+
+#endif // MOCK_MIR_PROMPT_SESSION_H

=== added file 'tests/modules/common/mock_prompt_session_manager.h'
--- tests/modules/common/mock_prompt_session_manager.h	1970-01-01 00:00:00 +0000
+++ tests/modules/common/mock_prompt_session_manager.h	2014-07-23 11:57:58 +0000
@@ -0,0 +1,55 @@
+/*
+ * 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_SCENE_PROMPT_SESSION_MANAGER_H_
+#define MOCK_MIR_SCENE_PROMPT_SESSION_MANAGER_H_
+
+#include "mir/scene/prompt_session_manager.h"
+#include "mir/scene/prompt_session_creation_parameters.h"
+
+#include <gmock/gmock.h>
+
+namespace testing
+{
+class MockPromptSessionManager: public mir::scene::PromptSessionManager
+{
+public:
+    MOCK_CONST_METHOD2(start_prompt_session_for, std::shared_ptr<mir::scene::PromptSession>(std::shared_ptr<mir::scene::Session> const&,
+        mir::scene::PromptSessionCreationParameters const&));
+
+    MOCK_CONST_METHOD1(stop_prompt_session, void(std::shared_ptr<mir::scene::PromptSession> const&));
+
+    MOCK_CONST_METHOD2(add_prompt_provider, void(std::shared_ptr<mir::scene::PromptSession> const&,
+        std::shared_ptr<mir::scene::Session> const&));
+
+    MOCK_CONST_METHOD2(add_prompt_provider_by_pid, void(std::shared_ptr<mir::scene::PromptSession> const&,
+        pid_t));
+
+    MOCK_CONST_METHOD1(add_expected_session, void(std::shared_ptr<mir::scene::Session> const&));
+
+    MOCK_CONST_METHOD1(remove_session, void(std::shared_ptr<mir::scene::Session> const&));
+
+    MOCK_CONST_METHOD1(application_for, std::shared_ptr<mir::scene::Session>(std::shared_ptr<mir::scene::PromptSession> const&));
+
+    MOCK_CONST_METHOD1(helper_for, std::shared_ptr<mir::scene::Session>(std::shared_ptr<mir::scene::PromptSession> const&));
+
+    MOCK_CONST_METHOD2(for_each_provider_in, void(std::shared_ptr<mir::scene::PromptSession> const&,
+        std::function<void(std::shared_ptr<mir::scene::Session> const&)> const&));
+};
+} // namespace testing
+
+#endif // MOCK_MIR_SCENE_PROMPT_SESSION_MANAGER_H_