Merge lp:~gerboland/qtmir/desktopFileReader into lp:~dandrader/qtmir/parse_splash_from_desktop_file

[Gerry Boland]

Rewrite DesktopFileReader to use GDesktopAppInfo, enables reading localized keys

Rewrite DesktopFileReader to use GDesktopAppInfo, enables reading localized keys

 * Are there any related MPs required for this MP to build/function as expected? Please list.
N
 * Did you perform an exploratory manual test run of your code change and any related functionality?
Y
 * If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
N/A

[lp:~gerboland/qtmir/desktopFileReader]

259. By Gerry Boland on 2014-09-18

Oops, revert naughty change

260. By Gerry Boland on 2014-09-18

Typos

261. By Gerry Boland on 2014-09-22

Fix typos

262. By Gerry Boland on 2014-09-22

Sssh, not so noisy

263. By Gerry Boland on 2014-09-22

Use qCWarning

264. By Gerry Boland on 2014-10-06

Merge trunk

265. By Gerry Boland on 2014-10-06

Fix compiler unused warning

266. By Gerry Boland on 2014-10-06

GDesktopInfo actually checks that the binary specified by the Exec line is installed. So need to change calculator.desktop to definitely use an installed binary

267. By Gerry Boland on 2014-10-06

Add more verbose error message if desktop file not valid or missing

268. By Gerry Boland on 2014-10-07

Missing !, debug statement now makes sense

Unmerged revisions

268. By Gerry Boland on 2014-10-07

Missing !, debug statement now makes sense

267. By Gerry Boland on 2014-10-06

Add more verbose error message if desktop file not valid or missing

266. By Gerry Boland on 2014-10-06

GDesktopInfo actually checks that the binary specified by the Exec line is installed. So need to change calculator.desktop to definitely use an installed binary

265. By Gerry Boland on 2014-10-06

Fix compiler unused warning

264. By Gerry Boland on 2014-10-06

Merge trunk

263. By Gerry Boland on 2014-09-22

Use qCWarning

262. By Gerry Boland on 2014-09-22

Sssh, not so noisy

261. By Gerry Boland on 2014-09-22

Fix typos

260. By Gerry Boland on 2014-09-18

Typos

259. By Gerry Boland on 2014-09-18

Oops, revert naughty change

=== modified file 'README'
--- README	2014-06-30 15:49:02 +0000
+++ README	2014-09-18 22:57:30 +0000
@@ -1,7 +1,7 @@
 This repo contains a QPA plugin to make Qt a Mir server.
 
 Handy way to grab dependencies is with:
-$ sudo mk-build-dep -ir debian/control
+$ sudo mk-build-deps -ir debian/control
 
 To use, compile and install with:
 $ qmake

=== modified file 'debian/changelog'
--- debian/changelog	2014-09-03 08:03:52 +0000
+++ debian/changelog	2014-09-18 22:57:30 +0000
@@ -1,3 +1,28 @@
+qtmir (0.4.3+14.10.20140915-0ubuntu1) utopic; urgency=low
+
+  [ Daniel d'Andrada ]
+  * MirSurfaceItem: Ensure all touch sequences sent to Mir surface are
+    properly ended.
+
+ -- Ubuntu daily release <[e-mail]>  Mon, 15 Sep 2014 14:50:16 +0000
+
+qtmir (0.4.3+14.10.20140907-0ubuntu1) utopic; urgency=low
+
+  [ Daniel d'Andrada ]
+  * QtEventFeeder: validate touches before sending them to Qt
+
+  [ josharenson ]
+  * Fix a small typo in the README file
+
+  [ Alan Griffiths ]
+  * Provide Mir with a handler for any command-line arguments it fails
+    to parse. For the moment, these are simply ignored.
+
+  [ Gerry Boland ]
+  * Add LTTng tracepoints
+
+ -- Ubuntu daily release <[e-mail]>  Sun, 07 Sep 2014 19:42:56 +0000
+
 qtmir (0.4.3+14.10.20140903-0ubuntu1) utopic; urgency=medium
 
   [ Nick Dedekind ]

=== modified file 'debian/control'
--- debian/control	2014-09-08 21:05:38 +0000
+++ debian/control	2014-09-18 22:57:30 +0000
@@ -11,6 +11,7 @@
                libboost-system-dev,
                libfontconfig1-dev,
                libglib2.0-dev,
+               liblttng-ust-dev,
                libmirclient-dev (>= 0.6.0),
                libmirserver-dev (>= 0.6.0),
                libprocess-cpp-dev,
@@ -25,6 +26,8 @@
                libmircommon-dev,
                pkg-config,
                protobuf-compiler,
+# lttng-gen-ts needs python3, but doesn't depend on it itself: bug 1359147
+               python3:any,               
                qt5-default,
                qtbase5-dev,
                qtbase5-private-dev,

=== added directory 'src/common'
=== renamed file 'src/modules/Unity/Application/debughelpers.cpp' => 'src/common/debughelpers.cpp'
--- src/modules/Unity/Application/debughelpers.cpp	2014-07-25 15:29:20 +0000
+++ src/common/debughelpers.cpp	2014-09-18 22:57:30 +0000
@@ -17,22 +17,24 @@
 #include "debughelpers.h"
 #include <QTouchEvent>
 
+#include <mir_toolkit/event.h>
+
 // Unity API
 #include <unity/shell/application/ApplicationInfoInterface.h>
 
-QString touchPointStateToString(Qt::TouchPointState state)
+const char *touchPointStateToString(Qt::TouchPointState state)
 {
     switch (state) {
     case Qt::TouchPointPressed:
-        return QString("pressed");
+        return "pressed";
     case Qt::TouchPointMoved:
-        return QString("moved");
+        return "moved";
     case Qt::TouchPointStationary:
-        return QString("stationary");
+        return "stationary";
     case Qt::TouchPointReleased:
-        return QString("released");
+        return "released";
     default:
-        return QString("UNKNOWN!");
+        return "UNKNOWN!";
     }
 }
 
@@ -174,6 +176,36 @@
     }
 }
 
+const char *mirMotionActionToStr(int value)
+{
+    switch (value) {
+    case mir_motion_action_move:
+        return "move";
+    case mir_motion_action_down:
+        return "down";
+    case mir_motion_action_up:
+        return "up";
+    case mir_motion_action_pointer_down:
+        return "pointer_down";
+    case mir_motion_action_cancel:
+        return "cancel";
+    case mir_motion_action_pointer_up:
+        return "pointer_up";
+    case mir_motion_action_outside:
+        return "outside";
+    case mir_motion_action_hover_move:
+        return "hover_move";
+    case mir_motion_action_scroll:
+        return "scroll";
+    case mir_motion_action_hover_enter:
+        return "hover_enter";
+    case mir_motion_action_hover_exit:
+        return "hover_exit";
+    default:
+        return "???";
+    }
+}
+
 using namespace unity::shell::application;
 
 const char *applicationStateToStr(int state)

=== renamed file 'src/modules/Unity/Application/debughelpers.h' => 'src/common/debughelpers.h'
--- src/modules/Unity/Application/debughelpers.h	2014-07-25 15:29:20 +0000
+++ src/common/debughelpers.h	2014-09-18 22:57:30 +0000
@@ -23,7 +23,7 @@
 
 class QTouchEvent;
 
-QString touchPointStateToString(Qt::TouchPointState state);
+const char *touchPointStateToString(Qt::TouchPointState state);
 QString touchEventToString(const QTouchEvent *ev);
 
 QString mirSurfaceAttribAndValueToString(MirSurfaceAttrib attrib, int value);
@@ -31,6 +31,7 @@
 const char *mirSurfaceStateToStr(int value);
 const char *mirSurfaceFocusStateToStr(int value);
 const char *mirSurfaceVisibilityToStr(int value);
+const char *mirMotionActionToStr(int value);
 
 const char *applicationStateToStr(int state);
 

=== added file 'src/lttng-compiler.pri'
--- src/lttng-compiler.pri	1970-01-01 00:00:00 +0000
+++ src/lttng-compiler.pri	2014-09-18 22:57:30 +0000
@@ -0,0 +1,25 @@
+# Add extra compiler to handle LTTng TP files
+# Append the files to the LTTNG_TP_FILES list
+
+# Note by Gerry (Aug 2014) - I tried to have lttng-gen-tp generate an object file but it failed to link with
+# the shared library we want. If there's a way to pass -fPIC to lttng-gen-tp, this workaround can be avoided
+QMAKE_EXTRA_COMPILERS += lttng_gen_tp_header
+lttng_gen_tp_header.name = "Generating headers .TP files and adding to HEADERS list"
+lttng_gen_tp_header.input = LTTNG_TP_FILES
+lttng_gen_tp_header.output = $${OUT_PWD}/${QMAKE_FILE_BASE}.h
+lttng_gen_tp_header.commands = lttng-gen-tp -o ${QMAKE_FILE_OUT} ${QMAKE_FILE_IN}
+lttng_gen_tp_header.dependency_type = TYPE_H
+lttng_gen_tp_header.variable_out = HEADERS #appends the generated file name to the HEADERS list
+lttng_gen_tp_header.CONFIG = no_link target_predeps
+
+QMAKE_EXTRA_COMPILERS += lttng_gen_tp_sources
+lttng_gen_tp_sources.name = "Generating sources from .TP files and adding to SOURCES list"
+lttng_gen_tp_sources.input = LTTNG_TP_FILES
+lttng_gen_tp_sources.output = $${OUT_PWD}/${QMAKE_FILE_BASE}.c
+lttng_gen_tp_sources.commands = lttng-gen-tp -o ${QMAKE_FILE_OUT} ${QMAKE_FILE_IN}
+lttng_gen_tp_sources.dependency_type = TYPE_C
+lttng_gen_tp_sources.variable_out = SOURCES #appends the generated file name to the SOURCES list
+lttng_gen_tp_sources.CONFIG = no_link target_predeps
+
+CONFIG    += link_pkgconfig
+PKGCONFIG += lttng-ust

=== modified file 'src/modules/Unity/Application/Application.pro'
--- src/modules/Unity/Application/Application.pro	2014-08-29 11:15:51 +0000
+++ src/modules/Unity/Application/Application.pro	2014-09-18 22:57:30 +0000
@@ -1,3 +1,5 @@
+include(../../../lttng-compiler.pri)
+
 TARGET = unityapplicationplugin
 TEMPLATE = lib
 
@@ -10,9 +12,9 @@
 QMAKE_CXXFLAGS = -std=c++11 -Werror -Wall
 QMAKE_LFLAGS = -std=c++11 -Wl,-no-undefined
 
-PKGCONFIG += mirserver glib-2.0 process-cpp ubuntu-app-launch-2
+PKGCONFIG += mirserver glib-2.0 gio-unix-2.0 process-cpp ubuntu-app-launch-2
 
-INCLUDEPATH += ../../../platforms/mirserver
+INCLUDEPATH += ../../../platforms/mirserver ../../../common
 LIBS += -L../../../platforms/mirserver -lqpa-mirserver
 QMAKE_RPATHDIR += $$[QT_INSTALL_PLUGINS]/platforms # where libqpa-mirserver.so is installed
 
@@ -24,7 +26,7 @@
 
 SOURCES += application_manager.cpp \
     application.cpp \
-    debughelpers.cpp \
+    ../../../common/debughelpers.cpp \
     desktopfilereader.cpp \
     plugin.cpp \
     applicationscreenshotprovider.cpp \
@@ -44,7 +46,7 @@
 HEADERS += application_manager.h \
     applicationcontroller.h \
     application.h \
-    debughelpers.h \
+    ../../../common/debughelpers.h \
     desktopfilereader.h \
     applicationscreenshotprovider.h \
     dbuswindowstack.h \
@@ -61,8 +63,12 @@
     processcontroller.h \
     proc_info.h \
     session.h \
+    session_interface.h \
     sessionmodel.h \
-    upstart/applicationcontroller.h
+    upstart/applicationcontroller.h \
+    gscopedpointer.h
+
+LTTNG_TP_FILES += tracepoints.tp
 
 installPath = $$[QT_INSTALL_QML]/$$replace(uri, \\., /)
 

=== modified file 'src/modules/Unity/Application/application.cpp'
--- src/modules/Unity/Application/application.cpp	2014-09-15 19:06:47 +0000
+++ src/modules/Unity/Application/application.cpp	2014-09-18 22:57:30 +0000
@@ -17,11 +17,13 @@
 // local
 #include "application.h"
 #include "application_manager.h"
-#include "debughelpers.h"
 #include "desktopfilereader.h"
 #include "session.h"
 #include "taskcontroller.h"
 
+// common
+#include <debughelpers.h>
+
 // QPA mirserver
 #include "logging.h"
 
@@ -256,9 +258,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/application.h'
--- src/modules/Unity/Application/application.h	2014-09-08 21:42:56 +0000
+++ src/modules/Unity/Application/application.h	2014-09-18 22:57:30 +0000
@@ -21,6 +21,7 @@
 #include <memory>
 
 //Qt
+#include <QColor>
 #include <QtCore/QtCore>
 #include <QImage>
 #include <QSharedPointer>
@@ -82,12 +83,12 @@
     Stage stage() const override;
     State state() const override;
     bool focused() const override;
-    QString splashTitle() const override;
-    QUrl splashImage() const override;
-    bool splashShowHeader() const override;
-    QColor splashColor() const override;
-    QColor splashColorHeader() const override;
-    QColor splashColorFooter() const override;
+    QString splashTitle() const;
+    QUrl splashImage() const;
+    bool splashShowHeader() const;
+    QColor splashColor() const;
+    QColor splashColorHeader() const;
+    QColor splashColorFooter() const;
 
     void setStage(Stage stage);
     void setState(State state);

=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2014-09-08 21:05:15 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2014-09-18 22:57:30 +0000
@@ -23,7 +23,7 @@
 #include "proc_info.h"
 #include "taskcontroller.h"
 #include "upstart/applicationcontroller.h"
-
+#include "tracepoints.h" // generated from tracepoints.tp
 
 // mirserver
 #include "mirserverconfiguration.h"
@@ -424,6 +424,7 @@
 Application *ApplicationManager::startApplication(const QString &inputAppId, ExecFlags flags,
                                                   const QStringList &arguments)
 {
+    tracepoint(qtmir, startApplication);
     QString appId = toShortAppIdIfPossible(inputAppId);
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::startApplication - this=" << this << "appId" << qPrintable(appId);
 
@@ -461,6 +462,7 @@
 
 void ApplicationManager::onProcessStarting(const QString &appId)
 {
+    tracepoint(qtmir, onProcessStarting);
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onProcessStarting - appId=" << appId;
 
     Application *application = findApplication(appId);
@@ -562,6 +564,7 @@
 
 void ApplicationManager::onProcessStopped(const QString &appId)
 {
+    tracepoint(qtmir, onProcessStopped);
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::onProcessStopped - appId=" << appId;
     Application *application = findApplication(appId);
 
@@ -637,16 +640,21 @@
 
 void ApplicationManager::authorizeSession(const quint64 pid, bool &authorized)
 {
+    tracepoint(qtmir, authorizeSession);
     authorized = false; //to be proven wrong
 
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::authorizeSession - pid=" << pid;
 
     for (Application *app : m_applications) {
-        if (app->state() == Application::Starting
-                && m_taskController->appIdHasProcessId(app->appId(), pid)) {
-            app->setPid(pid);
-            authorized = true;
-            return;
+        if (app->state() == Application::Starting) {
+            tracepoint(qtmir, appIdHasProcessId_start);
+            if (m_taskController->appIdHasProcessId(app->appId(), pid)) {
+                app->setPid(pid);
+                authorized = true;
+                tracepoint(qtmir, appIdHasProcessId_end, 1); //found
+                return;
+            }
+            tracepoint(qtmir, appIdHasProcessId_end, 0); // not found
         }
     }
 

=== modified file 'src/modules/Unity/Application/desktopfilereader.cpp'
--- src/modules/Unity/Application/desktopfilereader.cpp	2014-08-07 18:15:45 +0000
+++ src/modules/Unity/Application/desktopfilereader.cpp	2014-09-18 22:57:30 +0000
@@ -16,142 +16,192 @@
 
 // local
 #include "desktopfilereader.h"
+#include "gscopedpointer.h"
 #include "logging.h"
 
 // Qt
 #include <QFile>
+#include <QLocale>
+
+// GIO
+#include <gio/gdesktopappinfo.h>
 
 namespace qtmir
 {
 
-DesktopFileReader::Factory::Factory()
-{
-}
-
-DesktopFileReader::Factory::~Factory()
-{
-}
 
 DesktopFileReader* DesktopFileReader::Factory::createInstance(const QString &appId, const QFileInfo& fi)
 {
     return new DesktopFileReader(appId, fi);
 }
 
-// Retrieves the size of an array at compile time.
-#define ARRAY_SIZE(a) \
-    ((sizeof(a) / sizeof(*(a))) / static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
+typedef GObjectScopedPointer<GAppInfo> GAppInfoPointer;
+
+struct DesktopFileReaderPrivate
+{
+    DesktopFileReaderPrivate(DesktopFileReader *parent):
+            q_ptr( parent )
+    {}
+
+    QString getKey(const char *key) const
+    {
+        if (!loaded()) return QString();
+
+        return QString::fromUtf8(g_desktop_app_info_get_string((GDesktopAppInfo*)appInfo.data(), key));
+    }
+
+    bool loaded() const
+    {
+        return !appInfo.isNull();
+    }
+
+    DesktopFileReader * const q_ptr;
+    Q_DECLARE_PUBLIC(DesktopFileReader)
+
+    QString appId;
+    QString file;
+    GAppInfoPointer appInfo; // GAppInfo is actually implemented by GDesktopAppInfo
+};
+
 
 DesktopFileReader::DesktopFileReader(const QString &appId, const QFileInfo &desktopFile)
-    : appId_(appId)
-    , entries_(DesktopFileReader::kNumberOfEntries, "")
+    : d_ptr(new DesktopFileReaderPrivate(this))
 {
     qCDebug(QTMIR_APPLICATIONS) << "DesktopFileReader::DesktopFileReader - this=" << this << "appId=" << appId;
-
-    file_ = desktopFile.absoluteFilePath();
-    loaded_ = loadDesktopFile(file_);
+    Q_D(DesktopFileReader);
+
+    d->appId = appId;
+    d->file = desktopFile.absoluteFilePath();
+    d->appInfo.reset((GAppInfo*) g_desktop_app_info_new_from_filename(d->file.toUtf8().constData()));
+
+    if (!d->loaded()) {
+        qWarning() << "Desktop file for appId:" << appId << "at:" << d->file << "does not exist, or is not valid";
+    }
 }
 
 DesktopFileReader::~DesktopFileReader()
 {
-    qCDebug(QTMIR_APPLICATIONS) << "DesktopFileReader::~DesktopFileReader";
-    entries_.clear();
-}
-
-bool DesktopFileReader::loadDesktopFile(QString desktopFile)
-{
-    qCDebug(QTMIR_APPLICATIONS) << "DesktopFileReader::loadDesktopFile - this=" << this << "desktopFile=" << desktopFile;
-
-    if (this->file().isNull() || this->file().isEmpty()) {
-        qCritical() << "No desktop file found for appId:" << appId_;
-        return false;
-    }
-
-    Q_ASSERT(desktopFile != NULL);
-    const struct { const char* const name; int size; unsigned int flag; } kEntryNames[] = {
-        { "Name=", sizeof("Name=") - 1, 1 << DesktopFileReader::kNameIndex },
-        { "Comment=", sizeof("Comment=") - 1, 1 << DesktopFileReader::kCommentIndex },
-        { "Icon=", sizeof("Icon=") - 1, 1 << DesktopFileReader::kIconIndex },
-        { "Exec=", sizeof("Exec=") - 1, 1 << DesktopFileReader::kExecIndex },
-        { "Path=", sizeof("Path=") - 1, 1 << DesktopFileReader::kPathIndex },
-        { "X-Ubuntu-StageHint=", sizeof("X-Ubuntu-StageHint=") - 1, 1 << DesktopFileReader::kStageHintIndex },
-        { "X-Ubuntu-Splash-Title=", sizeof("X-Ubuntu-Splash-Title=") - 1, 1 << DesktopFileReader::kSplashTitleIndex },
-        { "X-Ubuntu-Splash-Image=", sizeof("X-Ubuntu-Splash-Image=") - 1, 1 << DesktopFileReader::kSplashImageIndex },
-        { "X-Ubuntu-Splash-Show-Header=", sizeof("X-Ubuntu-Splash-Show-Header=") - 1, 1 << DesktopFileReader::kSplashShowHeaderIndex },
-        { "X-Ubuntu-Splash-Color=", sizeof("X-Ubuntu-Splash-Color=") - 1, 1 << DesktopFileReader::kSplashColorIndex },
-        { "X-Ubuntu-Splash-Color-Header=", sizeof("X-Ubuntu-Splash-Color-Header=") - 1, 1 << DesktopFileReader::kSplashColorHeaderIndex },
-        { "X-Ubuntu-Splash-Color-Footer=", sizeof("X-Ubuntu-Splash-Color-Footer=") - 1, 1 << DesktopFileReader::kSplashColorFooterIndex }
-    };
-    const unsigned int kAllEntriesMask =
-            (1 << DesktopFileReader::kNameIndex) | (1 << DesktopFileReader::kCommentIndex)
-            | (1 << DesktopFileReader::kIconIndex) | (1 << DesktopFileReader::kExecIndex)
-            | (1 << DesktopFileReader::kPathIndex) | (1 << DesktopFileReader::kStageHintIndex)
-            | (1 << DesktopFileReader::kSplashTitleIndex) | (1 << DesktopFileReader::kSplashImageIndex)
-            | (1 << DesktopFileReader::kSplashShowHeaderIndex) | (1 << DesktopFileReader::kSplashColorIndex)
-            | (1 << DesktopFileReader::kSplashColorHeaderIndex) | (1 << DesktopFileReader::kSplashColorFooterIndex);
-    const unsigned int kMandatoryEntriesMask =
-            (1 << DesktopFileReader::kNameIndex) | (1 << DesktopFileReader::kIconIndex)
-            | (1 << DesktopFileReader::kExecIndex);
-    const int kEntriesCount = ARRAY_SIZE(kEntryNames);
-    const int kBufferSize = 256;
-    static char buffer[kBufferSize];
-    QFile file(desktopFile);
-
-    // Open file.
-    if (!file.open(QFile::ReadOnly | QIODevice::Text)) {
-        qWarning() << "Can't open file:" << file.errorString();
-        return false;
-    }
-
-    // Validate "magic key" (standard group header).
-    if (file.readLine(buffer, kBufferSize) != -1) {
-        if (strncmp(buffer, "[Desktop Entry]", sizeof("[Desktop Entry]") - 1)) {
-            qWarning() << "not a desktop file, unable to read it";
-            return false;
-        }
-    }
-
-    int length;
-    unsigned int entryFlags = 0;
-    while ((length = file.readLine(buffer, kBufferSize)) != -1) {
-        // Skip empty lines.
-        if (length > 1) {
-            // Stop when reaching unsupported next group header.
-            if (buffer[0] == '[') {
-                qWarning() << "reached next group header, leaving loop";
-                break;
-            }
-            // Lookup entries ignoring duplicates if any.
-            for (int i = 0; i < kEntriesCount; i++) {
-                if (!strncmp(buffer, kEntryNames[i].name, kEntryNames[i].size)) {
-                    if (~entryFlags & kEntryNames[i].flag) {
-                        buffer[length-1] = '\0';
-                        entries_[i] = QString::fromUtf8(&buffer[kEntryNames[i].size]);
-                        entryFlags |= kEntryNames[i].flag;
-                        break;
-                    }
-                }
-            }
-            // Stop when matching the right number of entries.
-            if (entryFlags == kAllEntriesMask) {
-                break;
-            }
-        }
-    }
-
-    // Check that the mandatory entries are set.
-    if ((entryFlags & kMandatoryEntriesMask) == kMandatoryEntriesMask) {
-        qDebug("loaded desktop file with name='%s', comment='%s', icon='%s', exec='%s', path='%s', stagehint='%s'",
-                qPrintable(entries_[DesktopFileReader::kNameIndex]),
-                qPrintable(entries_[DesktopFileReader::kCommentIndex]),
-                qPrintable(entries_[DesktopFileReader::kIconIndex]),
-                qPrintable(entries_[DesktopFileReader::kExecIndex]),
-                qPrintable(entries_[DesktopFileReader::kPathIndex]),
-                qPrintable(entries_[DesktopFileReader::kStageHintIndex]));
-        return true;
-    } else {
-        qWarning() << "not a valid desktop file, missing mandatory entries in the standard group header";
-        return false;
-    }
+    Q_D(const DesktopFileReader);
+    qCDebug(QTMIR_APPLICATIONS) << "DesktopFileReader::~DesktopFileReader - this=" << this << "appId=" << d->appId;
+    delete d_ptr;
+}
+
+QString DesktopFileReader::file() const
+{
+    Q_D(const DesktopFileReader);
+    return d->file;
+}
+
+QString DesktopFileReader::appId() const
+{
+    Q_D(const DesktopFileReader);
+    return d->appId;
+}
+
+QString DesktopFileReader::name() const
+{
+    Q_D(const DesktopFileReader);
+    if (!d->loaded()) return QString();
+
+    return QString::fromUtf8(g_app_info_get_name(d->appInfo.data()));
+}
+
+QString DesktopFileReader::comment() const
+{
+    Q_D(const DesktopFileReader);
+    if (!d->loaded()) return QString();
+
+    return QString::fromUtf8(g_app_info_get_description(d->appInfo.data()));
+}
+
+QString DesktopFileReader::icon() const
+{
+    Q_D(const DesktopFileReader);
+    return d->getKey("Icon");
+}
+
+QString DesktopFileReader::exec() const
+{
+    Q_D(const DesktopFileReader);
+    if (!d->loaded()) return QString();
+
+    return QString::fromUtf8(g_app_info_get_commandline(d->appInfo.data()));
+}
+
+QString DesktopFileReader::path() const
+{
+    Q_D(const DesktopFileReader);
+    return d->getKey("Path");
+}
+
+QString DesktopFileReader::stageHint() const
+{
+    Q_D(const DesktopFileReader);
+    return d->getKey("X-Ubuntu-StageHint");
+}
+
+QString DesktopFileReader::splashTitle() const
+{
+    Q_D(const DesktopFileReader);
+    if (!d->loaded()) return QString();
+
+    /* Sadly GDesktopAppInfo only considers Name, GenericName, Comments and Keywords to be keys
+     * which can have locale-specific entries. So we need to work to make X-Ubuntu-Splash-Title
+     * locale-aware, but generating a locale-correct key name and seeing if that exists. If yes,
+     * get and return it. Else fallback to the non-localized key.
+     */
+    GDesktopAppInfo *info = (GDesktopAppInfo*)d->appInfo.data();
+    QLocale defaultLocale;
+    QStringList locales = defaultLocale.uiLanguages();
+
+    QString keyTemplate("X-Ubuntu-Splash-Title[%1]");
+    for (QString locale: locales) {
+        // Desktop files use local specifiers with underscore separaters but Qt uses hyphens
+        locale = locale.replace('-', '_');
+        const char* key = keyTemplate.arg(locale).toUtf8().constData();
+        if (g_desktop_app_info_has_key(info, key)) {
+            return d->getKey(key);
+        }
+    }
+
+    // Fallback to the non-localized string, if available
+    return d->getKey("X-Ubuntu-Splash-Title");
+}
+
+QString DesktopFileReader::splashImage() const
+{
+    Q_D(const DesktopFileReader);
+    return d->getKey("X-Ubuntu-Splash-Image");
+}
+
+QString DesktopFileReader::splashShowHeader() const
+{
+    Q_D(const DesktopFileReader);
+    return d->getKey("X-Ubuntu-Splash-Show-Header");
+}
+
+QString DesktopFileReader::splashColor() const
+{
+    Q_D(const DesktopFileReader);
+    return d->getKey("X-Ubuntu-Splash-Color");
+}
+
+QString DesktopFileReader::splashColorHeader() const
+{
+    Q_D(const DesktopFileReader);
+    return d->getKey("X-Ubuntu-Splash-Color-Header");
+}
+
+QString DesktopFileReader::splashColorFooter() const
+{
+    Q_D(const DesktopFileReader);
+    return d->getKey("X-Ubuntu-Splash-Color-Footer");
+}
+
+bool DesktopFileReader::loaded() const
+{
+    Q_D(const DesktopFileReader);
+    return d->loaded();
 }
 
 } // namespace qtmir

=== modified file 'src/modules/Unity/Application/desktopfilereader.h'
--- src/modules/Unity/Application/desktopfilereader.h	2014-08-07 18:15:45 +0000
+++ src/modules/Unity/Application/desktopfilereader.h	2014-09-18 22:57:30 +0000
@@ -18,20 +18,19 @@
 #define DESKTOPFILEREADER_H
 
 #include <QString>
-#include <QVector>
 #include <QFileInfo>
 
 namespace qtmir
 {
 
+class DesktopFileReaderPrivate;
 class DesktopFileReader {
 public:
     class Factory
     {
     public:
-        Factory();
+        Factory() = default;
         Factory(const Factory&) = delete;
-        virtual ~Factory();
 
         Factory& operator=(const Factory&) = delete;
 
@@ -40,48 +39,31 @@
 
     virtual ~DesktopFileReader();
 
-    virtual QString file() const { return file_; }
-    virtual QString appId() const { return appId_; }
-    virtual QString name() const { return entries_[kNameIndex]; }
-    virtual QString comment() const { return entries_[kCommentIndex]; }
-    virtual QString icon() const { return entries_[kIconIndex]; }
-    virtual QString exec() const { return entries_[kExecIndex]; }
-    virtual QString path() const { return entries_[kPathIndex]; }
-    virtual QString stageHint() const { return entries_[kStageHintIndex]; }
-    virtual QString splashTitle() const { return entries_[kSplashTitleIndex]; }
-    virtual QString splashImage() const { return entries_[kSplashImageIndex]; }
-    virtual QString splashShowHeader() const { return entries_[kSplashShowHeaderIndex]; }
-    virtual QString splashColor() const { return entries_[kSplashColorIndex]; }
-    virtual QString splashColorHeader() const { return entries_[kSplashColorHeaderIndex]; }
-    virtual QString splashColorFooter() const { return entries_[kSplashColorFooterIndex]; }
-    virtual bool loaded() const { return loaded_; }
+    virtual QString file() const;
+    virtual QString appId() const;
+    virtual QString name() const;
+    virtual QString comment() const;
+    virtual QString icon() const;
+    virtual QString exec() const;
+    virtual QString path() const;
+    virtual QString stageHint() const;
+    virtual QString splashTitle() const;
+    virtual QString splashImage() const;
+    virtual QString splashShowHeader() const;
+    virtual QString splashColor() const;
+    virtual QString splashColorHeader() const;
+    virtual QString splashColorFooter() const;
+    virtual bool loaded() const;
 
 protected:
+    DesktopFileReader(const QString &appId, const QFileInfo &desktopFile);
+
+    DesktopFileReaderPrivate * const d_ptr;
+
     friend class DesktopFileReaderFactory;
 
-    DesktopFileReader(const QString &appId, const QFileInfo &desktopFile);
-
 private:
-    static const int kNameIndex = 0,
-    kCommentIndex = 1,
-    kIconIndex = 2,
-    kExecIndex = 3,
-    kPathIndex = 4,
-    kStageHintIndex = 5,
-    kSplashTitleIndex = 6,
-    kSplashImageIndex = 7,
-    kSplashShowHeaderIndex = 8,
-    kSplashColorIndex = 9,
-    kSplashColorHeaderIndex = 10,
-    kSplashColorFooterIndex = 11,
-    kNumberOfEntries = 12;
-
-    virtual bool loadDesktopFile(QString desktopFile);
-
-    QString appId_;
-    QString file_;
-    QVector<QString> entries_;
-    bool loaded_;
+    Q_DECLARE_PRIVATE(DesktopFileReader)
 };
 
 } // namespace qtmir

=== added file 'src/modules/Unity/Application/gscopedpointer.h'
--- src/modules/Unity/Application/gscopedpointer.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/gscopedpointer.h	2014-09-18 22:57:30 +0000
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2011-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/>.
+ *
+ * Authors:
+ * - Aurélien Gâteau <[e-mail]>
+ */
+
+#ifndef GSCOPEDPOINTER_H
+#define GSCOPEDPOINTER_H
+
+// Local
+
+// Qt
+#include <QScopedPointer>
+
+// GLib
+#include <glib-object.h>
+
+/**
+ * Helper class for GScopedPointer
+ */
+template <class T, void (*cleanup_fcn)(T*)>
+class GScopedPointerDeleter
+{
+public:
+    static void cleanup(T* ptr)
+    {
+        if (ptr) {
+            cleanup_fcn(ptr);
+        }
+    }
+};
+
+/**
+ * A GScopedPointer works like a QScopedPointer, except the cleanup static
+ * method is replaced with a cleanup function, making it useful to handle C
+ * structs whose cleanup function prototype is "void cleanup(T*)"
+ *
+ * Best way to use it is to define a typedef for your C struct, like this:
+ *
+ * typedef GScopedPointer<Foo, foo_free> GFooPointer;
+ */
+template <class T, void (*cleanup)(T*)>
+class GScopedPointer : public QScopedPointer<T, GScopedPointerDeleter<T, cleanup> >
+{
+public:
+    GScopedPointer(T* ptr = 0)
+    : QScopedPointer<T, GScopedPointerDeleter<T, cleanup> >(ptr)
+    {}
+};
+
+
+/**
+ * Helper class for GObjectScopedPointer
+ */
+template <class T, void (*cleanup_fcn)(gpointer)>
+class GObjectScopedPointerDeleter
+{
+public:
+    static void cleanup(T* ptr)
+    {
+        if (ptr) {
+            cleanup_fcn(ptr);
+        }
+    }
+};
+
+/**
+ * A GObjectScopedPointer is similar to a GScopedPointer. The only difference
+ * is its cleanup function signature is "void cleanup(gpointer)" and defaults to
+ * g_object_unref(), making it useful for GObject-based classes.
+ *
+ * You can use it directly like this:
+ *
+ * GObjectScopedPointer<GFoo> foo;
+ *
+ * Or define a typedef for your class:
+ *
+ * typedef GObjectScopedPointer<GFoo> GFooPointer;
+ *
+ * Note: GObjectScopedPointer does *not* call gobject_ref() when assigned a
+ * pointer.
+ */
+template <class T, void (*cleanup)(gpointer) = g_object_unref>
+class GObjectScopedPointer : public QScopedPointer<T, GObjectScopedPointerDeleter<T, cleanup> >
+{
+public:
+    GObjectScopedPointer(T* ptr = 0)
+    : QScopedPointer<T, GObjectScopedPointerDeleter<T, cleanup> >(ptr)
+    {}
+};
+
+// A Generic GObject pointer
+typedef GObjectScopedPointer<GObject> GObjectPointer;
+
+// Take advantage of the cleanup signature of GObjectScopedPointer to define
+// a GCharPointer
+typedef GObjectScopedPointer<gchar, g_free> GCharPointer;
+
+#endif /* GSCOPEDPOINTER_H */
+

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.cpp'
--- src/modules/Unity/Application/mirsurfaceitem.cpp	2014-08-29 14:58:07 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.cpp	2014-09-18 22:57:30 +0000
@@ -20,12 +20,14 @@
 
 // local
 #include "application.h"
-#include "debughelpers.h"
 #include "mirbuffersgtexture.h"
 #include "session.h"
 #include "mirsurfaceitem.h"
 #include "logging.h"
 
+// common
+#include <debughelpers.h>
+
 // Qt
 #include <QDebug>
 #include <QQmlEngine>
@@ -85,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;
 
@@ -97,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;
@@ -136,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;
@@ -232,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)
@@ -240,6 +244,7 @@
     , m_firstFrameDrawn(false)
     , m_live(true)
     , m_textureProvider(nullptr)
+    , m_lastTouchEvent(nullptr)
 {
     qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::MirSurfaceItem";
 
@@ -314,6 +319,8 @@
     m_surface->remove_observer(m_surfaceObserver);
     if (m_textureProvider)
         m_textureProvider->deleteLater();
+
+    delete m_lastTouchEvent;
 }
 
 // For QML to destroy this surface
@@ -327,7 +334,7 @@
     deleteLater();
 }
 
-Session* MirSurfaceItem::session() const
+SessionInterface* MirSurfaceItem::session() const
 {
     return m_session.data();
 }
@@ -476,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()
@@ -637,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:
@@ -674,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-18 22:57:30 +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-08-29 14:58:07 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.cpp	2014-09-18 22:57:30 +0000
@@ -19,10 +19,13 @@
 #include <QMutexLocker>
 
 // local
-#include "debughelpers.h"
 #include "mirsurfacemanager.h"
 #include "sessionmanager.h"
 #include "application_manager.h"
+#include "tracepoints.h" // generated from tracepoints.tp
+
+// common
+#include <debughelpers.h>
 
 // QPA mirserver
 #include "nativeinterface.h"
@@ -96,24 +99,25 @@
     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) {
+        tracepoint(qtmir, firstFrameDrawn);
         Q_EMIT surfaceCreated(item);
 
         insert(0, item);
@@ -128,7 +132,9 @@
         }
 
         remove(mirSurfaceItem);
+        tracepoint(qtmir, surfaceDestroyed);
     });
+    tracepoint(qtmir, surfaceCreated);
 }
 
 void MirSurfaceManager::onSessionDestroyingSurface(const mir::scene::Session *session,

=== 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-18 22:57:30 +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-18 22:57:30 +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-18 22:57:30 +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-18 22:57:30 +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-18 22:57:30 +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-18 22:57:30 +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-18 22:57:30 +0000
@@ -22,8 +22,8 @@
 
 namespace qtmir {
 
-class Session;
-typedef ObjectListModel<Session> SessionModel;
+class SessionInterface;
+typedef ObjectListModel<SessionInterface> SessionModel;
 
 } // namespace qtmir
 

=== added file 'src/modules/Unity/Application/tracepoints.tp'
--- src/modules/Unity/Application/tracepoints.tp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/tracepoints.tp	2014-09-18 22:57:30 +0000
@@ -0,0 +1,9 @@
+TRACEPOINT_EVENT(qtmir, startApplication, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(qtmir, onProcessStarting, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(qtmir, authorizeSession, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(qtmir, onProcessStopped, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(qtmir, surfaceCreated, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(qtmir, surfaceDestroyed, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(qtmir, firstFrameDrawn, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(qtmir, appIdHasProcessId_start, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(qtmir, appIdHasProcessId_end, TP_ARGS(int, found), TP_FIELDS(ctf_integer(int, found, found)))

=== modified file 'src/platforms/mirserver/logging.h'
--- src/platforms/mirserver/logging.h	2014-08-22 14:57:00 +0000
+++ src/platforms/mirserver/logging.h	2014-09-18 22:57:30 +0000
@@ -22,5 +22,6 @@
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_SESSIONS)
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_SURFACES)
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_MIR_MESSAGES)
+Q_DECLARE_LOGGING_CATEGORY(QTMIR_MIR_INPUT)
 
 #endif // UBUNTU_APPLICATION_PLUGIN_LOGGING_H

=== modified file 'src/platforms/mirserver/mirplacementstrategy.cpp'
--- src/platforms/mirserver/mirplacementstrategy.cpp	2014-07-01 13:38:06 +0000
+++ src/platforms/mirserver/mirplacementstrategy.cpp	2014-09-18 22:57:30 +0000
@@ -16,6 +16,7 @@
 
 #include "mirplacementstrategy.h"
 #include "logging.h"
+#include "tracepoints.h" // generated from tracepoints.tp
 
 #include <mir/geometry/rectangle.h>
 #include <mir/shell/display_layout.h>
@@ -35,6 +36,8 @@
 MirPlacementStrategy::place(ms::Session const& /*session*/,
         ms::SurfaceCreationParameters const& requestParameters)
 {
+    tracepoint(qtmirserver, surfacePlacementStart);
+
     // TODO: Callback unity8 so that it can make a decision on that.
     //       unity8 must bear in mind that the called function will be on a Mir thread though.
     //       The QPA shouldn't be deciding for itself on such things.
@@ -50,5 +53,7 @@
         << requestParameters.size.width.as_int() << "," << requestParameters.size.height.as_int() << ") and returned ("
         << placedParameters.size.width.as_int() << "," << placedParameters.size.height.as_int() << ")";
 
+    tracepoint(qtmirserver, surfacePlacementEnd);
+
     return placedParameters;
 }

=== modified file 'src/platforms/mirserver/mirserver.pro'
--- src/platforms/mirserver/mirserver.pro	2014-08-05 09:14:13 +0000
+++ src/platforms/mirserver/mirserver.pro	2014-09-18 22:57:30 +0000
@@ -1,3 +1,5 @@
+include(../../lttng-compiler.pri)
+
 TARGET = qpa-mirserver
 TEMPLATE = lib
 
@@ -14,6 +16,8 @@
 QMAKE_CXXFLAGS = -std=c++11 -Werror -Wall
 QMAKE_LFLAGS = -std=c++11 -Wl,-no-undefined
 
+INCLUDEPATH += ../../common
+
 CONFIG   += link_pkgconfig
 PKGCONFIG += mirserver protobuf egl xkbcommon url-dispatcher-1
 
@@ -21,6 +25,7 @@
 
 SOURCES += \
     connectioncreator.cpp \
+    ../../common/debughelpers.cpp \
     focussetter.cpp \
     qteventfeeder.cpp \
     plugin.cpp \
@@ -47,6 +52,7 @@
 
 HEADERS += \
     connectioncreator.h \
+    ../../common/debughelpers.h \
     focussetter.h \
     qteventfeeder.h \
     plugin.h \
@@ -73,6 +79,8 @@
     unityprotobufservice.h \
     unityrpc.h
 
+LTTNG_TP_FILES += tracepoints.tp
+
 # Installation path
 target.path +=  $$[QT_INSTALL_PLUGINS]/platforms
 

=== modified file 'src/platforms/mirserver/mirserverconfiguration.cpp'
--- src/platforms/mirserver/mirserverconfiguration.cpp	2014-08-05 10:02:12 +0000
+++ src/platforms/mirserver/mirserverconfiguration.cpp	2014-09-18 22:57:30 +0000
@@ -31,20 +31,31 @@
 #include "logging.h"
 #include "unityprotobufservice.h"
 
+// mir
+#include <mir/options/default_configuration.h>
+
 // Qt
 #include <QDebug>
 
 // egl
 #include <EGL/egl.h>
 
+namespace mo  = mir::options;
 namespace msh = mir::shell;
 namespace ms = mir::scene;
 
+namespace
+{
+void ignore_unparsed_arguments(int /*argc*/, char const* const/*argv*/[])
+{
+}
+}
+
 Q_LOGGING_CATEGORY(QTMIR_MIR_MESSAGES, "qtmir.mir")
 
 MirServerConfiguration::MirServerConfiguration(int argc, char const* argv[], QObject* parent)
     : QObject(parent)
-    , DefaultServerConfiguration(argc, argv)
+    , DefaultServerConfiguration(std::make_shared<mo::DefaultConfiguration>(argc, argv, &ignore_unparsed_arguments))
     , m_unityService(std::make_shared<UnityProtobufService>())
 {
     qCDebug(QTMIR_MIR_MESSAGES) << "MirServerConfiguration created";

=== modified file 'src/platforms/mirserver/qteventfeeder.cpp'
--- src/platforms/mirserver/qteventfeeder.cpp	2014-07-29 15:01:34 +0000
+++ src/platforms/mirserver/qteventfeeder.cpp	2014-09-18 22:57:30 +0000
@@ -18,10 +18,10 @@
  */
 
 #include "qteventfeeder.h"
+#include "logging.h"
 
 #include <qpa/qplatforminputcontext.h>
 #include <qpa/qplatformintegration.h>
-#include <qpa/qwindowsysteminterface.h>
 #include <QGuiApplication>
 #include <private/qguiapplication_p.h>
 
@@ -30,6 +30,8 @@
 
 #include <QDebug>
 
+Q_LOGGING_CATEGORY(QTMIR_MIR_INPUT, "qtmir.mir.input")
+
 // from android-input AMOTION_EVENT_ACTION_*, hidden inside mir bowels
 // mir headers should define them
 const int QtEventFeeder::MirEventActionMask = 0xff;
@@ -133,9 +135,61 @@
     return toupper(sym);
 }
 
-
-QtEventFeeder::QtEventFeeder()
+namespace {
+
+class QtWindowSystem : public QtEventFeeder::QtWindowSystemInterface {
+
+    bool hasTargetWindow() override
+    {
+        if (mTopLevelWindow.isNull() && !QGuiApplication::topLevelWindows().isEmpty()) {
+            mTopLevelWindow = QGuiApplication::topLevelWindows().first();
+        }
+        return !mTopLevelWindow.isNull();
+    }
+
+    QRect targetWindowGeometry() override
+    {
+        Q_ASSERT(!mTopLevelWindow.isNull());
+        return mTopLevelWindow->geometry();
+    }
+
+    void registerTouchDevice(QTouchDevice *device) override
+    {
+        QWindowSystemInterface::registerTouchDevice(device);
+    }
+
+    void handleExtendedKeyEvent(ulong timestamp, QEvent::Type type, int key,
+                Qt::KeyboardModifiers modifiers,
+                quint32 nativeScanCode, quint32 nativeVirtualKey,
+                quint32 nativeModifiers,
+                const QString& text, bool autorep, ushort count) override
+    {
+        Q_ASSERT(!mTopLevelWindow.isNull());
+        QWindowSystemInterface::handleExtendedKeyEvent(mTopLevelWindow.data(), timestamp, type, key, modifiers,
+                nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count);
+    }
+
+    void handleTouchEvent(ulong timestamp, QTouchDevice *device,
+            const QList<struct QWindowSystemInterface::TouchPoint> &points, Qt::KeyboardModifiers mods) override
+    {
+        Q_ASSERT(!mTopLevelWindow.isNull());
+        QWindowSystemInterface::handleTouchEvent(mTopLevelWindow.data(), timestamp, device, points, mods);
+    }
+private:
+    QPointer<QWindow> mTopLevelWindow;
+};
+
+} // anonymous namespace
+
+
+QtEventFeeder::QtEventFeeder(QtEventFeeder::QtWindowSystemInterface *windowSystem)
 {
+    if (windowSystem) {
+        mQtWindowSystem = windowSystem;
+    } else {
+        mQtWindowSystem = new QtWindowSystem;
+    }
+
     // Initialize touch device. Hardcoded just like in qtubuntu
     // TODO: Create them from info gathered from Mir and store things like device id and source
     //       in a QTouchDevice-derived class created by us. So that we can properly assemble back
@@ -145,7 +199,12 @@
     mTouchDevice->setCapabilities(
             QTouchDevice::Position | QTouchDevice::Area | QTouchDevice::Pressure |
             QTouchDevice::NormalizedPosition);
-    QWindowSystemInterface::registerTouchDevice(mTouchDevice);
+    mQtWindowSystem->registerTouchDevice(mTouchDevice);
+}
+
+QtEventFeeder::~QtEventFeeder()
+{
+    delete mQtWindowSystem;
 }
 
 void QtEventFeeder::dispatch(MirEvent const& event)
@@ -171,11 +230,9 @@
 
 void QtEventFeeder::dispatchKey(MirKeyEvent const& event)
 {
-    if (QGuiApplication::topLevelWindows().isEmpty())
+    if (!mQtWindowSystem->hasTargetWindow())
         return;
 
-    QWindow *window = QGuiApplication::topLevelWindows().first();
-
     ulong timestamp = event.event_time / 1000000;
     xkb_keysym_t xk_sym = static_cast<xkb_keysym_t>(event.key_code);
 
@@ -221,20 +278,33 @@
         }
     }
 
-    QWindowSystemInterface::handleExtendedKeyEvent(window, timestamp, keyType, keyCode, modifiers, event.scan_code, event.key_code, event.modifiers, text);
+    mQtWindowSystem->handleExtendedKeyEvent(timestamp, keyType, keyCode, modifiers,
+            event.scan_code, event.key_code, event.modifiers, text);
 }
 
 void QtEventFeeder::dispatchMotion(MirMotionEvent const& event)
 {
-    if (QGuiApplication::topLevelWindows().isEmpty())
-        return;
-
-    QWindow *window = QGuiApplication::topLevelWindows().first();
+    if (!mQtWindowSystem->hasTargetWindow())
+        return;
+
+    const int mirMotionAction = event.action & MirEventActionMask;
+
+    // Ignore the events that do not interest us (or that we currently don't support or know
+    // how to translate into Qt events)
+    if (mirMotionAction != mir_motion_action_move
+            && mirMotionAction != mir_motion_action_down
+            && mirMotionAction != mir_motion_action_up
+            && mirMotionAction != mir_motion_action_pointer_down
+            && mirMotionAction != mir_motion_action_pointer_up
+            && mirMotionAction != mir_motion_action_cancel) {
+        return;
+    }
+
 
     // FIXME(loicm) Max pressure is device specific. That one is for the Samsung Galaxy Nexus. That
     //     needs to be fixed as soon as the compat input lib adds query support.
     const float kMaxPressure = 1.28;
-    const QRect kWindowGeometry = window->geometry();
+    const QRect kWindowGeometry = mQtWindowSystem->targetWindowGeometry();
     QList<QWindowSystemInterface::TouchPoint> touchPoints;
 
     // TODO: Is it worth setting the Qt::TouchPointStationary ones? Currently they are left
@@ -257,7 +327,7 @@
         touchPoints.append(touchPoint);
     }
 
-    switch (event.action & MirEventActionMask) {
+    switch (mirMotionAction) {
     case mir_motion_action_move:
         // No extra work needed.
         break;
@@ -291,13 +361,17 @@
     case mir_motion_action_scroll:
     case mir_motion_action_hover_enter:
     case mir_motion_action_hover_exit:
-        default:
-        qWarning() << "unhandled motion event action" << (int)(event.action & MirEventActionMask);
+    default:
+        // Should never reach this point. If so, it's a programming error.
+        qFatal("Trying to handle unsupported motion event action");
     }
 
+    // Qt needs a happy, sane stream of touch events. So let's make sure we're not forwarding
+    // any insanity.
+    validateTouches(touchPoints);
+
     // Touch event propagation.
-    QWindowSystemInterface::handleTouchEvent(
-            window,
+    mQtWindowSystem->handleTouchEvent(
             event.event_time / 1000000, //scales down the nsec_t (int64) to fit a ulong, precision lost but time difference suitable
             mTouchDevice,
             touchPoints);
@@ -323,3 +397,86 @@
     Q_UNUSED(device_id);
     Q_UNUSED(when);
 }
+
+void QtEventFeeder::validateTouches(QList<QWindowSystemInterface::TouchPoint> &touchPoints)
+{
+    QSet<int> updatedTouches;
+
+    {
+        int i = 0;
+        while (i < touchPoints.count()) {
+            bool mustDiscardTouch = !validateTouch(touchPoints[i]);
+            if (mustDiscardTouch) {
+                touchPoints.removeAt(i);
+            } else {
+                updatedTouches.insert(touchPoints.at(i).id);
+                ++i;
+            }
+        }
+    }
+
+    // Release all unmentioned touches.
+    {
+        QHash<int, QWindowSystemInterface::TouchPoint>::iterator it = mActiveTouches.begin();
+        while (it != mActiveTouches.end()) {
+            if (!updatedTouches.contains(it.key())) {
+                qCWarning(QTMIR_MIR_INPUT)
+                    << "There's a touch (id =" << it.key() << ") missing. Releasing it.";
+                it.value().state = Qt::TouchPointReleased;
+                touchPoints.append(it.value());
+                it = mActiveTouches.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    }
+}
+
+bool QtEventFeeder::validateTouch(QWindowSystemInterface::TouchPoint &touchPoint)
+{
+    bool ok = true;
+
+    switch (touchPoint.state) {
+    case Qt::TouchPointPressed:
+        if (mActiveTouches.contains(touchPoint.id)) {
+            qCWarning(QTMIR_MIR_INPUT)
+                << "Would press an already existing touch (id =" << touchPoint.id
+                << "). Making it move instead.";
+            touchPoint.state = Qt::TouchPointMoved;
+        }
+        mActiveTouches[touchPoint.id] = touchPoint;
+        break;
+    case Qt::TouchPointMoved:
+        if (!mActiveTouches.contains(touchPoint.id)) {
+            qCWarning(QTMIR_MIR_INPUT)
+                << "Would move a touch that wasn't pressed before (id =" << touchPoint.id
+                << "). Making it press instead.";
+            touchPoint.state = Qt::TouchPointPressed;
+        }
+        mActiveTouches[touchPoint.id] = touchPoint;
+        break;
+    case Qt::TouchPointStationary:
+        if (!mActiveTouches.contains(touchPoint.id)) {
+            qCWarning(QTMIR_MIR_INPUT)
+                << "There's an stationary touch that wasn't pressed before (id =" << touchPoint.id
+                << "). Making it press instead.";
+            touchPoint.state = Qt::TouchPointPressed;
+        }
+        mActiveTouches[touchPoint.id] = touchPoint;
+        break;
+    case Qt::TouchPointReleased:
+        if (!mActiveTouches.contains(touchPoint.id)) {
+            qCWarning(QTMIR_MIR_INPUT)
+                << "Would release a touch that wasn't pressed before (id =" << touchPoint.id
+                << "). Ignoring it.";
+            ok = false;
+        } else {
+            mActiveTouches.remove(touchPoint.id);
+        }
+        break;
+    default:
+        qFatal("QtEventFeeder: invalid touch state");
+    }
+
+    return ok;
+}

=== modified file 'src/platforms/mirserver/qteventfeeder.h'
--- src/platforms/mirserver/qteventfeeder.h	2014-07-18 20:23:35 +0000
+++ src/platforms/mirserver/qteventfeeder.h	2014-09-18 22:57:30 +0000
@@ -22,6 +22,8 @@
 #include <mir/input/input_dispatcher.h>
 #include <mir/shell/input_targeter.h>
 
+#include <qpa/qwindowsysteminterface.h>
+
 class QTouchDevice;
 
 /*
@@ -30,7 +32,29 @@
 class QtEventFeeder : public mir::input::InputDispatcher
 {
 public:
-    QtEventFeeder();
+    // Interface between QtEventFeeder and the actual QWindowSystemInterface functions
+    // and other related Qt methods and objects to enable replacing them with mocks in
+    // pure unit tests.
+    // TODO - Make it work with multimonitor scenarios
+    class QtWindowSystemInterface {
+        public:
+        virtual ~QtWindowSystemInterface() {}
+        virtual bool hasTargetWindow() = 0;
+        virtual QRect targetWindowGeometry() = 0;
+        virtual void registerTouchDevice(QTouchDevice *device) = 0;
+        virtual void handleExtendedKeyEvent(ulong timestamp, QEvent::Type type, int key,
+                Qt::KeyboardModifiers modifiers,
+                quint32 nativeScanCode, quint32 nativeVirtualKey,
+                quint32 nativeModifiers,
+                const QString& text = QString(), bool autorep = false,
+                ushort count = 1) = 0;
+        virtual void handleTouchEvent(ulong timestamp, QTouchDevice *device,
+                const QList<struct QWindowSystemInterface::TouchPoint> &points,
+                Qt::KeyboardModifiers mods = Qt::NoModifier) = 0;
+    };
+
+    QtEventFeeder(QtWindowSystemInterface *windowSystem = nullptr);
+    virtual ~QtEventFeeder();
 
     static const int MirEventActionMask;
     static const int MirEventActionPointerIndexMask;
@@ -45,8 +69,14 @@
 private:
     void dispatchKey(MirKeyEvent const& event);
     void dispatchMotion(MirMotionEvent const& event);
+    void validateTouches(QList<QWindowSystemInterface::TouchPoint> &touchPoints);
+    bool validateTouch(QWindowSystemInterface::TouchPoint &touchPoint);
 
     QTouchDevice *mTouchDevice;
+    QtWindowSystemInterface *mQtWindowSystem;
+
+    // Maps the id of an active touch to its last known state
+    QHash<int, QWindowSystemInterface::TouchPoint> mActiveTouches;
 };
 
 #endif // MIR_QT_EVENT_FEEDER_H

=== modified file 'src/platforms/mirserver/sessionauthorizer.cpp'
--- src/platforms/mirserver/sessionauthorizer.cpp	2014-07-18 08:53:13 +0000
+++ src/platforms/mirserver/sessionauthorizer.cpp	2014-09-18 22:57:30 +0000
@@ -16,6 +16,7 @@
 
 #include "sessionauthorizer.h"
 #include "logging.h"
+#include "tracepoints.h" // generated from tracepoints.tp
 
 // mir
 #include <mir/frontend/session_credentials.h>
@@ -33,10 +34,13 @@
 
 bool SessionAuthorizer::connection_is_allowed(SessionCredentials const& creds)
 {
+    tracepoint(qtmirserver, sessionAuthorizeStart);
     qCDebug(QTMIR_MIR_MESSAGES) << "SessionAuthorizer::connection_is_allowed - this=" << this << "pid=" << creds.pid();
     bool authorized = true;
 
     Q_EMIT requestAuthorizationForSession(creds.pid(), authorized); // needs to block until authorized value returned
+    tracepoint(qtmirserver, sessionAuthorizeEnd);
+
     return authorized;
 }
 

=== modified file 'src/platforms/mirserver/sessionlistener.cpp'
--- src/platforms/mirserver/sessionlistener.cpp	2014-07-01 13:38:06 +0000
+++ src/platforms/mirserver/sessionlistener.cpp	2014-09-18 22:57:30 +0000
@@ -16,6 +16,7 @@
 
 #include "sessionlistener.h"
 #include "logging.h"
+#include "tracepoints.h" // generated from tracepoints.tp
 
 namespace ms = mir::scene;
 
@@ -38,12 +39,14 @@
 
 void SessionListener::starting(std::shared_ptr<ms::Session> const& session)
 {
+    tracepoint(qtmirserver, starting);
     qCDebug(QTMIR_MIR_MESSAGES) << "SessionListener::starting - this=" << this << "session=" << session.get();
     Q_EMIT sessionStarting(session);
 }
 
 void SessionListener::stopping(std::shared_ptr<ms::Session> const& session)
 {
+    tracepoint(qtmirserver, stopping);
     qCDebug(QTMIR_MIR_MESSAGES) << "SessionListener::stopping - this=" << this << "session=" << session.get();
     Q_EMIT sessionStopping(session);
 }
@@ -62,6 +65,7 @@
 
 void SessionListener::surface_created(ms::Session& session, std::shared_ptr<ms::Surface> const& surface)
 {
+    tracepoint(qtmirserver, surfaceCreated);
     qCDebug(QTMIR_MIR_MESSAGES) << "SessionListener::surface_created - this=" << this << "session=" << &session
                                    << "surface=" << surface.get();
     Q_EMIT sessionCreatedSurface(&session, surface);
@@ -69,6 +73,7 @@
 
 void SessionListener::destroying_surface(ms::Session& session, std::shared_ptr<ms::Surface> const& surface)
 {
+    tracepoint(qtmirserver, surfaceDestroyed);
     qCDebug(QTMIR_MIR_MESSAGES) << "SessionListener::destroying_surface - this=" << this << "session=" << &session
                                    << "surface=" << surface.get();
     Q_EMIT sessionDestroyingSurface(&session, surface);

=== added file 'src/platforms/mirserver/tracepoints.tp'
--- src/platforms/mirserver/tracepoints.tp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/tracepoints.tp	2014-09-18 22:57:30 +0000
@@ -0,0 +1,10 @@
+TRACEPOINT_EVENT(qtmirserver, starting, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(qtmirserver, stopping, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(qtmirserver, surfaceCreated, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(qtmirserver, surfaceDestroyed, TP_ARGS(0), TP_FIELDS())
+
+TRACEPOINT_EVENT(qtmirserver, sessionAuthorizeStart, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(qtmirserver, sessionAuthorizeEnd, TP_ARGS(0), TP_FIELDS())
+
+TRACEPOINT_EVENT(qtmirserver, surfacePlacementStart, TP_ARGS(0), TP_FIELDS())
+TRACEPOINT_EVENT(qtmirserver, surfacePlacementEnd, TP_ARGS(0), TP_FIELDS())

=== added file 'tests/google-mock.pri'
--- tests/google-mock.pri	1970-01-01 00:00:00 +0000
+++ tests/google-mock.pri	2014-09-18 22:57:30 +0000
@@ -0,0 +1,24 @@
+GMOCK_SOURCES = /usr/src/gmock/src/gmock-all.cc \
+                /usr/src/gmock/src/gmock_main.cc \
+                /usr/src/gtest/src/gtest-all.cc
+
+QMAKE_EXTRA_COMPILERS += gmock_compiler
+gmock_compiler.input = GMOCK_SOURCES
+gmock_compiler.output = $${OUT_PWD}/${QMAKE_FILE_BASE}.o
+gmock_compiler.commands = g++ \
+                          -I/usr/src/gtest \
+                          -I/usr/src/gmock \
+                          -c ${QMAKE_FILE_IN} \
+                          -o ${QMAKE_FILE_OUT}
+gmock_compiler.CONFIG = no_link
+
+QMAKE_EXTRA_COMPILERS += gmock_linker
+gmock_linker.depends = $${OUT_PWD}/gmock-all.o \
+                       $${OUT_PWD}/gmock_main.o \
+                       $${OUT_PWD}/gtest-all.o
+gmock_linker.input = GMOCK_SOURCES
+gmock_linker.output = $${OUT_PWD}/libgmock.a
+gmock_linker.commands = ar -rv ${QMAKE_FILE_OUT} $${OUT_PWD}/gmock-all.o $${OUT_PWD}/gmock_main.o $${OUT_PWD}/gtest-all.o
+gmock_linker.CONFIG = combine explicit_dependencies no_link target_predeps
+
+LIBS += $${OUT_PWD}/libgmock.a

=== added directory 'tests/mirserver'
=== added directory 'tests/mirserver/QtEventFeeder'
=== added file 'tests/mirserver/QtEventFeeder/QtEventFeeder.pro'
--- tests/mirserver/QtEventFeeder/QtEventFeeder.pro	1970-01-01 00:00:00 +0000
+++ tests/mirserver/QtEventFeeder/QtEventFeeder.pro	2014-09-18 22:57:30 +0000
@@ -0,0 +1,16 @@
+include(../../test-includes.pri)
+
+TARGET = QtEventFeederTest
+
+QT += gui-private
+
+INCLUDEPATH += \
+    ../../../src/platforms/mirserver \
+    ../../../src/common
+
+SOURCES += \
+    qteventfeeder_test.cpp \
+    ../../../src/common/debughelpers.cpp
+
+LIBS += -Wl,-rpath,$${OUT_PWD}/../../../src/platforms/mirserver \
+    -L../../../src/platforms/mirserver -lqpa-mirserver

=== added file 'tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h'
--- tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h	1970-01-01 00:00:00 +0000
+++ tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h	2014-09-18 22:57:30 +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_QTWINDOWSYSTEM_H
+#define MOCK_QTWINDOWSYSTEM_H
+
+#include <qteventfeeder.h>
+
+class MockQtWindowSystem : public QtEventFeeder::QtWindowSystemInterface {
+public:
+    MOCK_METHOD0(hasTargetWindow, bool());
+    MOCK_METHOD0(targetWindowGeometry, QRect());
+    MOCK_METHOD1(registerTouchDevice, void(QTouchDevice* device));
+    MOCK_METHOD10(handleExtendedKeyEvent, void(ulong timestamp, QEvent::Type type, int key,
+            Qt::KeyboardModifiers modifiers,
+            quint32 nativeScanCode, quint32 nativeVirtualKey,
+            quint32 nativeModifiers,
+            const QString& text, bool autorep,
+            ushort count));
+    MOCK_METHOD4(handleTouchEvent, void(ulong timestamp, QTouchDevice *device,
+            const QList<struct QWindowSystemInterface::TouchPoint> &points,
+            Qt::KeyboardModifiers mods));
+};
+
+namespace testing
+{
+
+MATCHER(IsPressed, std::string(negation ? "isn't" : "is") + " pressed")
+{
+    return arg.state == Qt::TouchPointPressed;
+}
+
+MATCHER(IsReleased, std::string(negation ? "isn't" : "is") + " released")
+{
+    return arg.state == Qt::TouchPointReleased;
+}
+
+MATCHER(StateIsMoved, "state " + std::string(negation ? "isn't" : "is") + " 'moved'")
+{
+    return arg.state == Qt::TouchPointMoved;
+}
+
+MATCHER_P(HasId, expectedId, "id " + std::string(negation ? "isn't " : "is ") + PrintToString(expectedId))
+{
+    return arg.id == expectedId;
+}
+
+} // namespace testing
+
+
+#endif // MOCK_QTWINDOWSYSTEM_H

=== added file 'tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp'
--- tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp	2014-09-18 22:57:30 +0000
@@ -0,0 +1,224 @@
+/*
+ * 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 <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <qteventfeeder.h>
+#include <debughelpers.h>
+
+#include <QGuiApplication>
+#include <QWindow>
+
+#include "mock_qtwindowsystem.h"
+
+using ::testing::_;
+using ::testing::AllOf;
+using ::testing::AnyNumber;
+using ::testing::Contains;
+using ::testing::AtLeast;
+using ::testing::InSequence;
+using ::testing::Mock;
+using ::testing::SizeIs;
+using ::testing::Return;
+
+// own gmock extensions
+using ::testing::IsPressed;
+using ::testing::IsReleased;
+using ::testing::HasId;
+using ::testing::StateIsMoved;
+
+void PrintTo(const struct QWindowSystemInterface::TouchPoint& touchPoint, ::std::ostream* os) {
+    *os << "TouchPoint("
+        << "id=" << touchPoint.id
+        << "," << touchPointStateToString(touchPoint.state)
+        << ")";
+}
+
+class QtEventFeederTest : public ::testing::Test {
+protected:
+    void SetUp() override;
+    void TearDown() override;
+
+    void setIrrelevantMockWindowSystemExpectations();
+
+    MockQtWindowSystem *mockWindowSystem;
+    QtEventFeeder *qtEventFeeder;
+};
+
+void QtEventFeederTest::SetUp()
+{
+    mockWindowSystem = new MockQtWindowSystem;
+
+    EXPECT_CALL(*mockWindowSystem, registerTouchDevice(_));
+
+    qtEventFeeder = new QtEventFeeder(mockWindowSystem);
+
+    ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
+}
+
+void QtEventFeederTest::TearDown()
+{
+    // mockWindowSystem will be deleted by QtEventFeeder
+    delete qtEventFeeder;
+}
+
+void QtEventFeederTest::setIrrelevantMockWindowSystemExpectations()
+{
+    EXPECT_CALL(*mockWindowSystem, hasTargetWindow())
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*mockWindowSystem, targetWindowGeometry())
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(QRect(0,0,100,100)));
+}
+
+
+/*
+   Mir sends a MirEvent([touch(id=0,state=pressed)]. QtEventFeeder happily forwards that to Qt.
+
+   Then, Mir sends a MirEvent([touch(id=1,state=pressed)]). In MirEvents, every single active touch
+   point must be listed in the event even if it didn't change at all in the meantime. So that's a bug.
+   But instead of crashing or forwarding the bogus event stream down to Qt, QtEventFeeder should attempt
+   to fix the situation by synthesizing a touch[id=1,state=released] to be send along with the
+   touch(id=1,state=pressed) it got. So that Qt receives a correct touch event stream.
+ */
+TEST_F(QtEventFeederTest, GenerateMissingTouchEnd)
+{
+
+    setIrrelevantMockWindowSystemExpectations();
+
+    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,AllOf(SizeIs(1),
+                                                              Contains(AllOf(HasId(0),
+                                                                             IsPressed()))),_)).Times(1);
+
+    MirEvent mirEvent;
+    mirEvent.type = mir_event_type_motion;
+    mirEvent.motion.pointer_count = 1;
+    mirEvent.motion.pointer_coordinates[0].id = 0;
+    mirEvent.motion.pointer_coordinates[0].x = 10;
+    mirEvent.motion.pointer_coordinates[0].y = 10;
+    mirEvent.motion.pointer_coordinates[0].touch_major = 1;
+    mirEvent.motion.pointer_coordinates[0].touch_minor = 1;
+    mirEvent.motion.pointer_coordinates[0].pressure = 10;
+    mirEvent.motion.action = mir_motion_action_down;
+    mirEvent.motion.event_time = 123 * 1000000;
+
+    qtEventFeeder->dispatch(mirEvent);
+
+    ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
+
+    setIrrelevantMockWindowSystemExpectations();
+
+    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,AllOf(SizeIs(2),
+                                                              Contains(AllOf(HasId(0),IsReleased())),
+                                                              Contains(AllOf(HasId(1),IsPressed()))
+                                                             ),_)).Times(1);
+
+    mirEvent.type = mir_event_type_motion;
+    mirEvent.motion.pointer_count = 1;
+    mirEvent.motion.pointer_coordinates[0].id = 1;
+    mirEvent.motion.pointer_coordinates[0].x = 20;
+    mirEvent.motion.pointer_coordinates[0].y = 20;
+    mirEvent.motion.pointer_coordinates[0].touch_major = 1;
+    mirEvent.motion.pointer_coordinates[0].touch_minor = 1;
+    mirEvent.motion.pointer_coordinates[0].pressure = 10;
+    mirEvent.motion.action = mir_motion_action_down;
+    mirEvent.motion.event_time = 125 * 1000000;
+
+    qtEventFeeder->dispatch(mirEvent);
+
+    ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
+}
+
+TEST_F(QtEventFeederTest, PressSameTouchTwice)
+{
+    setIrrelevantMockWindowSystemExpectations();
+
+    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,AllOf(SizeIs(1),
+                                                              Contains(AllOf(HasId(0),
+                                                                             IsPressed()))),_)).Times(1);
+
+    MirEvent mirEvent;
+    mirEvent.type = mir_event_type_motion;
+    mirEvent.motion.pointer_count = 1;
+    mirEvent.motion.pointer_coordinates[0].id = 0;
+    mirEvent.motion.pointer_coordinates[0].x = 10;
+    mirEvent.motion.pointer_coordinates[0].y = 10;
+    mirEvent.motion.pointer_coordinates[0].touch_major = 1;
+    mirEvent.motion.pointer_coordinates[0].touch_minor = 1;
+    mirEvent.motion.pointer_coordinates[0].pressure = 10;
+    mirEvent.motion.action = mir_motion_action_down;
+    mirEvent.motion.event_time = 123 * 1000000;
+
+    qtEventFeeder->dispatch(mirEvent);
+
+    ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
+
+    setIrrelevantMockWindowSystemExpectations();
+
+    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,AllOf(SizeIs(1),
+                                                              Contains(AllOf(HasId(0), StateIsMoved()))
+                                                             ),_)).Times(1);
+
+    mirEvent.type = mir_event_type_motion;
+    mirEvent.motion.pointer_count = 1;
+    mirEvent.motion.pointer_coordinates[0].id = 0;
+    mirEvent.motion.pointer_coordinates[0].x = 20;
+    mirEvent.motion.pointer_coordinates[0].y = 20;
+    mirEvent.motion.pointer_coordinates[0].touch_major = 1;
+    mirEvent.motion.pointer_coordinates[0].touch_minor = 1;
+    mirEvent.motion.pointer_coordinates[0].pressure = 10;
+    mirEvent.motion.action = mir_motion_action_down;
+    mirEvent.motion.event_time = 125 * 1000000;
+
+    qtEventFeeder->dispatch(mirEvent);
+
+    ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
+}
+
+TEST_F(QtEventFeederTest, IgnoreHovering)
+{
+    setIrrelevantMockWindowSystemExpectations();
+    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,_,_)).Times(0);
+
+    MirEvent mirEvent;
+    mirEvent.type = mir_event_type_motion;
+    mirEvent.motion.pointer_count = 1;
+    mirEvent.motion.pointer_coordinates[0].id = 0;
+    mirEvent.motion.pointer_coordinates[0].x = 10;
+    mirEvent.motion.pointer_coordinates[0].y = 10;
+    mirEvent.motion.pointer_coordinates[0].touch_major = 1;
+    mirEvent.motion.pointer_coordinates[0].touch_minor = 1;
+    mirEvent.motion.pointer_coordinates[0].pressure = 10;
+    mirEvent.motion.action = mir_motion_action_hover_enter;
+    mirEvent.motion.event_time = 123 * 1000000;
+
+    qtEventFeeder->dispatch(mirEvent);
+
+    mirEvent.motion.pointer_coordinates[0].x = 20;
+    mirEvent.motion.pointer_coordinates[0].y = 20;
+    mirEvent.motion.action = mir_motion_action_hover_move;
+    mirEvent.motion.event_time = 125 * 1000000;
+
+    qtEventFeeder->dispatch(mirEvent);
+
+    mirEvent.motion.action = mir_motion_action_hover_exit;
+    mirEvent.motion.event_time = 127 * 1000000;
+
+    qtEventFeeder->dispatch(mirEvent);
+}

=== added file 'tests/mirserver/mirserver.pro'
--- tests/mirserver/mirserver.pro	1970-01-01 00:00:00 +0000
+++ tests/mirserver/mirserver.pro	2014-09-18 22:57:30 +0000
@@ -0,0 +1,2 @@
+TEMPLATE = subdirs
+SUBDIRS = QtEventFeeder

=== 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-18 22:57:30 +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/DesktopFileReader'
=== added file 'tests/modules/DesktopFileReader/DesktopFileReader.pro'
--- tests/modules/DesktopFileReader/DesktopFileReader.pro	1970-01-01 00:00:00 +0000
+++ tests/modules/DesktopFileReader/DesktopFileReader.pro	2014-09-18 22:57:30 +0000
@@ -0,0 +1,15 @@
+include(../../test-includes.pri)
+include(../common/common.pri)
+
+TARGET = desktopfilereader_test
+
+SOURCES += \
+    desktopfilereader_test.cpp
+
+OTHER_FILES += \
+    calculator.desktop
+
+# Copy to build directory
+for(FILE, OTHER_FILES){
+    QMAKE_POST_LINK += $$quote(cp $${PWD}/$${FILE} $${OUT_PWD}$$escape_expand(\\n\\t))
+}

=== added file 'tests/modules/DesktopFileReader/calculator.desktop'
--- tests/modules/DesktopFileReader/calculator.desktop	1970-01-01 00:00:00 +0000
+++ tests/modules/DesktopFileReader/calculator.desktop	2014-09-18 22:57:30 +0000
@@ -0,0 +1,227 @@
+[Desktop Entry]
+Name=Calculator
+Name[am]=መደመሪያ
+Name[ar]=الآلة الحاسبة
+Name[ast]=Calculadora
+Name[az]=Kalkulyator
+Name[be]=Калькулятар
+Name[bg]=Калкулатор
+Name[br]=Jederez
+Name[bs]=Kalkulator
+Name[ca]=Calculadora
+Name[cs]=Kalkulačka
+Name[cy]=Cyfrifiannell
+Name[da]=Lommeregner
+Name[de]=Taschenrechner
+Name[el]=Αριθμομηχανή
+Name[en_AU]=Calculator
+Name[en_CA]=Calculator
+Name[en_GB]=Calculator
+Name[es]=Calculadora
+Name[eu]=Kalkulagailua
+Name[fa]=ماشین‌حساب
+Name[fi]=Laskin
+Name[fr]=Calculatrice
+Name[gd]=An t-àireamhair
+Name[gl]=Calculadora
+Name[gu]=કેલ્ક્યુલેટર
+Name[he]=מחשבון
+Name[hi]=कैलकुलेटर
+Name[hu]=Számológép
+Name[id]=Kalkulator
+Name[is]=Reiknivél
+Name[it]=Calcolatrice
+Name[ja]=電卓
+Name[km]=ម៉ាស៊ីន​គិត​លេខ
+Name[ko]=계산기
+Name[lv]=Kalkulators
+Name[mr]=गणनयंत्र
+Name[ms]=Kalkulator
+Name[my]=ဂဏန်းတွက်စက်
+Name[nb]=Kalkulator
+Name[ne]=क्याल्कुलेटर
+Name[nl]=Rekenmachine
+Name[pa]=ਕੈਲਕੂਲੇਟਰ
+Name[pl]=Kalkulator
+Name[pt]=Calculadora
+Name[pt_BR]=Calculadora
+Name[ro]=Calculator
+Name[ru]=Калькулятор
+Name[sa]=सङ्कलकम्
+Name[shn]=ၸၢၵ်ႈၼပ့်သွၼ်
+Name[sl]=Računalo
+Name[sr]=Калкулатор
+Name[sv]=Kalkylator
+Name[ta]=கணிப்பான்
+Name[te]=గణన పరికరం
+Name[tr]=Hesap Makinesi
+Name[ug]=ھېسابلىغۇچ
+Name[uk]=Калькулятор
+Name[zh_CN]=计算器
+Name[zh_HK]=計數機
+Name[zh_TW]=計算機
+Comment=A simple calculator for Ubuntu.
+Comment[am]=ለ ኡቡንቱ ቀላል መደመሪያ
+Comment[ar]=آلة حاسبة بسيطة لأوبونتو.
+Comment[ast]=Una calculadora cenciella pa Ubuntu.
+Comment[az]=Ubuntu üçün sadә kalkulyator.
+Comment[br]=Ur jederez eeun evit Ubuntu.
+Comment[ca]=Una calculadora simple per a l'Ubuntu.
+Comment[cy]=Cyfrifiannell hawdd ar gyfer Ubuntu.
+Comment[da]=En simpel lommeregner til Ubuntu.
+Comment[de]=Ein einfach Tachenrechner für Ubuntu.
+Comment[el]=Μια απλή αριθμομηχανή για το Ubuntu
+Comment[en_AU]=A simple calculator for Ubuntu.
+Comment[en_GB]=A simple calculator for Ubuntu.
+Comment[es]=Una calculadora sencilla para Ubuntu.
+Comment[eu]=Ubunturako kalkulagailu sinplea.
+Comment[fa]=یک ماشین حساب ساده برای اوبونتو.
+Comment[fi]=Laskin Ubuntulle.
+Comment[fr]=Une calculatrice simple pour Ubuntu.
+Comment[gd]=Àireamhair simplidh airson Ubuntu.
+Comment[gl]=Calculadora sinxela para Ubuntu.
+Comment[he]=מחשבון פשוט לאובונטו.
+Comment[hu]=Egyszerű számológép Ubuntuhoz.
+Comment[is]=Einföld reiknivél
+Comment[it]=Una semplice calcolatrice per Ubuntu.
+Comment[ja]=Ubuntu用のシンプルな電卓です。
+Comment[km]=ម៉ាស៊ីន​គិត​លេខ​ធម្មតា​សម្រាប់ Ubuntu ។
+Comment[ko]=우분투를 위한 간단한 계산기
+Comment[lv]=Vienkāršs kalkulators priekš Ubuntu
+Comment[nb]=En enkel kalkulator for Ubuntu.
+Comment[ne]=Ubuntu को लागि एक सरल कैलकुलेटर।
+Comment[nl]=Een eenvoudige rekenmachine voor Ubuntu.
+Comment[pa]=ਉਬੰਤੂ ਲਈ ਇੱਕ ਸਧਾਰਨ ਕੈਲਕੂਲੇਟਰ
+Comment[pl]=Prosty kalkulator dla Ubuntu
+Comment[pt]=Uma calculadora simples para o Ubuntu.
+Comment[pt_BR]=Uma simples calculadora para Ubuntu
+Comment[ro]=Un calculator simplu pentru Ubuntu.
+Comment[ru]=Простой калькулятор для Ubuntu
+Comment[sa]=Ubuntu इत्यस्मा एकं सरलं सङ्कलकम्।
+Comment[sl]=Preprost kalkulator za Ubuntu.
+Comment[sr]=Једноставан калкулатор за Убунту
+Comment[sv]=En enkel kalkylator för Ubuntu.
+Comment[tr]=Ubuntu için sade bir hesap makinesi.
+Comment[ug]=ئاددىي ھېسابلىغۇچى
+Comment[uk]=Простий калькулятор для Ubuntu.
+Comment[zh_CN]=Ubuntu 简易计算器
+Comment[zh_TW]=Ubuntu 簡易計算機。
+Keywords=math;addition;subtraction;multiplication;division;
+Keywords[am]=ሂሳብ;መደመሪያ;መቀነሻ;ማባዣ;ማካፈያ;
+Keywords[ar]=رياضة;ياضيات;حساب;حسابات;جمع;طرح;ضرب;قسمة;
+Keywords[ast]=matemática;suma;resta;multiplicación;división;
+Keywords[az]=riyaziyyat;әlavә etmә;çıxma;vurma;bölmә;toplama;
+Keywords[br]=matematikoù;sammadenn;lamadenn;lieskementadenn;rannadenn;
+Keywords[ca]=suma;resta;calculadora;multiplica;divideix
+Keywords[da]=matematik;plus;minus;gange;dividere;beregning;lommeregner;
+Keywords[de]=Mathe;Mathematik;Multiplikation;Subtraktion;Addition;Division;
+Keywords[en_AU]=math;addition;subtraction;multiplication;division;
+Keywords[en_GB]=maths;addition;subtraction;multiplication;division;
+Keywords[es]=matemática;suma;resta;multiplicación;división;
+Keywords[eu]=matematikak;gehitu;kendu;biderkatu;zatitu;
+Keywords[fa]=حساب;جمع;تفریق;ضرب;تقسیم
+Keywords[fi]=math;addition;subtraction;multiplication;division;matematiikka;lisäys;vähennys;kertaus;jakaminen;
+Keywords[fr]=math;addition;soustraction;multiplication;division;
+Keywords[gd]=math;addition;subtraction;multiplication;division;matamataig;roinneadh;toirt air falbh;cur ris;iomadadh
+Keywords[gl]=matemáticas;suma;resta;multiplicación;división;
+Keywords[he]=מתמטיקה;חשבון;חיבור;חיסור;כפל;חילוק;
+Keywords[hu]=számolás;összeadás;kivonás;szorzás;osztás;
+Keywords[is]=reikna;samlagning;frádráttur;margföldun;deiling
+Keywords[it]=matematica;addizioni;sottrazioni;moltiplicazioni;divisioni;
+Keywords[ja]=math;addition;subtraction;multiplication;division;計算;電卓;足し算;引き算;かけ算;わり算;
+Keywords[km]=math;addition;subtraction;multiplication;division;
+Keywords[ko]=수학;덧셈;뺄셈;곱셈;나눗셈;
+Keywords[nb]=matte;addisjon;subtraksjon;multiplikasjon;divisjon;
+Keywords[ne]=गणित; जोड्; घटाउ; गुणन; विभाजन;
+Keywords[nl]=math;addition;subtraction;multiplication;division;optellen;aftrekken;vermenigvuldigen;delen;
+Keywords[pa]=ਹਿਸਾਬ;ਜੋੜ;ਘਟਾਉ;ਗੁਣਾ;ਭਾਗ;
+Keywords[pl]=liczenie;dodawanie;odejmowanie;mnożenie;dzielenie;
+Keywords[pt]=matemática;soma;subtracção;multiplicação;divisão;
+Keywords[pt_BR]=matemática;adição;subtração;multiplicação;divisão
+Keywords[ro]=matematică;adunare;scădere;înmulțire;împărțire
+Keywords[ru]=математика;сложение;умножение;деление;
+Keywords[sa]=गणितम्;योजनम्;वियोजनम्;गुणनम्;विभाजनम्;
+Keywords[sl]=matematika;seštevanje;odštevanje;množenje;deljenje;
+Keywords[sr]=математика;сабирање;одузимање;множење;дељење;рачунање;дигитрон;
+Keywords[sv]=matematik;addition;substraktion;multiplikation;division
+Keywords[tr]=matematik;ekleme;çıkarma;çarpma;bölme;toplama
+Keywords[ug]=ماتېماتىكا;قوشۇش;ئېلىش;كۆپەيتىش;بۆلۈش;
+Keywords[uk]=math;addition;subtraction;multiplication;division;математика;додавання;віднімання;множення;ділення;калькулятор;
+Keywords[zh_CN]=数学;加;减;乘;除;
+Keywords[zh_TW]=math;addition;subtraction;multiplication;division;數學;加;減;乘;除;
+Type=Application
+Terminal=false
+Exec=aa-exec-click -p com.ubuntu.calculator_calculator_1.3.329 -- qmlscene -qt5 ubuntu-calculator-app.qml
+Icon=/usr/share/click/preinstalled/.click/users/@all/com.ubuntu.calculator/[e-mail]
+X-Ubuntu-Touch=true
+X-Ubuntu-StageHint=SideStage
+X-Ubuntu-Default-Department-ID=accessories
+Path=/usr/share/click/preinstalled/.click/users/@all/com.ubuntu.calculator
+X-Ubuntu-Old-Icon=[e-mail]
+X-Ubuntu-Application-ID=com.ubuntu.calculator_calculator_1.3.329
+X-Ubuntu-Splash-Show-Header=True
+X-Ubuntu-Splash-Color=#aabbcc
+X-Ubuntu-Splash-Color-Header=purple
+X-Ubuntu-Splash-Color-Footer=#deadbeefda
+X-Ubuntu-Splash-Image=/usr/share/click/preinstalled/.click/users/@all/com.ubuntu.calculator/[e-mail]
+X-Ubuntu-Splash-Title=Calculator 2.0
+X-Ubuntu-Splash-Title[am]=መደመሪያ 2.0
+X-Ubuntu-Splash-Title[ar]=الآلة  2.0الحاسبة
+X-Ubuntu-Splash-Title[ast]=Calculadora 2.0
+X-Ubuntu-Splash-Title[az]=Kalkulyator 2.0
+X-Ubuntu-Splash-Title[be]=Калькулятар 2.0
+X-Ubuntu-Splash-Title[bg]=Калкулатор 2.0
+X-Ubuntu-Splash-Title[br]=Jederez 2.0
+X-Ubuntu-Splash-Title[bs]=Kalkulator 2.0
+X-Ubuntu-Splash-Title[ca]=Calculadora 2.0
+X-Ubuntu-Splash-Title[cs]=Kalkulačka 2.0
+X-Ubuntu-Splash-Title[cy]=Cyfrifiannell 2.0
+X-Ubuntu-Splash-Title[da]=Lommeregner 2.0
+X-Ubuntu-Splash-Title[de]=Taschenrechner 2.0
+X-Ubuntu-Splash-Title[el]=Αριθμομηχανή 2.0
+X-Ubuntu-Splash-Title[en_AU]=Calculator 2.0
+X-Ubuntu-Splash-Title[en_CA]=Calculator 2.0
+X-Ubuntu-Splash-Title[en_GB]=Calculator 2.0
+X-Ubuntu-Splash-Title[es]=Calculadora 2.0
+X-Ubuntu-Splash-Title[eu]=Kalkulagailua 2.0
+X-Ubuntu-Splash-Title[fa]= 2.0ماشین‌حساب
+X-Ubuntu-Splash-Title[fi]=Laskin 2.0
+X-Ubuntu-Splash-Title[fr]=Calculatrice 2.0
+X-Ubuntu-Splash-Title[gd]=An t-àireamhair 2.0
+X-Ubuntu-Splash-Title[gl]=Calculadora 2.0
+X-Ubuntu-Splash-Title[gu]=કેલ્ક્યુલેટર 2.0
+X-Ubuntu-Splash-Title[he]= 2.0מחשבון
+X-Ubuntu-Splash-Title[hi]=कैलकुलेटर 2.0
+X-Ubuntu-Splash-Title[hu]=Számológép 2.0
+X-Ubuntu-Splash-Title[id]=Kalkulator 2.0
+X-Ubuntu-Splash-Title[is]=Reiknivél 2.0
+X-Ubuntu-Splash-Title[it]=Calcolatrice 2.0
+X-Ubuntu-Splash-Title[ja]=電卓 2.0
+X-Ubuntu-Splash-Title[km]=ម៉ាស៊ីន​គិត​លេខ 2.0
+X-Ubuntu-Splash-Title[ko]=계산기 2.0
+X-Ubuntu-Splash-Title[lv]=Kalkulators 2.0
+X-Ubuntu-Splash-Title[mr]=गणनयंत्र 2.0
+X-Ubuntu-Splash-Title[ms]=Kalkulator 2.0
+X-Ubuntu-Splash-Title[my]=ဂဏန်းတွက်စက် 2.0
+X-Ubuntu-Splash-Title[nb]=Kalkulator 2.0
+X-Ubuntu-Splash-Title[ne]=क्याल्कुलेटर 2.0
+X-Ubuntu-Splash-Title[nl]=Rekenmachine 2.0
+X-Ubuntu-Splash-Title[pa]=ਕੈਲਕੂਲੇਟਰ 2.0
+X-Ubuntu-Splash-Title[pl]=Kalkulator 2.0
+X-Ubuntu-Splash-Title[pt]=Calculadora 2.0
+X-Ubuntu-Splash-Title[pt_BR]=Calculadora 2.0
+X-Ubuntu-Splash-Title[ro]=Calculator 2.0
+X-Ubuntu-Splash-Title[ru]=Калькулятор 2.0
+X-Ubuntu-Splash-Title[sa]=सङ्कलकम् 2.0
+X-Ubuntu-Splash-Title[shn]=ၸၢၵ်ႈၼပ့်သွၼ် 2.0
+X-Ubuntu-Splash-Title[sl]=Računalo 2.0
+X-Ubuntu-Splash-Title[sr]=Калкулатор 2.0
+X-Ubuntu-Splash-Title[sv]=Kalkylator 2.0
+X-Ubuntu-Splash-Title[ta]=கணிப்பான் 2.0
+X-Ubuntu-Splash-Title[te]=గణన పరికరం 2.0
+X-Ubuntu-Splash-Title[tr]=Hesap Makinesi 2.0
+X-Ubuntu-Splash-Title[ug]= 2.0ھېسابلىغۇچ
+X-Ubuntu-Splash-Title[uk]=Калькулятор 2.0
+X-Ubuntu-Splash-Title[zh_CN]=计算器 2.0
+X-Ubuntu-Splash-Title[zh_HK]=計數機 2.0
+X-Ubuntu-Splash-Title[zh_TW]=計算機 2.0

=== added file 'tests/modules/DesktopFileReader/desktopfilereader_test.cpp'
--- tests/modules/DesktopFileReader/desktopfilereader_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/modules/DesktopFileReader/desktopfilereader_test.cpp	2014-09-18 22:57:30 +0000
@@ -0,0 +1,128 @@
+/*
+ * 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 <Unity/Application/desktopfilereader.h>
+
+#include <gtest/gtest.h>
+
+#include <QDir>
+#include <QFileInfo>
+#include <QLocale>
+#include <QtGlobal>
+#include <QString>
+
+using namespace qtmir;
+
+namespace {
+    static void setLocale(const char *locale)
+    {
+        qputenv("LANGUAGE", locale);
+        qputenv("LC_ALL", locale); // set these for GIO
+        QLocale::setDefault(QString(locale)); // set for Qt
+    }
+}
+
+TEST(DesktopFileReader, testReadsDesktopFile)
+{
+    using namespace ::testing;
+    setLocale("C");
+
+    QFileInfo fileInfo(QDir::currentPath() + "/calculator.desktop");
+    DesktopFileReader::Factory readerFactory;
+    DesktopFileReader *reader = readerFactory.createInstance("calculator", fileInfo);
+
+    EXPECT_EQ(reader->loaded(), true);
+    EXPECT_EQ(reader->appId(), "calculator");
+    EXPECT_EQ(reader->name(), "Calculator");
+    EXPECT_EQ(reader->exec(), "aa-exec-click -p com.ubuntu.calculator_calculator_1.3.329 -- qmlscene -qt5 ubuntu-calculator-app.qml");
+    EXPECT_EQ(reader->icon(), "/usr/share/click/preinstalled/.click/users/@all/com.ubuntu.calculator/[e-mail]");
+    EXPECT_EQ(reader->path(), "/usr/share/click/preinstalled/.click/users/@all/com.ubuntu.calculator");
+    EXPECT_EQ(reader->comment(), "A simple calculator for Ubuntu.");
+    EXPECT_EQ(reader->stageHint(), "SideStage");
+    EXPECT_EQ(reader->splashColor(), "#aabbcc");
+    EXPECT_EQ(reader->splashColorFooter(), "#deadbeefda");
+    EXPECT_EQ(reader->splashColorHeader(), "purple");
+    EXPECT_EQ(reader->splashImage(), "/usr/share/click/preinstalled/.click/users/@all/com.ubuntu.calculator/[e-mail]");
+    EXPECT_EQ(reader->splashShowHeader(), "True");
+    EXPECT_EQ(reader->splashTitle(), "Calculator 2.0");
+}
+
+TEST(DesktopFileReader, testReadsLocalizedDesktopFile)
+{
+    using namespace ::testing;
+    setLocale("de");
+
+    QFileInfo fileInfo(QDir::currentPath() + "/calculator.desktop");
+    DesktopFileReader::Factory readerFactory;
+    DesktopFileReader *reader = readerFactory.createInstance("calculator", fileInfo);
+
+    EXPECT_EQ(reader->loaded(), true);
+    EXPECT_EQ(reader->appId(), "calculator");
+    EXPECT_EQ(reader->name(), "Taschenrechner");
+    EXPECT_EQ(reader->exec(), "aa-exec-click -p com.ubuntu.calculator_calculator_1.3.329 -- qmlscene -qt5 ubuntu-calculator-app.qml");
+    EXPECT_EQ(reader->icon(), "/usr/share/click/preinstalled/.click/users/@all/com.ubuntu.calculator/[e-mail]");
+    EXPECT_EQ(reader->path(), "/usr/share/click/preinstalled/.click/users/@all/com.ubuntu.calculator");
+    EXPECT_EQ(reader->comment(), "Ein einfach Tachenrechner für Ubuntu.");
+    EXPECT_EQ(reader->stageHint(), "SideStage");
+    EXPECT_EQ(reader->splashColor(), "#aabbcc");
+    EXPECT_EQ(reader->splashColorFooter(), "#deadbeefda");
+    EXPECT_EQ(reader->splashColorHeader(), "purple");
+    EXPECT_EQ(reader->splashImage(), "/usr/share/click/preinstalled/.click/users/@all/com.ubuntu.calculator/[e-mail]");
+    EXPECT_EQ(reader->splashShowHeader(), "True");
+    EXPECT_EQ(reader->splashTitle(), "Taschenrechner 2.0");
+}
+
+TEST(DesktopFileReader, testMissingDesktopFile)
+{
+    using namespace ::testing;
+    setLocale("C");
+
+    QFileInfo fileInfo(QDir::currentPath() + "/missing.desktop");
+    DesktopFileReader::Factory readerFactory;
+    DesktopFileReader *reader = readerFactory.createInstance("calculator", fileInfo);
+
+    EXPECT_EQ(reader->loaded(), false);
+    EXPECT_EQ(reader->appId(), "calculator");
+    EXPECT_EQ(reader->name(), "");
+    EXPECT_EQ(reader->exec(), "");
+    EXPECT_EQ(reader->icon(), "");
+    EXPECT_EQ(reader->path(), "");
+    EXPECT_EQ(reader->comment(), "");
+    EXPECT_EQ(reader->stageHint(), "");
+    EXPECT_EQ(reader->splashColor(), "");
+    EXPECT_EQ(reader->splashColorFooter(), "");
+    EXPECT_EQ(reader->splashColorHeader(), "");
+    EXPECT_EQ(reader->splashImage(), "");
+    EXPECT_EQ(reader->splashShowHeader(), "");
+    EXPECT_EQ(reader->splashTitle(), "");
+}
+
+TEST(DesktopFileReader, testUTF8Characters)
+{
+    using namespace ::testing;
+    setLocale("zh_CN");
+
+    QFileInfo fileInfo(QDir::currentPath() + "/calculator.desktop");
+    DesktopFileReader::Factory readerFactory;
+    DesktopFileReader *reader = readerFactory.createInstance("calculator", fileInfo);
+
+    EXPECT_EQ(reader->loaded(), true);
+    EXPECT_EQ(reader->appId(), "calculator");
+    EXPECT_EQ(reader->name(), "计算器");
+    EXPECT_EQ(reader->comment(), "Ubuntu 简易计算器");
+    EXPECT_EQ(reader->splashTitle(), "计算器 2.0");
+}

=== 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-18 22:57:30 +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-18 22:57:30 +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-18 22:57:30 +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-18 22:57:30 +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-08-26 14:55:03 +0000
+++ tests/modules/common/common.pri	2014-09-18 22:57:30 +0000
@@ -1,12 +1,12 @@
-CONFIG += link_pkgconfig no_keywords # keywords clash with ProcessC++
-PKGCONFIG += mirserver process-cpp ubuntu-app-launch-2
+CONFIG += no_keywords # keywords clash with ProcessC++
+PKGCONFIG += process-cpp ubuntu-app-launch-2
 
-QT += quick testlib
-QMAKE_CXXFLAGS = -std=c++11
+QT += quick
 
 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 \
@@ -22,31 +22,7 @@
 INCLUDEPATH += ../../../src/modules \
     ../common
 
-
-GMOCK_SOURCES = /usr/src/gmock/src/gmock-all.cc \
-                /usr/src/gmock/src/gmock_main.cc \
-                /usr/src/gtest/src/gtest-all.cc
-
-QMAKE_EXTRA_COMPILERS += gmock_compiler
-gmock_compiler.input = GMOCK_SOURCES
-gmock_compiler.output = $${OUT_PWD}/${QMAKE_FILE_BASE}.o
-gmock_compiler.commands = g++ \
-                          -I/usr/src/gtest \
-                          -I/usr/src/gmock \
-                          -c ${QMAKE_FILE_IN} \
-                          -o ${QMAKE_FILE_OUT}
-gmock_compiler.CONFIG = no_link
-
-QMAKE_EXTRA_COMPILERS += gmock_linker
-gmock_linker.depends = $${OUT_PWD}/gmock-all.o \
-                       $${OUT_PWD}/gmock_main.o \
-                       $${OUT_PWD}/gtest-all.o
-gmock_linker.input = GMOCK_SOURCES
-gmock_linker.output = $${OUT_PWD}/libgmock.a
-gmock_linker.commands = ar -rv ${QMAKE_FILE_OUT} $${OUT_PWD}/gmock-all.o $${OUT_PWD}/gmock_main.o $${OUT_PWD}/gtest-all.o
-gmock_linker.CONFIG = combine explicit_dependencies no_link target_predeps
-
-LIBS += $${OUT_PWD}/libgmock.a \
+LIBS += \
     -Wl,-rpath,$${OUT_PWD}/../../../src/modules/Unity/Application \
     -L$${OUT_PWD}/../../../src/modules/Unity/Application -lunityapplicationplugin \
     -Wl,-rpath,$${OUT_PWD}/../../../src/platforms/mirserver \

=== 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-18 22:57:30 +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-18 22:57:30 +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-18 22:57:30 +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-18 22:57:30 +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-18 22:57:30 +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-18 22:57:30 +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-18 22:57:30 +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-18 22:57:30 +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-18 22:57:30 +0000
@@ -1,2 +1,2 @@
 TEMPLATE = subdirs
-SUBDIRS = ApplicationManager General SessionManager TaskController
+SUBDIRS = ApplicationManager General MirSurfaceItem SessionManager TaskController DesktopFileReader

=== modified file 'tests/test-includes.pri'
--- tests/test-includes.pri	2014-07-07 19:33:56 +0000
+++ tests/test-includes.pri	2014-09-18 22:57:30 +0000
@@ -4,3 +4,12 @@
 # adds a 'make install' that installs the test cases, which we do not want.
 # Can configure it not to do that with 'no_testcase_installs'
 CONFIG += testcase no_testcase_installs
+
+QMAKE_CXXFLAGS = -std=c++11
+
+QT += testlib
+
+CONFIG += link_pkgconfig
+PKGCONFIG += mirserver
+
+include(google-mock.pri)

=== modified file 'tests/tests.pro'
--- tests/tests.pro	2014-08-28 23:36:42 +0000
+++ tests/tests.pro	2014-09-18 22:57:30 +0000
@@ -1,2 +1,2 @@
 TEMPLATE = subdirs
-SUBDIRS = modules
+SUBDIRS = modules mirserver