Merge lp:~dandrader/qtmir/frozenApps-lp1295623 into lp:qtmir

[Daniel d'Andrada]

MirSurfaceItem: Ensure all touch sequences sent to Mir surface are properly ended.

In order to have a testable MirSurfaceItem I had to mock qtmir::Session.
To mock qtmir::Session I had to define a qtmir::SessionInterface. That caused many s/Session/SessionInterfaces throughout the code base.
When creating a testing::MockSession for qtmir::Session it clashed with the existing testing::MockSession for mir::scene::Surface. Thus I had to refactor the namespacing of all mocks.

So most of the diff is just about refactoring code to enable a MirSurfaceItem unit test.

* Are there any related MPs required for this MP to build/function as expected? Please list.
No

* Did you perform an exploratory manual test run of your code change and any related functionality?
Yes

* If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
Not applicable

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:253
http://jenkins.qa.ubuntu.com/job/qtmir-ci/67/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/67
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/67

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/67/rebuild

review: Approve (continuous-integration)

[Michael Zanetti (mzanetti)]

Confirming this fixes the issue. Code looks ok despite the fact that we're drifting even further from unity-api. However, there's plans to restructure this. So ok with me.

 * Did you perform an exploratory manual test run of the code change and any related functionality?

yes

 * Did CI run pass? If not, please explain why.

yes

review: Approve

=== modified file 'src/modules/Unity/Application/Application.pro'
--- src/modules/Unity/Application/Application.pro	2014-09-07 19:42:33 +0000
+++ src/modules/Unity/Application/Application.pro	2014-09-11 21:25:08 +0000
@@ -63,6 +63,7 @@
     processcontroller.h \
     proc_info.h \
     session.h \
+    session_interface.h \
     sessionmodel.h \
     upstart/applicationcontroller.h
 
 
=== modified file 'src/modules/Unity/Application/application.cpp'
--- src/modules/Unity/Application/application.cpp	2014-09-07 19:42:14 +0000
+++ src/modules/Unity/Application/application.cpp	2014-09-11 21:25:08 +0000
@@ -183,9 +183,9 @@
         m_session->setApplication(this);
         m_session->setState(state());
 
-        connect(m_session, &Session::suspended, this, &Application::onSessionSuspended);
-        connect(m_session, &Session::resumed, this, &Application::onSessionResumed);
-        connect(m_session, &Session::fullscreenChanged, this, &Application::fullscreenChanged);
+        connect(m_session, &SessionInterface::suspended, this, &Application::onSessionSuspended);
+        connect(m_session, &SessionInterface::resumed, this, &Application::onSessionResumed);
+        connect(m_session, &SessionInterface::fullscreenChanged, this, &Application::fullscreenChanged);
 
         if (oldFullscreen != fullscreen())
             Q_EMIT fullscreenChanged(fullscreen());
 
=== modified file 'src/modules/Unity/Application/mirsurfaceitem.cpp'
--- src/modules/Unity/Application/mirsurfaceitem.cpp	2014-09-07 19:42:14 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.cpp	2014-09-11 21:25:08 +0000
@@ -87,7 +87,10 @@
     return true;
 }
 
-bool fillInMirEvent(MirEvent &mirEvent, QTouchEvent *qtEvent)
+bool fillInMirEvent(MirEvent &mirEvent,
+                    const QList<QTouchEvent::TouchPoint> &qtTouchPoints,
+                    Qt::TouchPointStates qtTouchPointStates,
+                    ulong qtTimestamp)
 {
     mirEvent.type = mir_event_type_motion;
 
@@ -99,14 +102,14 @@
     // NB: it's assumed that touch points are pressed and released
     // one at a time.
 
-    if (qtEvent->touchPointStates().testFlag(Qt::TouchPointPressed)) {
-        if (qtEvent->touchPoints().count() > 1) {
+    if (qtTouchPointStates.testFlag(Qt::TouchPointPressed)) {
+        if (qtTouchPoints.count() > 1) {
             mirEvent.motion.action = mir_motion_action_pointer_down;
         } else {
             mirEvent.motion.action = mir_motion_action_down;
         }
-    } else if (qtEvent->touchPointStates().testFlag(Qt::TouchPointReleased)) {
-        if (qtEvent->touchPoints().count() > 1) {
+    } else if (qtTouchPointStates.testFlag(Qt::TouchPointReleased)) {
+        if (qtTouchPoints.count() > 1) {
             mirEvent.motion.action = mir_motion_action_pointer_up;
         } else {
             mirEvent.motion.action = mir_motion_action_up;
@@ -138,18 +141,17 @@
 
     // Note: QtEventFeeder scales the event time down, scale it back up - precision is
     // lost but the time difference should still be accurate to milliseconds
-    mirEvent.motion.event_time = static_cast<nsecs_t>(qtEvent->timestamp()) * 1000000;
-
-    mirEvent.motion.pointer_count = qtEvent->touchPoints().count();
-
-    auto touchPoints = qtEvent->touchPoints();
-    for (int i = 0; i < touchPoints.count(); ++i) {
-        auto touchPoint = touchPoints.at(i);
+    mirEvent.motion.event_time = static_cast<nsecs_t>(qtTimestamp) * 1000000;
+
+    mirEvent.motion.pointer_count = qtTouchPoints.count();
+
+    for (int i = 0; i < qtTouchPoints.count(); ++i) {
+        auto touchPoint = qtTouchPoints.at(i);
         auto &pointer = mirEvent.motion.pointer_coordinates[i];
 
         // FIXME: https://bugs.launchpad.net/mir/+bug/1311699
         // When multiple touch points are transmitted with a MirEvent
-        // and one of them (only one is allowed) indicates a pressed
+        // and one of them (only one is allowed) indicates a presse
         // state change the index is encoded in the second byte of the
         // action value.
         const int mir_motion_event_pointer_index_shift = 8;
@@ -234,7 +236,7 @@
 UbuntuKeyboardInfo *MirSurfaceItem::m_ubuntuKeyboardInfo = nullptr;
 
 MirSurfaceItem::MirSurfaceItem(std::shared_ptr<mir::scene::Surface> surface,
-                               QPointer<Session> session,
+                               SessionInterface* session,
                                QQuickItem *parent)
     : QQuickItem(parent)
     , m_surface(surface)
@@ -242,6 +244,7 @@
     , m_firstFrameDrawn(false)
     , m_live(true)
     , m_textureProvider(nullptr)
+    , m_lastTouchEvent(nullptr)
 {
     qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::MirSurfaceItem";
 
@@ -316,6 +319,8 @@
     m_surface->remove_observer(m_surfaceObserver);
     if (m_textureProvider)
         m_textureProvider->deleteLater();
+
+    delete m_lastTouchEvent;
 }
 
 // For QML to destroy this surface
@@ -329,7 +334,7 @@
     deleteLater();
 }
 
-Session* MirSurfaceItem::session() const
+SessionInterface* MirSurfaceItem::session() const
 {
     return m_session.data();
 }
@@ -478,31 +483,115 @@
     }
 }
 
+QString MirSurfaceItem::appId() const
+{
+    QString appId;
+    if (session() && session()->application()) {
+        appId = session()->application()->appId();
+    } else {
+        appId.append("-");
+    }
+    return appId;
+}
+
+void MirSurfaceItem::endCurrentTouchSequence(ulong timestamp)
+{
+    MirEvent mirEvent;
+
+    Q_ASSERT(m_lastTouchEvent);
+    Q_ASSERT(m_lastTouchEvent->type != QEvent::TouchEnd);
+    Q_ASSERT(m_lastTouchEvent->touchPoints.count() > 0);
+
+    TouchEvent touchEvent = *m_lastTouchEvent;
+    touchEvent.timestamp = timestamp;
+
+    // Remove all already released touch points
+    int i = 0;
+    while (i < touchEvent.touchPoints.count()) {
+        if (touchEvent.touchPoints[i].state() == Qt::TouchPointReleased) {
+            touchEvent.touchPoints.removeAt(i);
+        } else {
+            ++i;
+        }
+    }
+
+    // And release the others one by one as Mir expects one press/release per event
+    while (touchEvent.touchPoints.count() > 0) {
+        touchEvent.touchPoints[0].setState(Qt::TouchPointReleased);
+
+        touchEvent.updateTouchPointStatesAndType();
+
+        if (fillInMirEvent(mirEvent, touchEvent.touchPoints,
+                           touchEvent.touchPointStates, touchEvent.timestamp)) {
+            m_surface->consume(mirEvent);
+        }
+        *m_lastTouchEvent = touchEvent;
+
+        touchEvent.touchPoints.removeAt(0);
+    }
+}
+
+void MirSurfaceItem::validateAndDeliverTouchEvent(int eventType,
+            ulong timestamp,
+            const QList<QTouchEvent::TouchPoint> &touchPoints,
+            Qt::TouchPointStates touchPointStates)
+{
+    MirEvent mirEvent;
+
+    if (eventType == QEvent::TouchBegin && m_lastTouchEvent && m_lastTouchEvent->type != QEvent::TouchEnd) {
+        qCWarning(QTMIR_SURFACES) << qPrintable(QString("MirSurfaceItem(%1) - Got a QEvent::TouchBegin while "
+            "there's still an active/unfinished touch sequence.").arg(appId()));
+        // Qt forgot to end the last touch sequence. Let's do it ourselves.
+        endCurrentTouchSequence(timestamp);
+    }
+
+    if (fillInMirEvent(mirEvent, touchPoints, touchPointStates, timestamp)) {
+        m_surface->consume(mirEvent);
+    }
+
+    if (!m_lastTouchEvent) {
+        m_lastTouchEvent = new TouchEvent;
+    }
+    m_lastTouchEvent->type = eventType;
+    m_lastTouchEvent->timestamp = timestamp;
+    m_lastTouchEvent->touchPoints = touchPoints;
+    m_lastTouchEvent->touchPointStates = touchPointStates;
+}
+
 void MirSurfaceItem::touchEvent(QTouchEvent *event)
 {
-    MirEvent mirEvent;
-    if (type() == InputMethod && event->type() == QEvent::TouchBegin) {
+    bool accepted = processTouchEvent(event->type(),
+            event->timestamp(),
+            event->touchPoints(),
+            event->touchPointStates());
+    event->setAccepted(accepted);
+}
+
+bool MirSurfaceItem::processTouchEvent(
+        int eventType,
+        ulong timestamp,
+        const QList<QTouchEvent::TouchPoint> &touchPoints,
+        Qt::TouchPointStates touchPointStates)
+{
+    bool accepted = true;
+    if (type() == InputMethod && eventType == QEvent::TouchBegin) {
         // FIXME: Hack to get the VKB use case working while we don't have the proper solution in place.
-        if (hasTouchInsideUbuntuKeyboard(event)) {
-            if (fillInMirEvent(mirEvent, event)) {
-                m_surface->consume(mirEvent);
-            }
+        if (hasTouchInsideUbuntuKeyboard(touchPoints)) {
+            validateAndDeliverTouchEvent(eventType, timestamp, touchPoints, touchPointStates);
         } else {
-            event->ignore();
+            accepted = false;
         }
 
     } else {
         // NB: If we are getting QEvent::TouchUpdate or QEvent::TouchEnd it's because we've
         // previously accepted the corresponding QEvent::TouchBegin
-        if (fillInMirEvent(mirEvent, event)) {
-            m_surface->consume(mirEvent);
-        }
+        validateAndDeliverTouchEvent(eventType, timestamp, touchPoints, touchPointStates);
     }
+    return accepted;
 }
 
-bool MirSurfaceItem::hasTouchInsideUbuntuKeyboard(QTouchEvent *event)
+bool MirSurfaceItem::hasTouchInsideUbuntuKeyboard(const QList<QTouchEvent::TouchPoint> &touchPoints)
 {
-    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
     for (int i = 0; i < touchPoints.count(); ++i) {
         QPoint pos = touchPoints.at(i).pos().toPoint();
         if (pos.x() >= m_ubuntuKeyboardInfo->x()
@@ -639,15 +728,15 @@
     m_frameDropperTimer.start();
 }
 
-void MirSurfaceItem::setSession(Session *session)
+void MirSurfaceItem::setSession(SessionInterface *session)
 {
     m_session = session;
 }
 
-void MirSurfaceItem::onSessionStateChanged(Session::State state)
+void MirSurfaceItem::onSessionStateChanged(SessionInterface::State state)
 {
     switch (state) {
-        case Session::State::Running:
+        case SessionInterface::State::Running:
             syncSurfaceSizeWithItemSize();
             break;
         default:
@@ -676,6 +765,22 @@
         || !m_session;
 }
 
+void MirSurfaceItem::TouchEvent::updateTouchPointStatesAndType()
+{
+    touchPointStates = 0;
+    for (int i = 0; i < touchPoints.count(); ++i) {
+        touchPointStates |= touchPoints.at(i).state();
+    }
+
+    if (touchPointStates == Qt::TouchPointReleased) {
+        type = QEvent::TouchEnd;
+    } else if (touchPointStates == Qt::TouchPointPressed) {
+        type = QEvent::TouchBegin;
+    } else {
+        type = QEvent::TouchUpdate;
+    }
+}
+
 } // namespace qtmir
 
 #include "mirsurfaceitem.moc"
 
=== modified file 'src/modules/Unity/Application/mirsurfaceitem.h'
--- src/modules/Unity/Application/mirsurfaceitem.h	2014-08-29 14:58:07 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.h	2014-09-11 21:25:08 +0000
@@ -32,7 +32,7 @@
 #include <mir/scene/surface_observer.h>
 #include <mir_toolkit/common.h>
 
-#include "session.h"
+#include "session_interface.h"
 #include "ubuntukeyboardinfo.h"
 
 namespace qtmir {
@@ -78,7 +78,7 @@
 
 public:
     explicit MirSurfaceItem(std::shared_ptr<mir::scene::Surface> surface,
-                            QPointer<Session> session,
+                            SessionInterface* session,
                             QQuickItem *parent = 0);
     ~MirSurfaceItem();
 
@@ -107,7 +107,7 @@
     State state() const;
     QString name() const;
     bool live() const;
-    Session *session() const;
+    SessionInterface *session() const;
 
     Q_INVOKABLE void release();
 
@@ -120,7 +120,13 @@
 
     bool isFirstFrameDrawn() const { return m_firstFrameDrawn; }
 
-    void setSession(Session *app);
+    void setSession(SessionInterface *app);
+
+    // to allow easy touch event injection from tests
+    bool processTouchEvent(int eventType,
+            ulong timestamp,
+            const QList<QTouchEvent::TouchPoint> &touchPoints,
+            Qt::TouchPointStates touchPointStates);
 
 Q_SIGNALS:
     void typeChanged();
@@ -130,7 +136,7 @@
     void firstFrameDrawn(MirSurfaceItem *item);
 
 protected Q_SLOTS:
-    void onSessionStateChanged(Session::State state);
+    void onSessionStateChanged(SessionInterface::State state);
 
 protected:
     void mousePressEvent(QMouseEvent *event) override;
@@ -167,15 +173,22 @@
     void setAttribute(const MirSurfaceAttrib, const int);
     void setSurfaceValid(const bool);
 
-    bool hasTouchInsideUbuntuKeyboard(QTouchEvent *event);
+    bool hasTouchInsideUbuntuKeyboard(const QList<QTouchEvent::TouchPoint> &touchPoints);
     void syncSurfaceSizeWithItemSize();
 
     bool clientIsRunning() const;
 
+    QString appId() const;
+    void endCurrentTouchSequence(ulong timestamp);
+    void validateAndDeliverTouchEvent(int eventType,
+            ulong timestamp,
+            const QList<QTouchEvent::TouchPoint> &touchPoints,
+            Qt::TouchPointStates touchPointStates);
+
     QMutex m_mutex;
 
     std::shared_ptr<mir::scene::Surface> m_surface;
-    QPointer<Session> m_session;
+    QPointer<SessionInterface> m_session;
     bool m_firstFrameDrawn;
     bool m_live;
 
@@ -189,6 +202,24 @@
 
     QTimer m_updateMirSurfaceSizeTimer;
 
+    class TouchEvent {
+    public:
+        TouchEvent &operator= (const QTouchEvent &qtEvent) {
+            type = qtEvent.type();
+            timestamp = qtEvent.timestamp();
+            touchPoints = qtEvent.touchPoints();
+            touchPointStates = qtEvent.touchPointStates();
+            return *this;
+        }
+
+        void updateTouchPointStatesAndType();
+
+        int type;
+        ulong timestamp;
+        QList<QTouchEvent::TouchPoint> touchPoints;
+        Qt::TouchPointStates touchPointStates;
+    } *m_lastTouchEvent;
+
     friend class MirSurfaceManager;
 };
 
 
=== modified file 'src/modules/Unity/Application/mirsurfacemanager.cpp'
--- src/modules/Unity/Application/mirsurfacemanager.cpp	2014-09-07 19:42:33 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.cpp	2014-09-11 21:25:08 +0000
@@ -99,21 +99,21 @@
     m_mirSurfaceToItemHash.clear();
 }
 
-void MirSurfaceManager::onSessionCreatedSurface(const mir::scene::Session *session,
+void MirSurfaceManager::onSessionCreatedSurface(const mir::scene::Session *mirSession,
                                                 const std::shared_ptr<mir::scene::Surface> &surface)
 {
-    qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::onSessionCreatedSurface - session=" << session
+    qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::onSessionCreatedSurface - mirSession=" << mirSession
                             << "surface=" << surface.get() << "surface.name=" << surface->name().c_str();
 
-    Session* sessionItem = m_sessionManager->findSession(session);
-    auto qmlSurface = new MirSurfaceItem(surface, sessionItem);
+    SessionInterface* session = m_sessionManager->findSession(mirSession);
+    auto qmlSurface = new MirSurfaceItem(surface, session);
     {
         QMutexLocker lock(&m_mutex);
         m_mirSurfaceToItemHash.insert(surface.get(), qmlSurface);
     }
 
-    if (sessionItem)
-        sessionItem->setSurface(qmlSurface);
+    if (session)
+        session->setSurface(qmlSurface);
 
     // Only notify QML of surface creation once it has drawn its first frame.
     connect(qmlSurface, &MirSurfaceItem::firstFrameDrawn, this, [&](MirSurfaceItem *item) {
 
=== modified file 'src/modules/Unity/Application/plugin.cpp'
--- src/modules/Unity/Application/plugin.cpp	2014-09-01 16:07:27 +0000
+++ src/modules/Unity/Application/plugin.cpp	2014-09-11 21:25:08 +0000
@@ -65,6 +65,7 @@
         qRegisterMetaType<qtmir::MirSurfaceItem*>("MirSurfaceItem*");
         qRegisterMetaType<qtmir::MirSurfaceItemModel*>("MirSurfaceItemModel*");
         qRegisterMetaType<qtmir::Session*>("Session*");
+        qRegisterMetaType<qtmir::SessionInterface*>("SessionInterface*");
         qRegisterMetaType<qtmir::SessionModel*>("SessionModel*");
 
         qmlRegisterUncreatableType<unity::shell::application::ApplicationManagerInterface>(
 
=== modified file 'src/modules/Unity/Application/session.cpp'
--- src/modules/Unity/Application/session.cpp	2014-09-01 16:07:27 +0000
+++ src/modules/Unity/Application/session.cpp	2014-09-11 21:25:08 +0000
@@ -34,13 +34,15 @@
 
 namespace ms = mir::scene;
 
+using unity::shell::application::ApplicationInfoInterface;
+
 namespace qtmir
 {
 
 Session::Session(const std::shared_ptr<ms::Session>& session,
                  const std::shared_ptr<ms::PromptSessionManager>& promptSessionManager,
                  QObject *parent)
-    : QObject(parent)
+    : SessionInterface(parent)
     , m_session(session)
     , m_application(nullptr)
     , m_surface(nullptr)
@@ -72,8 +74,8 @@
     qCDebug(QTMIR_SESSIONS) << "Session::~Session() " << name();
     stopPromptSessions();
 
-    QList<Session*> children(m_children->list());
-    for (Session* child : children) {
+    QList<SessionInterface*> children(m_children->list());
+    for (SessionInterface* child : children) {
         delete child;
     }
     if (m_parentSession) {
@@ -112,7 +114,7 @@
     return m_session;
 }
 
-Application* Session::application() const
+ApplicationInfoInterface* Session::application() const
 {
     return m_application;
 }
@@ -127,7 +129,7 @@
     }
 }
 
-Session* Session::parentSession() const
+SessionInterface* Session::parentSession() const
 {
     return m_parentSession;
 }
@@ -147,12 +149,12 @@
     return m_live;
 }
 
-void Session::setApplication(Application* application)
+void Session::setApplication(ApplicationInfoInterface* application)
 {
     if (m_application == application)
         return;
 
-    m_application = application;
+    m_application = static_cast<Application*>(application);
     Q_EMIT applicationChanged(application);
 }
 
@@ -251,7 +253,7 @@
         m_state = state;
         Q_EMIT stateChanged(state);
 
-        foreachChildSession([state](Session* session) {
+        foreachChildSession([state](SessionInterface* session) {
             session->setState(state);
         });
     }
@@ -275,35 +277,35 @@
     Q_EMIT parentSessionChanged(session);
 }
 
-void Session::addChildSession(Session* session)
+void Session::addChildSession(SessionInterface* session)
 {
     insertChildSession(m_children->rowCount(), session);
 }
 
-void Session::insertChildSession(uint index, Session* session)
+void Session::insertChildSession(uint index, SessionInterface* session)
 {
     qCDebug(QTMIR_SESSIONS) << "Session::insertChildSession - " << session->name() << " to " << name() << " @  " << index;
 
-    session->setParentSession(this);
+    static_cast<Session*>(session)->setParentSession(this);
     m_children->insert(index, session);
 
     session->setState(state());
 }
 
-void Session::removeChildSession(Session* session)
+void Session::removeChildSession(SessionInterface* session)
 {
     qCDebug(QTMIR_SESSIONS) << "Session::removeChildSession - " << session->name() << " from " << name();
 
     if (m_children->contains(session)) {
         m_children->remove(session);
-        session->setParentSession(nullptr);
+        static_cast<Session*>(session)->setParentSession(nullptr);
     }
 }
 
-void Session::foreachChildSession(std::function<void(Session* session)> f) const
+void Session::foreachChildSession(std::function<void(SessionInterface* session)> f) const
 {
-    QList<Session*> children(m_children->list());
-    for (Session* child : children) {
+    QList<SessionInterface*> children(m_children->list());
+    for (SessionInterface* child : children) {
         f(child);
     }
 }
@@ -331,9 +333,9 @@
 
 void Session::stopPromptSessions()
 {
-    QList<Session*> children(m_children->list());
-    for (Session* child : children) {
-        child->stopPromptSessions();
+    QList<SessionInterface*> children(m_children->list());
+    for (SessionInterface* child : children) {
+        static_cast<Session*>(child)->stopPromptSessions();
     }
 
     QList<std::shared_ptr<ms::PromptSession>> copy(m_promptSessions);
 
=== modified file 'src/modules/Unity/Application/session.h'
--- src/modules/Unity/Application/session.h	2014-09-01 16:07:27 +0000
+++ src/modules/Unity/Application/session.h	2014-09-11 21:25:08 +0000
@@ -21,19 +21,15 @@
 #include <memory>
 
 // local
-#include "sessionmodel.h"
+#include "session_interface.h"
 
 // Qt
 #include <QObject>
 #include <QTimer>
 
-// Unity API
-#include <unity/shell/application/ApplicationInfoInterface.h>
 
 namespace mir {
     namespace scene {
-        class Session;
-        class PromptSession;
         class PromptSessionManager;
     }
 }
@@ -41,83 +37,61 @@
 namespace qtmir {
 
 class Application;
-class MirSurfaceItem;
 
-class Session : public QObject
+class Session : public SessionInterface
 {
     Q_OBJECT
-    Q_PROPERTY(MirSurfaceItem* surface READ surface NOTIFY surfaceChanged)
-    Q_PROPERTY(Application* application READ application NOTIFY applicationChanged DESIGNABLE false)
-    Q_PROPERTY(Session* parentSession READ parentSession NOTIFY parentSessionChanged DESIGNABLE false)
-    Q_PROPERTY(SessionModel* childSessions READ childSessions DESIGNABLE false CONSTANT)
-    Q_PROPERTY(bool fullscreen READ fullscreen NOTIFY fullscreenChanged)
-    Q_PROPERTY(bool live READ live NOTIFY liveChanged)
-
 public:
     explicit Session(const std::shared_ptr<mir::scene::Session>& session,
                      const std::shared_ptr<mir::scene::PromptSessionManager>& promptSessionManager,
                      QObject *parent = 0);
-    ~Session();
-
-    // Session State
-    typedef unity::shell::application::ApplicationInfoInterface::State State;
-
-    Q_INVOKABLE void release();
+    virtual ~Session();
+
+    Q_INVOKABLE void release() override;
 
     //getters
-    QString name() const;
-    Application* application() const;
-    MirSurfaceItem* surface() const;
-    Session* parentSession() const;
-    State state() const;
-    bool fullscreen() const;
-    bool live() const;
-
-    void setSession();
-    void setApplication(Application* item);
-    void setSurface(MirSurfaceItem* surface);
-    void setState(State state);
-
-    void addChildSession(Session* session);
-    void insertChildSession(uint index, Session* session);
-    void removeChildSession(Session* session);
-    void foreachChildSession(std::function<void(Session* session)> f) 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;
-
-Q_SIGNALS:
-    void surfaceChanged(MirSurfaceItem*);
-    void parentSessionChanged(Session*);
-    void applicationChanged(Application* application);
-    void aboutToBeDestroyed();
-    void stateChanged(State state);
-    void fullscreenChanged(bool fullscreen);
-    void liveChanged(bool live);
-
-    void suspended();
-    void resumed();
+    QString name() const override;
+    unity::shell::application::ApplicationInfoInterface* application() const override;
+    MirSurfaceItem* surface() const override;
+    SessionInterface* parentSession() const override;
+    State state() const override;
+    bool fullscreen() const override;
+    bool live() const override;
+
+    void setApplication(unity::shell::application::ApplicationInfoInterface* item) override;
+    void setSurface(MirSurfaceItem* surface) override;
+    void setState(State state) override;
+
+    void addChildSession(SessionInterface* session) override;
+    void insertChildSession(uint index, SessionInterface* session) override;
+    void removeChildSession(SessionInterface* session) override;
+    void foreachChildSession(std::function<void(SessionInterface* session)> f) const override;
+
+    std::shared_ptr<mir::scene::Session> session() const override;
+
+    std::shared_ptr<mir::scene::PromptSession> activePromptSession() const override;
+    void foreachPromptSession(std::function<void(const std::shared_ptr<mir::scene::PromptSession>&)> f) const override;
+
+    SessionModel* childSessions() const override;
+
+protected:
+    void setFullscreen(bool fullscreen) override;
+    void setLive(const bool) override;
+    void appendPromptSession(const std::shared_ptr<mir::scene::PromptSession>& session) override;
+    void removePromptSession(const std::shared_ptr<mir::scene::PromptSession>& session) override;
 
 private Q_SLOTS:
     void updateFullscreenProperty();
 
 private:
-    SessionModel* childSessions() const;
     void setParentSession(Session* session);
 
-    void appendPromptSession(const std::shared_ptr<mir::scene::PromptSession>& session);
-    void removePromptSession(const std::shared_ptr<mir::scene::PromptSession>& session);
     void stopPromptSessions();
 
-    void setFullscreen(bool fullscreen);
-    void setLive(const bool);
-
     std::shared_ptr<mir::scene::Session> m_session;
     Application* m_application;
     MirSurfaceItem* m_surface;
-    Session* m_parentSession;
+    SessionInterface* m_parentSession;
     SessionModel* m_children;
     bool m_fullscreen;
     State m_state;
@@ -125,8 +99,6 @@
     QTimer* m_suspendTimer;
     QList<std::shared_ptr<mir::scene::PromptSession>> m_promptSessions;
     std::shared_ptr<mir::scene::PromptSessionManager> const m_promptSessionManager;
-
-    friend class SessionManager;
 };
 
 } // namespace qtmir
 
=== added file 'src/modules/Unity/Application/session_interface.h'
--- src/modules/Unity/Application/session_interface.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/session_interface.h	2014-09-11 21:25:08 +0000
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SESSION_INTERFACE_H
+#define SESSION_INTERFACE_H
+
+#include <functional>
+#include <memory>
+
+// Unity API
+#include <unity/shell/application/ApplicationInfoInterface.h>
+
+// local
+#include "sessionmodel.h"
+
+namespace mir {
+    namespace scene {
+        class Session;
+        class PromptSession;
+    }
+}
+
+namespace qtmir {
+
+class MirSurfaceItem;
+
+class SessionInterface : public QObject {
+    Q_OBJECT
+    Q_PROPERTY(MirSurfaceItem* surface READ surface NOTIFY surfaceChanged)
+    Q_PROPERTY(unity::shell::application::ApplicationInfoInterface* application READ application NOTIFY applicationChanged DESIGNABLE false)
+    Q_PROPERTY(SessionInterface* parentSession READ parentSession NOTIFY parentSessionChanged DESIGNABLE false)
+    Q_PROPERTY(SessionModel* childSessions READ childSessions DESIGNABLE false CONSTANT)
+    Q_PROPERTY(bool fullscreen READ fullscreen NOTIFY fullscreenChanged)
+    Q_PROPERTY(bool live READ live NOTIFY liveChanged)
+public:
+    SessionInterface(QObject *parent = 0) : QObject(parent) {}
+    virtual ~SessionInterface() {}
+
+    // Session State
+    typedef unity::shell::application::ApplicationInfoInterface::State State;
+
+    Q_INVOKABLE virtual void release() = 0;
+
+    //getters
+    virtual QString name() const = 0;
+    virtual unity::shell::application::ApplicationInfoInterface* application() const = 0;
+    virtual MirSurfaceItem* surface() const = 0;
+    virtual SessionInterface* parentSession() const = 0;
+    virtual State state() const = 0;
+    virtual bool fullscreen() const = 0;
+    virtual bool live() const = 0;
+
+    virtual void setApplication(unity::shell::application::ApplicationInfoInterface* item) = 0;
+    virtual void setSurface(MirSurfaceItem* surface) = 0;
+    virtual void setState(State state) = 0;
+
+    virtual void addChildSession(SessionInterface* session) = 0;
+    virtual void insertChildSession(uint index, SessionInterface* session) = 0;
+    virtual void removeChildSession(SessionInterface* session) = 0;
+    virtual void foreachChildSession(std::function<void(SessionInterface* session)> f) const = 0;
+
+    virtual std::shared_ptr<mir::scene::Session> session() const = 0;
+
+    virtual std::shared_ptr<mir::scene::PromptSession> activePromptSession() const = 0;
+    virtual void foreachPromptSession(std::function<void(const std::shared_ptr<mir::scene::PromptSession>&)> f) const = 0;
+
+    virtual SessionModel* childSessions() const = 0;
+
+Q_SIGNALS:
+    void surfaceChanged(MirSurfaceItem*);
+    void parentSessionChanged(SessionInterface*);
+    void applicationChanged(unity::shell::application::ApplicationInfoInterface* application);
+    void aboutToBeDestroyed();
+    void stateChanged(State state);
+    void fullscreenChanged(bool fullscreen);
+    void liveChanged(bool live);
+
+    void suspended();
+    void resumed();
+
+protected:
+    virtual void setFullscreen(bool fullscreen) = 0;
+    virtual void setLive(const bool) = 0;
+    virtual void appendPromptSession(const std::shared_ptr<mir::scene::PromptSession>& session) = 0;
+    virtual void removePromptSession(const std::shared_ptr<mir::scene::PromptSession>& session) = 0;
+
+    friend class SessionManager;
+};
+
+} // namespace qtmir
+
+
+#endif // SESSION_INTERFACE_H
 
=== modified file 'src/modules/Unity/Application/sessionmanager.cpp'
--- src/modules/Unity/Application/sessionmanager.cpp	2014-08-29 14:58:07 +0000
+++ src/modules/Unity/Application/sessionmanager.cpp	2014-09-11 21:25:08 +0000
@@ -103,11 +103,11 @@
     qCDebug(QTMIR_SESSIONS) << "SessionManager::~SessionManager - this=" << this;
 }
 
-Session *SessionManager::findSession(const mir::scene::Session* session) const
+SessionInterface *SessionManager::findSession(const mir::scene::Session* session) const
 {
     if (!session) return nullptr;
 
-    for (Session* child : list()) {
+    for (SessionInterface* child : list()) {
         if (child->session().get() == session)
             return child;
     }
@@ -139,7 +139,7 @@
 {
     qCDebug(QTMIR_SESSIONS) << "SessionManager::onSessionStopping - sessionName=" << session->name().c_str();
 
-    Session* qmlSession = findSession(session.get());
+    SessionInterface* qmlSession = findSession(session.get());
     if (!qmlSession) return;
 
     remove(qmlSession);
@@ -153,7 +153,7 @@
     qCDebug(QTMIR_SESSIONS) << "SessionManager::onPromptSessionStarting - promptSession=" << promptSession.get();
 
     std::shared_ptr<mir::scene::Session> appSession = m_mirConfig->the_prompt_session_manager()->application_for(promptSession);
-    Session *qmlAppSession = findSession(appSession.get());
+    SessionInterface *qmlAppSession = findSession(appSession.get());
     if (qmlAppSession) {
         m_mirPromptToSessionHash[promptSession.get()] = qmlAppSession;
         qmlAppSession->appendPromptSession(promptSession);
@@ -166,7 +166,7 @@
 {
     qCDebug(QTMIR_SESSIONS) << "SessionManager::onPromptSessionStopping - promptSession=" << promptSession.get();
 
-    for (Session *qmlSession : this->list()) {
+    for (SessionInterface *qmlSession : this->list()) {
         qmlSession->removePromptSession(promptSession);
     }
     m_mirPromptToSessionHash.remove(promptSession.get());
@@ -177,13 +177,13 @@
 {
     qCDebug(QTMIR_SESSIONS) << "SessionManager::onPromptProviderAdded - promptSession=" << promptSession << " promptProvider=" << promptProvider.get();
 
-    Session* qmlAppSession = m_mirPromptToSessionHash.value(promptSession, nullptr);
+    SessionInterface* qmlAppSession = m_mirPromptToSessionHash.value(promptSession, nullptr);
     if (!qmlAppSession) {
         qCDebug(QTMIR_SESSIONS) << "SessionManager::onPromptProviderAdded - could not find session item for app session";
         return;
     }
 
-    Session* qmlPromptProvider = findSession(promptProvider.get());
+    SessionInterface* qmlPromptProvider = findSession(promptProvider.get());
     if (!qmlPromptProvider) {
         qCDebug(QTMIR_SESSIONS) << "SessionManager::onPromptProviderAdded - could not find session item for provider session";
         return;
@@ -197,7 +197,7 @@
 {
     qCDebug(QTMIR_SESSIONS) << "SessionManager::onPromptProviderRemoved - promptSession=" << promptSession << " promptProvider=" << promptProvider.get();
 
-    Session* qmlPromptProvider = findSession(promptProvider.get());
+    SessionInterface* qmlPromptProvider = findSession(promptProvider.get());
     if (!qmlPromptProvider) {
         qCDebug(QTMIR_SESSIONS) << "SessionManager::onPromptProviderAdded - could not find session item for provider session";
         return;
 
=== modified file 'src/modules/Unity/Application/sessionmanager.h'
--- src/modules/Unity/Application/sessionmanager.h	2014-08-28 23:36:42 +0000
+++ src/modules/Unity/Application/sessionmanager.h	2014-09-11 21:25:08 +0000
@@ -59,11 +59,11 @@
 
     static SessionManager* singleton();
 
-    Session *findSession(const mir::scene::Session* session) const;
+    SessionInterface *findSession(const mir::scene::Session* session) const;
 
 Q_SIGNALS:
-    void sessionStarting(Session* session);
-    void sessionStopping(Session* session);
+    void sessionStarting(SessionInterface* session);
+    void sessionStopping(SessionInterface* session);
 
 public Q_SLOTS:
     void onSessionStarting(std::shared_ptr<mir::scene::Session> const& session);
@@ -82,7 +82,7 @@
     static SessionManager *the_session_manager;
 
     QList<Session*> m_sessions;
-    QHash<const mir::scene::PromptSession *, Session *> m_mirPromptToSessionHash;
+    QHash<const mir::scene::PromptSession *, SessionInterface *> m_mirPromptToSessionHash;
 };
 
 } // namespace qtmir
 
=== modified file 'src/modules/Unity/Application/sessionmodel.h'
--- src/modules/Unity/Application/sessionmodel.h	2014-08-29 11:15:51 +0000
+++ src/modules/Unity/Application/sessionmodel.h	2014-09-11 21:25:08 +0000
@@ -22,8 +22,8 @@
 
 namespace qtmir {
 
-class Session;
-typedef ObjectListModel<Session> SessionModel;
+class SessionInterface;
+typedef ObjectListModel<SessionInterface> SessionModel;
 
 } // namespace qtmir
 
 
=== modified file 'tests/modules/ApplicationManager/application_manager_test.cpp'
--- tests/modules/ApplicationManager/application_manager_test.cpp	2014-08-29 10:18:57 +0000
+++ tests/modules/ApplicationManager/application_manager_test.cpp	2014-09-11 21:25:08 +0000
@@ -25,6 +25,7 @@
  #include "qtmir_test.h"
 
 using namespace qtmir;
+using mir::scene::MockSession;
 
 namespace ms = mir::scene;
 
@@ -1774,7 +1775,7 @@
             }).detach();
         }));
 
-    auto mockSurface = std::make_shared<MockSurface>();
+    auto mockSurface = std::make_shared<ms::MockSurface>();
     EXPECT_CALL(*session, default_surface()).WillRepeatedly(Return(mockSurface));
 
     {
@@ -1826,7 +1827,7 @@
             }).detach();
         }));
 
-    auto mockSurface = std::make_shared<MockSurface>();
+    auto mockSurface = std::make_shared<ms::MockSurface>();
     EXPECT_CALL(*session, default_surface()).WillRepeatedly(Return(mockSurface));
 
     {
 
=== added directory 'tests/modules/MirSurfaceItem'
=== added file 'tests/modules/MirSurfaceItem/MirSurfaceItem.pro'
--- tests/modules/MirSurfaceItem/MirSurfaceItem.pro	1970-01-01 00:00:00 +0000
+++ tests/modules/MirSurfaceItem/MirSurfaceItem.pro	2014-09-11 21:25:08 +0000
@@ -0,0 +1,13 @@
+include(../../test-includes.pri)
+include(../common/common.pri)
+
+TARGET = mirsurfaceitem_test
+
+QT += testlib
+
+INCLUDEPATH += \
+    ../../../src/platforms/mirserver \
+    ../../../src/modules/Unity/Application
+
+SOURCES += \
+    mirsurfaceitem_test.cpp
 
=== added file 'tests/modules/MirSurfaceItem/mirsurfaceitem_test.cpp'
--- tests/modules/MirSurfaceItem/mirsurfaceitem_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/modules/MirSurfaceItem/mirsurfaceitem_test.cpp	2014-09-11 21:25:08 +0000
@@ -0,0 +1,113 @@
+/*
+ * 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 <gtest/gtest.h>
+
+#include <QLoggingCategory>
+#include <QTest>
+
+// the test subject
+#include <mirsurfaceitem.h>
+
+// mocks
+#include <mock_surface.h>
+#include <mock_session.h>
+
+using namespace qtmir;
+
+using mir::scene::MockSurface;
+using qtmir::MockSession;
+
+// gtest stuff
+using ::testing::_;
+using ::testing::AnyNumber;
+using ::testing::Invoke;
+using ::testing::InSequence;
+using ::testing::Return;
+
+/*
+  Tests that even if Qt fails to finish a touch sequence, MirSurfaceItem will
+  properly finish it when forwarding it to its mir::input::surface. So
+  mir::input::surface will still consume a proper sequence of touch events
+  (comprised of a begin, zero or more updates and an end).
+ */
+TEST(MirSurfaceItemTest, MissingTouchEnd)
+{
+    // We don't want the logging spam cluttering the test results
+    QLoggingCategory::setFilterRules(QStringLiteral("qtmir*=false"));
+
+    std::shared_ptr<MockSurface> mockSurface = std::make_shared<MockSurface>();
+    MockSession *mockSession = new MockSession;
+
+    // Set some expectations and behavior for calls we are not interested in
+    EXPECT_CALL(*mockSurface, add_observer(_)).Times(AnyNumber());
+    EXPECT_CALL(*mockSurface, remove_observer(_)).Times(AnyNumber());
+    EXPECT_CALL(*mockSurface, size()).Times(AnyNumber()).WillRepeatedly(Return(mir::geometry::Size(100,100)));
+    EXPECT_CALL(*mockSurface, type()).Times(AnyNumber()).WillRepeatedly(Return(mir_surface_type_normal));
+    EXPECT_CALL(*mockSession, setSurface(_)).Times(AnyNumber());
+
+    // The touch event sequence we expect mir::input::surface to receive from MirSurfaceItem.
+    // It should properly finish the sequence for touch 0 ('down', 'move' and 'up') before starting
+    // the sequence for touch 1.
+    EXPECT_CALL(*mockSurface, consume(_))
+        .WillOnce(Invoke([] (MirEvent const& mirEvent) {
+            ASSERT_EQ(mir_motion_action_down, mirEvent.motion.action);
+            ASSERT_EQ(1, mirEvent.motion.pointer_count);
+            ASSERT_EQ(0, mirEvent.motion.pointer_coordinates[0].id);
+        }))
+        .WillOnce(Invoke([] (MirEvent const& mirEvent) {
+            ASSERT_EQ(mir_motion_action_move, mirEvent.motion.action);
+            ASSERT_EQ(1, mirEvent.motion.pointer_count);
+            ASSERT_EQ(0, mirEvent.motion.pointer_coordinates[0].id);
+        }))
+        .WillOnce(Invoke([] (MirEvent const& mirEvent) {
+            ASSERT_EQ(mir_motion_action_up, mirEvent.motion.action);
+            ASSERT_EQ(1, mirEvent.motion.pointer_count);
+            ASSERT_EQ(0, mirEvent.motion.pointer_coordinates[0].id);
+        }))
+        .WillOnce(Invoke([] (MirEvent const& mirEvent) {
+            ASSERT_EQ(mir_motion_action_down, mirEvent.motion.action);
+            ASSERT_EQ(1, mirEvent.motion.pointer_count);
+            ASSERT_EQ(1, mirEvent.motion.pointer_coordinates[0].id);
+        }));
+
+
+    MirSurfaceItem *surfaceItem = new MirSurfaceItem(mockSurface, mockSession);
+
+    ulong timestamp = 1234;
+    QList<QTouchEvent::TouchPoint> touchPoints;
+    touchPoints.append(QTouchEvent::TouchPoint());
+
+    touchPoints[0].setId(0);
+    touchPoints[0].setState(Qt::TouchPointPressed);
+    surfaceItem->processTouchEvent(QEvent::TouchBegin,
+            timestamp, touchPoints, touchPoints[0].state());
+
+    touchPoints[0].setState(Qt::TouchPointMoved);
+    surfaceItem->processTouchEvent(QEvent::TouchUpdate,
+            timestamp + 10, touchPoints, touchPoints[0].state());
+
+    // Starting a new touch sequence (with touch 1) without ending the current one
+    // (wich has touch 0).
+    touchPoints[0].setId(1);
+    touchPoints[0].setState(Qt::TouchPointPressed);
+    surfaceItem->processTouchEvent(QEvent::TouchBegin,
+            timestamp + 20, touchPoints, touchPoints[0].state());
+    
+    delete surfaceItem;
+    delete mockSession;
+}
 
=== modified file 'tests/modules/SessionManager/session_manager_test.cpp'
--- tests/modules/SessionManager/session_manager_test.cpp	2014-08-29 14:58:07 +0000
+++ tests/modules/SessionManager/session_manager_test.cpp	2014-09-11 21:25:08 +0000
@@ -24,6 +24,7 @@
  #include "qtmir_test.h"
 
 using namespace qtmir;
+using mir::scene::MockSession;
 
 namespace ms = mir::scene;
 
@@ -33,7 +34,7 @@
     SessionManagerTests()
     {}
 
-    QList<std::shared_ptr<ms::PromptSession>> listPromptSessions(Session* session) {
+    QList<std::shared_ptr<ms::PromptSession>> listPromptSessions(SessionInterface* session) {
         QList<std::shared_ptr<ms::PromptSession>> promptSessions;
         session->foreachPromptSession([&promptSessions](const std::shared_ptr<ms::PromptSession>& promptSession) {
             promptSessions << promptSession;
@@ -41,9 +42,9 @@
         return promptSessions;
     }
 
-    QList<Session*> listChildSessions(Session* session) {
-        QList<Session*> sessions;
-        session->foreachChildSession([&sessions](Session* session) {
+    QList<SessionInterface*> listChildSessions(SessionInterface* session) {
+        QList<SessionInterface*> sessions;
+        session->foreachChildSession([&sessions](SessionInterface* session) {
             sessions << session;
         });
         return sessions;
@@ -56,10 +57,10 @@
 
     std::shared_ptr<ms::Session> mirAppSession = std::make_shared<MockSession>("mirAppSession", __LINE__);
     sessionManager.onSessionStarting(mirAppSession);
-    Session* qtmirAppSession = sessionManager.findSession(mirAppSession.get());
+    SessionInterface* qtmirAppSession = sessionManager.findSession(mirAppSession.get());
     EXPECT_TRUE(qtmirAppSession != nullptr);
 
-    auto promptSession = std::make_shared<MockPromptSession>();
+    auto promptSession = std::make_shared<ms::MockPromptSession>();
     ON_CALL(*mirConfig->the_mock_prompt_session_manager(), application_for(_)).WillByDefault(Return(mirAppSession));
 
     sessionManager.onPromptSessionStarting(promptSession);
@@ -80,18 +81,18 @@
 
     std::shared_ptr<ms::Session> mirAppSession = std::make_shared<MockSession>("mirAppSession", __LINE__);
     sessionManager.onSessionStarting(mirAppSession);
-    Session* qtmirAppSession = sessionManager.findSession(mirAppSession.get());
+    SessionInterface* qtmirAppSession = sessionManager.findSession(mirAppSession.get());
     EXPECT_TRUE(qtmirAppSession != nullptr);
 
     EXPECT_CALL(*mirConfig->the_mock_prompt_session_manager(), application_for(_)).WillRepeatedly(Return(mirAppSession));
     EXPECT_CALL(*mirConfig->the_mock_prompt_session_manager(), helper_for(_)).WillRepeatedly(Return(nullptr));
 
-    std::shared_ptr<ms::PromptSession> mirPromptSession = std::make_shared<MockPromptSession>();
+    std::shared_ptr<ms::PromptSession> mirPromptSession = std::make_shared<ms::MockPromptSession>();
 
     // prompt provider session
     std::shared_ptr<ms::Session> mirProviderSession = std::make_shared<MockSession>("mirProviderSession", __LINE__);
     sessionManager.onSessionStarting(mirProviderSession);
-    Session* qtmirProviderSession = sessionManager.findSession(mirProviderSession.get());
+    SessionInterface* qtmirProviderSession = sessionManager.findSession(mirProviderSession.get());
 
     EXPECT_CALL(*mirConfig->the_mock_prompt_session_manager(), for_each_provider_in(mirPromptSession,_)).WillRepeatedly(WithArgs<1>(Invoke(
         [&](std::function<void(std::shared_ptr<ms::Session> const& prompt_provider)> const& f) {
 
=== modified file 'tests/modules/SessionManager/session_test.cpp'
--- tests/modules/SessionManager/session_test.cpp	2014-08-28 23:36:42 +0000
+++ tests/modules/SessionManager/session_test.cpp	2014-09-11 21:25:08 +0000
@@ -22,6 +22,8 @@
 #include "stub_scene_surface.h"
 
 using namespace qtmir;
+using mir::scene::MockSession;
+
 
 namespace ms = mir::scene;
 namespace mtd = mir::test::doubles;
@@ -32,9 +34,9 @@
     SessionTests()
     {}
 
-    QList<Session*> listChildSessions(Session* session) {
-        QList<Session*> sessions;
-        session->foreachChildSession([&sessions](Session* session) {
+    QList<SessionInterface*> listChildSessions(Session* session) {
+        QList<SessionInterface*> sessions;
+        session->foreachChildSession([&sessions](SessionInterface* session) {
             sessions << session;
         });
         return sessions;
@@ -151,17 +153,14 @@
 
     // delete surfaces
     delete session2;
-    EXPECT_EQ(session2->parentSession(), nullptr);
     EXPECT_THAT(listChildSessions(&session), ElementsAre(session1, session3));
 
     // delete surfaces
     delete session3;
-    EXPECT_EQ(session3->parentSession(), nullptr);
     EXPECT_THAT(listChildSessions(&session), ElementsAre(session1));
 
     // delete surfaces
     delete session1;
-    EXPECT_EQ(session1->parentSession(), nullptr);
     EXPECT_THAT(listChildSessions(&session), IsEmpty());
 }
 
 
=== modified file 'tests/modules/common/common.pri'
--- tests/modules/common/common.pri	2014-09-07 19:42:14 +0000
+++ tests/modules/common/common.pri	2014-09-11 21:25:08 +0000
@@ -6,6 +6,7 @@
 HEADERS += ../common/mock_application_controller.h \
     ../common/mock_desktop_file_reader.h \
     ../common/mock_focus_controller.h \
+    ../common/mock_mir_session.h \
     ../common/mock_oom_controller.h \
     ../common/mock_process_controller.h \
     ../common/mock_proc_info.h \
 
=== modified file 'tests/modules/common/mock_focus_controller.h'
--- tests/modules/common/mock_focus_controller.h	2014-07-01 13:38:06 +0000
+++ tests/modules/common/mock_focus_controller.h	2014-09-11 21:25:08 +0000
@@ -23,15 +23,18 @@
 
 #include <string>
 
-namespace testing
-{
-class MockFocusController : public mir::shell::FocusController
+namespace mir {
+namespace shell {
+
+class MockFocusController : public FocusController
 {
 public:
     MOCK_METHOD0(focus_next, void());
-    MOCK_CONST_METHOD0(focussed_application, std::weak_ptr<mir::scene::Session>());
-    MOCK_METHOD1(set_focus_to, void(std::shared_ptr<mir::scene::Session>const&));
+    MOCK_CONST_METHOD0(focussed_application, std::weak_ptr<scene::Session>());
+    MOCK_METHOD1(set_focus_to, void(std::shared_ptr<scene::Session>const&));
 };
-}
+
+} // namespace shell
+} // namespace mir
 
 #endif // MOCK_MIR_SHELL_FOCUS_CONTROLLER_H_
 
=== renamed file 'tests/modules/common/mock_session.h' => 'tests/modules/common/mock_mir_session.h'
--- tests/modules/common/mock_session.h	2014-07-01 13:38:06 +0000
+++ tests/modules/common/mock_mir_session.h	2014-09-11 21:25:08 +0000
@@ -25,9 +25,10 @@
 
 #include <string>
 
-namespace testing
-{
-struct MockSession : public mir::scene::Session
+namespace mir {
+namespace scene {
+
+struct MockSession : public Session
 {
     MockSession() {}
     MockSession(std::string const& sessionName, pid_t processId) 
@@ -44,22 +45,20 @@
         return m_sessionId;
     }
 
-    typedef mir::frontend::SurfaceId SurfaceId;
-
     MOCK_METHOD0(force_requests_to_complete, void());
 
-    MOCK_CONST_METHOD0(default_surface, std::shared_ptr<mir::scene::Surface>());
-    MOCK_CONST_METHOD1(get_surface, std::shared_ptr<mir::frontend::Surface>(SurfaceId));
+    MOCK_CONST_METHOD0(default_surface, std::shared_ptr<Surface>());
+    MOCK_CONST_METHOD1(get_surface, std::shared_ptr<frontend::Surface>(frontend::SurfaceId));
 
-    MOCK_METHOD1(take_snapshot, void(mir::scene::SnapshotCallback const&));
+    MOCK_METHOD1(take_snapshot, void(SnapshotCallback const&));
     MOCK_METHOD1(set_lifecycle_state, void(MirLifecycleState));
-    MOCK_METHOD1(create_surface, SurfaceId(mir::scene::SurfaceCreationParameters const&));
-    MOCK_METHOD1(destroy_surface, void (SurfaceId));
+    MOCK_METHOD1(create_surface, frontend::SurfaceId(SurfaceCreationParameters const&));
+    MOCK_METHOD1(destroy_surface, void (frontend::SurfaceId));
 
     MOCK_METHOD0(hide, void());
     MOCK_METHOD0(show, void());
-    MOCK_METHOD1(send_display_config, void(mir::graphics::DisplayConfiguration const&));
-    MOCK_METHOD3(configure_surface, int(SurfaceId, MirSurfaceAttrib, int));
+    MOCK_METHOD1(send_display_config, void(graphics::DisplayConfiguration const&));
+    MOCK_METHOD3(configure_surface, int(frontend::SurfaceId, MirSurfaceAttrib, int));
 
     void start_prompt_session() override {};
     void stop_prompt_session() override {};
@@ -68,6 +67,8 @@
     std::string m_sessionName;
     pid_t m_sessionId;
 };
-}
+
+} // namespace scene
+} // namespace mir
 
 #endif // MOCK_MIR_SCENE_SESSION_H
 
=== modified file 'tests/modules/common/mock_prompt_session.h'
--- tests/modules/common/mock_prompt_session.h	2014-07-21 15:51:17 +0000
+++ tests/modules/common/mock_prompt_session.h	2014-09-11 21:25:08 +0000
@@ -21,11 +21,14 @@
 #include <mir/scene/prompt_session.h>
 #include <gmock/gmock.h>
 
-namespace testing
-{
-struct MockPromptSession : public mir::scene::PromptSession
+namespace mir {
+namespace scene {
+
+struct MockPromptSession : public PromptSession
 {
 };
-}
+
+} // namespace scene
+} // namespace mir
 
 #endif // MOCK_MIR_PROMPT_SESSION_H
 
=== modified file 'tests/modules/common/mock_prompt_session_manager.h'
--- tests/modules/common/mock_prompt_session_manager.h	2014-07-21 15:51:17 +0000
+++ tests/modules/common/mock_prompt_session_manager.h	2014-09-11 21:25:08 +0000
@@ -23,33 +23,36 @@
 
 #include <gmock/gmock.h>
 
-namespace testing
-{
-class MockPromptSessionManager: public mir::scene::PromptSessionManager
+namespace mir {
+namespace scene {
+
+class MockPromptSessionManager: public PromptSessionManager
 {
 public:
-    MOCK_CONST_METHOD2(start_prompt_session_for, std::shared_ptr<mir::scene::PromptSession>(std::shared_ptr<mir::scene::Session> const&,
+    MOCK_CONST_METHOD2(start_prompt_session_for, std::shared_ptr<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_METHOD1(stop_prompt_session, void(std::shared_ptr<PromptSession> const&));
 
-    MOCK_CONST_METHOD2(add_prompt_provider, void(std::shared_ptr<mir::scene::PromptSession> const&,
+    MOCK_CONST_METHOD2(add_prompt_provider, void(std::shared_ptr<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&,
+    MOCK_CONST_METHOD2(add_prompt_provider_by_pid, void(std::shared_ptr<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&));
+    MOCK_CONST_METHOD1(add_expected_session, void(std::shared_ptr<Session> const&));
+
+    MOCK_CONST_METHOD1(remove_session, void(std::shared_ptr<Session> const&));
+
+    MOCK_CONST_METHOD1(application_for, std::shared_ptr<Session>(std::shared_ptr<PromptSession> const&));
+
+    MOCK_CONST_METHOD1(helper_for, std::shared_ptr<Session>(std::shared_ptr<PromptSession> const&));
+
+    MOCK_CONST_METHOD2(for_each_provider_in, void(std::shared_ptr<PromptSession> const&,
+        std::function<void(std::shared_ptr<Session> const&)> const&));
 };
-} // namespace testing
+
+} // namespace scene
+} // namespace mir
 
 #endif // MOCK_MIR_SCENE_PROMPT_SESSION_MANAGER_H_
 
=== modified file 'tests/modules/common/mock_renderable.h'
--- tests/modules/common/mock_renderable.h	2014-08-14 15:38:15 +0000
+++ tests/modules/common/mock_renderable.h	2014-09-11 21:25:08 +0000
@@ -21,23 +21,26 @@
 #include <mir/graphics/renderable.h>
 #include <gmock/gmock.h>
 
-namespace testing
-{
-struct MockRenderable : public mir::graphics::Renderable
+namespace mir {
+namespace graphics {
+
+struct MockRenderable : public Renderable
 {
     MockRenderable() {};
 
     MOCK_CONST_METHOD0(id, ID());
-    MOCK_CONST_METHOD0(buffer, std::shared_ptr<mir::graphics::Buffer>());
+    MOCK_CONST_METHOD0(buffer, std::shared_ptr<Buffer>());
     MOCK_CONST_METHOD0(alpha_enabled, bool());
-    MOCK_CONST_METHOD0(screen_position, mir::geometry::Rectangle());
+    MOCK_CONST_METHOD0(screen_position, geometry::Rectangle());
     MOCK_CONST_METHOD0(alpha, float() );
     MOCK_CONST_METHOD0(transformation, glm::mat4());
     MOCK_CONST_METHOD0(visible, bool());
     MOCK_CONST_METHOD0(shaped, bool());
     MOCK_CONST_METHOD0(buffers_ready_for_compositor, int());
 };
-}
+
+} // namespace graphics
+} // namespace mir
 
 #endif // MOCK_MIR_GRAPHICS_RENDERABLE_H
 
 
=== added file 'tests/modules/common/mock_session.h'
--- tests/modules/common/mock_session.h	1970-01-01 00:00:00 +0000
+++ tests/modules/common/mock_session.h	2014-09-11 21:25:08 +0000
@@ -0,0 +1,65 @@
+/*
+ * 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_QTMIR_SESSION_H
+#define MOCK_QTMIR_SESSION_H
+
+#include <session_interface.h>
+#include <gmock/gmock.h>
+
+namespace qtmir {
+
+class MockSession : public SessionInterface {
+public:
+    MockSession() : SessionInterface(0) {}
+
+    MOCK_METHOD0(release, void());
+
+    MOCK_CONST_METHOD0(name, QString());
+    MOCK_CONST_METHOD0(application, unity::shell::application::ApplicationInfoInterface*());
+    MOCK_CONST_METHOD0(surface, MirSurfaceItem*());
+    MOCK_CONST_METHOD0(parentSession, SessionInterface*());
+    MOCK_CONST_METHOD0(state, State());
+    MOCK_CONST_METHOD0(fullscreen, bool());
+    MOCK_CONST_METHOD0(live, bool());
+
+    MOCK_METHOD1(setApplication, void(unity::shell::application::ApplicationInfoInterface* item));
+    MOCK_METHOD1(setSurface, void(MirSurfaceItem* surface));
+    MOCK_METHOD1(setState, void(State state));
+
+    MOCK_METHOD1(addChildSession, void(SessionInterface* session));
+    MOCK_METHOD2(insertChildSession, void(uint index, SessionInterface* session));
+    MOCK_METHOD1(removeChildSession, void(SessionInterface* session));
+    MOCK_CONST_METHOD1(foreachChildSession, void(std::function<void(SessionInterface* session)> f));
+
+    MOCK_CONST_METHOD0(session, std::shared_ptr<mir::scene::Session>());
+
+    MOCK_CONST_METHOD0(activePromptSession, std::shared_ptr<mir::scene::PromptSession>());
+    MOCK_CONST_METHOD1(foreachPromptSession, void(std::function<void(const std::shared_ptr<mir::scene::PromptSession>&)> f));
+
+    MOCK_CONST_METHOD0(childSessions, SessionModel*());
+
+protected:
+    MOCK_METHOD1(setFullscreen, void(bool fullscreen));
+    MOCK_METHOD1(setLive, void(const bool));
+    MOCK_METHOD1(appendPromptSession, void(const std::shared_ptr<mir::scene::PromptSession>& session));
+    MOCK_METHOD1(removePromptSession, void(const std::shared_ptr<mir::scene::PromptSession>& session));
+};
+
+} // namespace qtmir
+
+#endif // MOCK_QTMIR_SESSION_H
 
=== modified file 'tests/modules/common/mock_surface.h'
--- tests/modules/common/mock_surface.h	2014-08-18 19:40:31 +0000
+++ tests/modules/common/mock_surface.h	2014-09-11 21:25:08 +0000
@@ -24,22 +24,22 @@
 #include <string>
 #include "mock_renderable.h"
 
-namespace testing
-{
+namespace mir {
+namespace scene {
 
 struct MockSurface : public mir::scene::Surface
 {
     MockSurface() {}
 
     MOCK_CONST_METHOD0(name, std::string());
-    MOCK_CONST_METHOD0(client_size, mir::geometry::Size());
-    MOCK_CONST_METHOD0(input_bounds, mir::geometry::Rectangle());
-    MOCK_CONST_METHOD0(top_left, mir::geometry::Point());
-    MOCK_CONST_METHOD0(size, mir::geometry::Size());
+    MOCK_CONST_METHOD0(client_size, geometry::Size());
+    MOCK_CONST_METHOD0(input_bounds, geometry::Rectangle());
+    MOCK_CONST_METHOD0(top_left, geometry::Point());
+    MOCK_CONST_METHOD0(size, geometry::Size());
 
-    std::unique_ptr<mir::graphics::Renderable> compositor_snapshot(void const* /*compositor_id*/) const
+    std::unique_ptr<graphics::Renderable> compositor_snapshot(void const* /*compositor_id*/) const
     {
-        return std::unique_ptr<mir::graphics::Renderable>(new MockRenderable);
+        return std::unique_ptr<graphics::Renderable>(new graphics::MockRenderable);
     }
 
     MOCK_CONST_METHOD0(alpha, float());
@@ -47,39 +47,40 @@
     MOCK_CONST_METHOD0(state, MirSurfaceState());
     MOCK_METHOD0(hide, void());
     MOCK_METHOD0(show, void());
-    MOCK_METHOD1(move_to, void(mir::geometry::Point const& top_left));
-    MOCK_METHOD1(take_input_focus, void(std::shared_ptr<mir::shell::InputTargeter> const& targeter));
-    MOCK_METHOD1(set_input_region, void(std::vector<mir::geometry::Rectangle> const& region));
+    MOCK_METHOD1(move_to, void(geometry::Point const& top_left));
+    MOCK_METHOD1(take_input_focus, void(std::shared_ptr<shell::InputTargeter> const& targeter));
+    MOCK_METHOD1(set_input_region, void(std::vector<geometry::Rectangle> const& region));
     MOCK_METHOD1(allow_framedropping, void(bool));
-    MOCK_METHOD1(resize, void(mir::geometry::Size const& size));
+    MOCK_METHOD1(resize, void(geometry::Size const& size));
     MOCK_METHOD1(set_transformation, void(glm::mat4 const& t));
     MOCK_METHOD1(set_alpha, void(float alpha));
     MOCK_METHOD1(set_orientation, void(MirOrientation orientation));
     MOCK_METHOD0(force_requests_to_complete, void());
-    MOCK_METHOD1(set_cursor_image, void(std::shared_ptr<mir::graphics::CursorImage> const& image));
-    MOCK_CONST_METHOD0(cursor_image, std::shared_ptr<mir::graphics::CursorImage>());
-    MOCK_METHOD1(add_observer, void(std::shared_ptr<mir::scene::SurfaceObserver> const& observer));
-    MOCK_METHOD1(remove_observer, void(std::weak_ptr<mir::scene::SurfaceObserver> const& observer));
-    MOCK_CONST_METHOD0(input_channel, std::shared_ptr<mir::input::InputChannel>());
-    MOCK_METHOD1(set_reception_mode, void(mir::input::InputReceptionMode mode));
+    MOCK_METHOD1(set_cursor_image, void(std::shared_ptr<graphics::CursorImage> const& image));
+    MOCK_CONST_METHOD0(cursor_image, std::shared_ptr<graphics::CursorImage>());
+    MOCK_METHOD1(add_observer, void(std::shared_ptr<SurfaceObserver> const& observer));
+    MOCK_METHOD1(remove_observer, void(std::weak_ptr<SurfaceObserver> const& observer));
+    MOCK_CONST_METHOD0(input_channel, std::shared_ptr<input::InputChannel>());
+    MOCK_METHOD1(set_reception_mode, void(input::InputReceptionMode mode));
 
     // from mir::input::surface
-    MOCK_CONST_METHOD1(input_area_contains, bool(mir::geometry::Point const& point));
-    MOCK_CONST_METHOD0(reception_mode, mir::input::InputReceptionMode());
+    MOCK_CONST_METHOD1(input_area_contains, bool(geometry::Point const& point));
+    MOCK_CONST_METHOD0(reception_mode, input::InputReceptionMode());
     MOCK_METHOD1(consume, void(MirEvent const& event));
 
     // from mir::frontend::surface
     MOCK_CONST_METHOD0(pixel_format, MirPixelFormat());
-    MOCK_METHOD2(swap_buffers, void(mir::graphics::Buffer* old_buffer, std::function<void(mir::graphics::Buffer* new_buffer)> complete));
+    MOCK_METHOD2(swap_buffers, void(graphics::Buffer* old_buffer, std::function<void(graphics::Buffer* new_buffer)> complete));
     MOCK_CONST_METHOD0(supports_input, bool());
     MOCK_CONST_METHOD0(client_input_fd, int());
     MOCK_METHOD2(configure, int(MirSurfaceAttrib attrib, int value));
     MOCK_METHOD1(query, int(MirSurfaceAttrib attrib));
 
     // from mir::scene::SurfaceBufferAccess
-    MOCK_METHOD1(with_most_recent_buffer_do, void(std::function<void(mir::graphics::Buffer&)> const& exec));
+    MOCK_METHOD1(with_most_recent_buffer_do, void(std::function<void(graphics::Buffer&)> const& exec));
 };
 
-}
+} // namespace scene
+} // namespace mir
 
 #endif // MOCK_MIR_SCENE_SURFACE_H
 
=== modified file 'tests/modules/common/qtmir_test.h'
--- tests/modules/common/qtmir_test.h	2014-08-28 23:36:42 +0000
+++ tests/modules/common/qtmir_test.h	2014-09-11 21:25:08 +0000
@@ -35,7 +35,7 @@
 #include "mock_oom_controller.h"
 #include "mock_process_controller.h"
 #include "mock_proc_info.h"
-#include "mock_session.h"
+#include "mock_mir_session.h"
 #include "mock_focus_controller.h"
 #include "mock_prompt_session_manager.h"
 #include "mock_prompt_session.h"
@@ -43,14 +43,13 @@
 namespace ms = mir::scene;
 using namespace qtmir;
 
-namespace testing
-{
+namespace qtmir {
 
-class QtMirTestConfiguration: public MirServerConfiguration
+class FakeMirServerConfiguration: public MirServerConfiguration
 {
-    typedef NiceMock<testing::MockPromptSessionManager> StubPromptSessionManager;
+    typedef testing::NiceMock<mir::scene::MockPromptSessionManager> StubPromptSessionManager;
 public:
-    QtMirTestConfiguration()
+    FakeMirServerConfiguration()
     : MirServerConfiguration(0, nullptr)
     , mock_prompt_session_manager(std::make_shared<StubPromptSessionManager>())
     {
@@ -73,6 +72,10 @@
     std::shared_ptr<StubPromptSessionManager> mock_prompt_session_manager;
 };
 
+} // namespace qtmir
+
+namespace testing {
+
 class QtMirTest : public ::testing::Test
 {
 public:
@@ -83,7 +86,7 @@
                 [](ProcessController::OomController*){})
         }
         , mirConfig{
-            QSharedPointer<QtMirTestConfiguration> (new QtMirTestConfiguration)
+            QSharedPointer<FakeMirServerConfiguration> (new FakeMirServerConfiguration)
         }
         , taskController{
               QSharedPointer<TaskController> (
@@ -141,7 +144,7 @@
         applicationManager.authorizeSession(procId, authed);
         EXPECT_EQ(authed, true);
 
-        auto appSession = std::make_shared<MockSession>(appId.toStdString(), procId);
+        auto appSession = std::make_shared<mir::scene::MockSession>(appId.toStdString(), procId);
         sessionManager.onSessionStarting(appSession);
         return application;
         return nullptr;
@@ -152,7 +155,7 @@
     testing::NiceMock<testing::MockApplicationController> appController;
     testing::NiceMock<testing::MockProcInfo> procInfo;
     testing::NiceMock<testing::MockDesktopFileReaderFactory> desktopFileReaderFactory;
-    QSharedPointer<QtMirTestConfiguration> mirConfig;
+    QSharedPointer<FakeMirServerConfiguration> mirConfig;
     QSharedPointer<TaskController> taskController;
     ApplicationManager applicationManager;
     SessionManager sessionManager;
 
=== modified file 'tests/modules/modules.pro'
--- tests/modules/modules.pro	2014-08-28 23:36:42 +0000
+++ tests/modules/modules.pro	2014-09-11 21:25:08 +0000
@@ -1,2 +1,2 @@
 TEMPLATE = subdirs
-SUBDIRS = ApplicationManager General SessionManager TaskController
+SUBDIRS = ApplicationManager General MirSurfaceItem SessionManager TaskController