Merge lp:~alan-griffiths/qtmir/spike-using-WindowManager into lp:qtmir

[Alan Griffiths]

Switch from subclassing mir::shell::AbstractShell to implementing mir::shell::WindowManager

Switch from subclassing mir::shell::AbstractShell to implementing mir::shell::WindowManager

Note this is proof-of-concept branch and I've yet to rebuild the stack and test it out.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:340
http://jenkins.qa.ubuntu.com/job/qtmir-ci/244/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/95/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/95/console

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

review: Needs Fixing (continuous-integration)

[lp:~alan-griffiths/qtmir/spike-using-WindowManager]

276. By Daniel van Vugt on 2015-03-27

Migrate to MirEvent 2.1 API, coming in Mir 0.13

277. By Daniel van Vugt on 2015-03-27

Update mock headers so they can build again, following racarr's
cursor BufferStream changes.

278. By Daniel van Vugt on 2015-04-02

Merge lp:~mir-team/qtmir/devel-mir-next-update

279. By Alan Griffiths on 2015-05-01

Mir 0.13.0 fixes

280. By Alan Griffiths on 2015-05-01

Workaround API that uses references to opaque types

281. By Alan Griffiths on 2015-05-01

libmircommon-dev dependency should be versioned

282. By Alan Griffiths on 2015-05-06

merge lp:~alan-griffiths/qtmir/spike-using-WindowManager

283. By Alan Griffiths on 2015-05-06

Very basic version of MirWindowManager::modify_surface()

Unmerged revisions

283. By Alan Griffiths on 2015-05-06

Very basic version of MirWindowManager::modify_surface()

282. By Alan Griffiths on 2015-05-06

merge lp:~alan-griffiths/qtmir/spike-using-WindowManager

=== modified file 'src/common/debughelpers.cpp'
--- src/common/debughelpers.cpp	2015-02-19 23:03:14 +0000
+++ src/common/debughelpers.cpp	2015-04-01 13:16:10 +0000
@@ -176,14 +176,14 @@
     }
 }
 
-const char *mirTouchActionToStr(MirTouchInputEventTouchAction action)
+const char *mirTouchActionToStr(MirTouchAction action)
 {
     switch (action) {
-    case mir_touch_input_event_action_up:
+    case mir_touch_action_up:
         return "up";
-    case mir_touch_input_event_action_down:
+    case mir_touch_action_down:
         return "down";
-    case mir_touch_input_event_action_change:
+    case mir_touch_action_change:
         return "change";
     default:
         return "???";

=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2015-04-01 13:16:09 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2015-04-01 13:16:10 +0000
@@ -70,9 +70,9 @@
     //TODO: should use mir::graphics::Display::configuration
     mir::geometry::Rectangles view_area;
     mirServer->the_display()->for_each_display_sync_group(
-        [&view_area](mir::graphics::DisplaySyncGroup& group) {
+        [&view_area](mir::graphics::DisplaySyncGroup &group) {
             group.for_each_display_buffer(
-                [&view_area](const mir::graphics::DisplayBuffer & db) {
+                [&view_area](const mir::graphics::DisplayBuffer &db) {
                     view_area.add(db.view_area());
                 });
         });

=== modified file 'src/modules/Unity/Application/application_manager.h'
--- src/modules/Unity/Application/application_manager.h	2015-01-09 11:23:34 +0000
+++ src/modules/Unity/Application/application_manager.h	2015-04-01 13:16:10 +0000
@@ -151,7 +151,7 @@
 
     Application* findApplicationWithPromptSession(const mir::scene::PromptSession* promptSession);
 
-    QSharedPointer<MirServer> m_mirServer;
+    const QSharedPointer<MirServer> m_mirServer;
 
     QList<Application*> m_applications;
     Application* m_focusedApplication;

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.cpp'
--- src/modules/Unity/Application/mirsurfaceitem.cpp	2015-03-18 10:12:03 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.cpp	2015-04-01 13:16:10 +0000
@@ -23,7 +23,6 @@
 #include "mirbuffersgtexture.h"
 #include "session.h"
 #include "mirsurfaceitem.h"
-#include "mirshell.h"
 #include "logging.h"
 #include "ubuntukeyboardinfo.h"
 
@@ -46,6 +45,7 @@
 // Mir
 #include <mir/geometry/rectangle.h>
 #include <mir/events/event_builders.h>
+#include <mir/shell/shell.h>
 #include <mir_toolkit/event.h>
 
 namespace mg = mir::graphics;
@@ -71,28 +71,28 @@
     return m_mods;
 }
 
-mir::EventUPtr makeMirEvent(QMouseEvent *qtEvent, MirPointerInputEventAction action)
+mir::EventUPtr makeMirEvent(QMouseEvent *qtEvent, MirPointerAction action)
 {
     auto timestamp = qtEvent->timestamp() * 1000000;
     auto modifiers = getMirModifiersFromQt(qtEvent->modifiers());
 
-    std::vector<MirPointerInputEventButton> buttons;
+    std::vector<MirPointerButton> buttons;
     if (qtEvent->buttons() & Qt::LeftButton)
-        buttons.push_back(mir_pointer_input_button_primary);
+        buttons.push_back(mir_pointer_button_primary);
     if (qtEvent->buttons() & Qt::RightButton)
-        buttons.push_back(mir_pointer_input_button_secondary);
+        buttons.push_back(mir_pointer_button_secondary);
     if (qtEvent->buttons() & Qt::MidButton)
-        buttons.push_back(mir_pointer_input_button_tertiary);
+        buttons.push_back(mir_pointer_button_tertiary);
 
     return mir::events::make_event(0 /*DeviceID */, timestamp, modifiers, action,
                                    buttons, qtEvent->x(), qtEvent->y(), 0, 0);
 }
 
-mir::EventUPtr makeMirEvent(QHoverEvent *qtEvent, MirPointerInputEventAction action)
+mir::EventUPtr makeMirEvent(QHoverEvent *qtEvent, MirPointerAction action)
 {
     auto timestamp = qtEvent->timestamp() * 1000000;
 
-    std::vector<MirPointerInputEventButton> buttons;
+    std::vector<MirPointerButton> buttons;
 
     return mir::events::make_event(0 /*DeviceID */, timestamp, mir_input_event_modifier_none, action,
                                    buttons, qtEvent->posF().x(), qtEvent->posF().y(), 0, 0);
@@ -100,20 +100,20 @@
 
 mir::EventUPtr makeMirEvent(QKeyEvent *qtEvent)
 {
-    MirKeyInputEventAction action = mir_key_input_event_action_down;
+    MirKeyboardAction action = mir_keyboard_action_down;
     switch (qtEvent->type())
     {
     case QEvent::KeyPress:
-        action = mir_key_input_event_action_down;
+        action = mir_keyboard_action_down;
         break;
     case QEvent::KeyRelease:
-        action = mir_key_input_event_action_up;
+        action = mir_keyboard_action_up;
         break;
     default:
         break;
     }
     if (qtEvent->isAutoRepeat())
-        action = mir_key_input_event_action_repeat;
+        action = mir_keyboard_action_repeat;
 
     return mir::events::make_event(0 /* DeviceID */, qtEvent->timestamp() * 1000000,
                            action, qtEvent->nativeVirtualKey(),
@@ -134,19 +134,19 @@
         auto touchPoint = qtTouchPoints.at(i);
         auto id = touchPoint.id();
 
-        MirTouchInputEventTouchAction action = mir_touch_input_event_action_change;
+        MirTouchAction action = mir_touch_action_change;
         if (touchPoint.state() == Qt::TouchPointReleased)
         {
-            action = mir_touch_input_event_action_up;
+            action = mir_touch_action_up;
         }
         if (touchPoint.state() == Qt::TouchPointPressed)
         {
-            action = mir_touch_input_event_action_down;
+            action = mir_touch_action_down;
         }
 
-        MirTouchInputEventTouchTooltype tooltype = mir_touch_input_tool_type_finger;
+        MirTouchTooltype tooltype = mir_touch_tooltype_finger;
         if (touchPoint.flags() & QTouchEvent::TouchPoint::Pen)
-            tooltype = mir_touch_input_tool_type_stylus;
+            tooltype = mir_touch_tooltype_stylus;
 
         mir::events::add_touch(*ev, id, action, tooltype,
                                touchPoint.pos().x(), touchPoint.pos().y(),
@@ -187,7 +187,7 @@
 
 MirSurfaceItem::MirSurfaceItem(std::shared_ptr<mir::scene::Surface> surface,
                                SessionInterface* session,
-                               MirShell *shell,
+                               mir::shell::Shell *shell,
                                std::shared_ptr<SurfaceObserver> observer,
                                QQuickItem *parent)
     : QQuickItem(parent)
@@ -465,14 +465,14 @@
     if (type() == InputMethod) {
         // FIXME: Hack to get the VKB use case working while we don't have the proper solution in place.
         if (isMouseInsideUbuntuKeyboard(event)) {
-            auto ev = makeMirEvent(event, mir_pointer_input_event_action_button_down);
+            auto ev = makeMirEvent(event, mir_pointer_action_button_down);
             m_surface->consume(*ev);
             event->accept();
         } else {
             event->ignore();
         }
     } else {
-        auto ev = makeMirEvent(event, mir_pointer_input_event_action_button_down);
+        auto ev = makeMirEvent(event, mir_pointer_action_button_down);
         m_surface->consume(*ev);
         event->accept();
     }
@@ -480,14 +480,14 @@
 
 void MirSurfaceItem::mouseMoveEvent(QMouseEvent *event)
 {
-    auto ev = makeMirEvent(event, mir_pointer_input_event_action_motion);
+    auto ev = makeMirEvent(event, mir_pointer_action_motion);
     m_surface->consume(*ev);
     event->accept();
 }
 
 void MirSurfaceItem::mouseReleaseEvent(QMouseEvent *event)
 {
-    auto ev = makeMirEvent(event, mir_pointer_input_event_action_button_up);
+    auto ev = makeMirEvent(event, mir_pointer_action_button_up);
     m_surface->consume(*ev);
     event->accept();
 }
@@ -499,21 +499,21 @@
 
 void MirSurfaceItem::hoverEnterEvent(QHoverEvent *event)
 {
-    auto ev = makeMirEvent(event, mir_pointer_input_event_action_enter);
+    auto ev = makeMirEvent(event, mir_pointer_action_enter);
     m_surface->consume(*ev);
     event->accept();
 }
 
 void MirSurfaceItem::hoverLeaveEvent(QHoverEvent *event)
 {
-    auto ev = makeMirEvent(event, mir_pointer_input_event_action_leave);
+    auto ev = makeMirEvent(event, mir_pointer_action_leave);
     m_surface->consume(*ev);
     event->accept();
 }
 
 void MirSurfaceItem::hoverMoveEvent(QHoverEvent *event)
 {
-    auto ev = makeMirEvent(event, mir_pointer_input_event_action_motion);
+    auto ev = makeMirEvent(event, mir_pointer_action_motion);
     m_surface->consume(*ev);
     event->accept();
 }

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.h'
--- src/modules/Unity/Application/mirsurfaceitem.h	2015-02-20 15:52:17 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.h	2015-04-01 13:16:10 +0000
@@ -33,8 +33,9 @@
 
 #include "session_interface.h"
 
+namespace mir { namespace shell { class Shell; } }
+
 class SurfaceObserver;
-class MirShell;
 
 namespace qtmir {
 
@@ -58,7 +59,7 @@
 public:
     explicit MirSurfaceItem(std::shared_ptr<mir::scene::Surface> surface,
                             SessionInterface* session,
-                            MirShell *shell,
+                            mir::shell::Shell *shell,
                             std::shared_ptr<SurfaceObserver> observer,
                             QQuickItem *parent = 0);
     ~MirSurfaceItem();
@@ -179,7 +180,7 @@
 
     std::shared_ptr<mir::scene::Surface> m_surface;
     QPointer<SessionInterface> m_session;
-    MirShell *const m_shell;
+    mir::shell::Shell *const m_shell;
     bool m_firstFrameDrawn;
     bool m_live;
     Qt::ScreenOrientation m_orientation; //FIXME -  have to save the state as Mir has no getter for it (bug:1357429)

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.cpp'
--- src/modules/Unity/Application/mirsurfacemanager.cpp	2015-02-06 09:47:21 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.cpp	2015-04-01 13:16:10 +0000
@@ -31,7 +31,7 @@
 #include "nativeinterface.h"
 #include "mirserver.h"
 #include "sessionlistener.h"
-#include "mirshell.h"
+#include "mirwindowmanager.h"
 #include "logging.h"
 
 Q_LOGGING_CATEGORY(QTMIR_SURFACES, "qtmir.surfaces")
@@ -51,9 +51,9 @@
                      manager, &MirSurfaceManager::onSessionDestroyingSurface);
 }
 
-void connectToShell(MirSurfaceManager *manager, MirShell *shell)
+void connectToWindowManager(MirSurfaceManager *manager, MirWindowManager *windowManager)
 {
-    QObject::connect(shell, &MirShell::surfaceAttributeChanged,
+    QObject::connect(windowManager, &MirWindowManager::surfaceAttributeChanged,
                      manager, &MirSurfaceManager::onSurfaceAttributeChanged);
 }
 
@@ -70,23 +70,22 @@
         }
 
         SessionListener *sessionListener = static_cast<SessionListener*>(nativeInterface->nativeResourceForIntegration("SessionListener"));
-        MirShell *shell = static_cast<MirShell*>(nativeInterface->nativeResourceForIntegration("Shell"));
+        MirWindowManager *window_manager = static_cast<MirWindowManager*>(nativeInterface->nativeResourceForIntegration("WindowManager"));
+        mir::shell::Shell *const shell = static_cast<mir::shell::Shell*>(nativeInterface->nativeResourceForIntegration("mir::shell::Shell"));
 
-        the_surface_manager = new MirSurfaceManager(nativeInterface->m_mirServer, shell, SessionManager::singleton());
+        the_surface_manager = new MirSurfaceManager(shell, SessionManager::singleton());
 
         connectToSessionListener(the_surface_manager, sessionListener);
-        connectToShell(the_surface_manager, shell);
+        connectToWindowManager(the_surface_manager, window_manager);
     }
     return the_surface_manager;
 }
 
 MirSurfaceManager::MirSurfaceManager(
-        const QSharedPointer<MirServer>& mirServer,
-        MirShell *shell,
+        mir::shell::Shell *shell,
         SessionManager* sessionManager,
         QObject *parent)
     : MirSurfaceItemModel(parent)
-    , m_mirServer(mirServer)
     , m_shell(shell)
     , m_sessionManager(sessionManager)
 {

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.h'
--- src/modules/Unity/Application/mirsurfacemanager.h	2015-02-06 09:47:21 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.h	2015-04-01 13:16:10 +0000
@@ -37,10 +37,12 @@
         class Session;
         class PromptSession;
     }
+    namespace shell {
+        class Shell;
+    }
 }
 
 class MirServer;
-class MirShell;
 
 namespace qtmir {
 
@@ -54,8 +56,7 @@
 
 public:
     explicit MirSurfaceManager(
-        const QSharedPointer<MirServer>& mirServer,
-        MirShell *shell,
+        mir::shell::Shell *shell,
         SessionManager* sessionManager,
         QObject *parent = 0
     );
@@ -81,8 +82,7 @@
     QMutex m_mutex;
 
 private:
-    QSharedPointer<MirServer> m_mirServer;
-    MirShell *const m_shell;
+    mir::shell::Shell *const m_shell;
     SessionManager* m_sessionManager;
     static MirSurfaceManager *the_surface_manager;
 };

=== modified file 'src/modules/Unity/Application/sessionmanager.cpp'
--- src/modules/Unity/Application/sessionmanager.cpp	2015-01-28 14:25:36 +0000
+++ src/modules/Unity/Application/sessionmanager.cpp	2015-04-01 13:16:10 +0000
@@ -26,7 +26,6 @@
 #include "nativeinterface.h"
 #include "mirserver.h"
 #include "sessionlistener.h"
-#include "mirshell.h"
 #include "logging.h"
 #include "promptsessionlistener.h"
 

=== modified file 'src/platforms/mirserver/CMakeLists.txt'
--- src/platforms/mirserver/CMakeLists.txt	2015-04-01 13:16:09 +0000
+++ src/platforms/mirserver/CMakeLists.txt	2015-04-01 13:16:10 +0000
@@ -37,7 +37,7 @@
 
 set(MIRSERVER_QPA_PLUGIN_SRC
     ../../common/debughelpers.cpp
-    mirshell.cpp
+    mirwindowmanager.cpp
     qteventfeeder.cpp
     plugin.cpp
     qmirserver.cpp

=== modified file 'src/platforms/mirserver/mirserver.cpp'
--- src/platforms/mirserver/mirserver.cpp	2015-02-09 16:28:40 +0000
+++ src/platforms/mirserver/mirserver.cpp	2015-04-01 13:16:10 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 Canonical, Ltd.
+ * Copyright (C) 2013-2015 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
@@ -19,7 +19,7 @@
 #include "mirserver.h"
 
 // local
-#include "mirshell.h"
+#include "mirwindowmanager.h"
 #include "mirglconfig.h"
 #include "mirserverstatuslistener.h"
 #include "promptsessionlistener.h"
@@ -51,19 +51,25 @@
     set_command_line_handler(&ignore_unparsed_arguments);
     set_command_line(argc, argv);
 
-    override_the_session_listener([]
-        {
-            return std::make_shared<SessionListener>();
-        });
-
-    override_the_prompt_session_listener([]
-        {
-            return std::make_shared<PromptSessionListener>();
-        });
-
-    override_the_session_authorizer([]
-        {
-            return std::make_shared<SessionAuthorizer>();
+    override_the_session_listener([this]
+        {
+            const auto result = std::make_shared<SessionListener>();
+            m_sessionListener = result;
+            return result;
+        });
+
+    override_the_prompt_session_listener([this]
+        {
+            const auto result = std::make_shared<PromptSessionListener>();
+            m_promptSessionListener = result;
+            return result;
+        });
+
+    override_the_session_authorizer([this]
+        {
+            const auto result = std::make_shared<SessionAuthorizer>();
+            m_sessionAuthorizer = result;
+            return result;
         });
 
     override_the_compositor([]
@@ -86,17 +92,11 @@
             return std::make_shared<MirServerStatusListener>();
         });
 
-    override_the_shell([this]
+    override_the_window_manager_builder([this](mir::shell::FocusController*)
         {
-            auto const shell = std::make_shared<MirShell>(
-                the_input_targeter(),
-                the_surface_coordinator(),
-                the_session_coordinator(),
-                the_prompt_session_manager(),
-                the_shell_display_layout());
-
-            m_shell = shell;
-            return shell;
+            const auto result = std::make_shared<MirWindowManager>(the_shell_display_layout());
+            m_windowManager = result;
+            return result;
         });
 
     set_terminator([&](int)
@@ -113,43 +113,25 @@
 
 /************************************ Shell side ************************************/
 
-//
-// Note about the
-//     if (sharedPtr.unique()) return 0;
-// constructs used in the functions below.
-// The rationale is that if when you do
-//     the_session_authorizer()
-// get a pointer that is unique means that Mir is not
-// holding the pointer and thus when we return from the
-//     sessionAuthorizer()
-// scope the unique pointer will be destroyed so we return 0
-//
+// Note about the"weak_ptr<X>.lock().get();" constructs used in the functions below.
+// An empty weak_ptr<> means that Mir is not holding the pointer so we return nullptr.
 
 SessionAuthorizer *MirServer::sessionAuthorizer()
 {
-    auto sharedPtr = the_session_authorizer();
-    if (sharedPtr.unique()) return 0;
-
-    return static_cast<SessionAuthorizer*>(sharedPtr.get());
+    return m_sessionAuthorizer.lock().get();
 }
 
 SessionListener *MirServer::sessionListener()
 {
-    auto sharedPtr = the_session_listener();
-    if (sharedPtr.unique()) return 0;
-
-    return static_cast<SessionListener*>(sharedPtr.get());
+    return m_sessionListener.lock().get();
 }
 
 PromptSessionListener *MirServer::promptSessionListener()
 {
-    auto sharedPtr = the_prompt_session_listener();
-    if (sharedPtr.unique()) return 0;
-
-    return static_cast<PromptSessionListener*>(sharedPtr.get());
+    return m_promptSessionListener.lock().get();
 }
 
-MirShell *MirServer::shell()
+MirWindowManager *MirServer::windowManager()
 {
-    return m_shell.lock().get();
+    return m_windowManager.lock().get();
 }

=== modified file 'src/platforms/mirserver/mirserver.h'
--- src/platforms/mirserver/mirserver.h	2015-04-01 13:16:09 +0000
+++ src/platforms/mirserver/mirserver.h	2015-04-01 13:16:10 +0000
@@ -23,7 +23,7 @@
 class QtEventFeeder;
 class SessionListener;
 class SessionAuthorizer;
-class MirShell;
+class MirWindowManager;
 class PromptSessionListener;
 
 // We use virtual inheritance of mir::Server to facilitate derived classes (e.g. testing)
@@ -34,7 +34,7 @@
 
     Q_PROPERTY(SessionAuthorizer* sessionAuthorizer READ sessionAuthorizer CONSTANT)
     Q_PROPERTY(SessionListener* sessionListener READ sessionListener CONSTANT)
-    Q_PROPERTY(MirShell* shell READ shell CONSTANT)
+    Q_PROPERTY(MirWindowManager* windowManager READ windowManager CONSTANT)
     Q_PROPERTY(PromptSessionListener* promptSessionListener READ promptSessionListener CONSTANT)
 
 public:
@@ -47,21 +47,22 @@
     using mir::Server::the_display;
     using mir::Server::the_gl_config;
     using mir::Server::the_main_loop;
-    using mir::Server::the_prompt_session_listener;
     using mir::Server::the_prompt_session_manager;
-    using mir::Server::the_session_authorizer;
-    using mir::Server::the_session_listener;
+    using mir::Server::the_shell;
 
     /* qt specific */
     // getters
     SessionAuthorizer *sessionAuthorizer();
     SessionListener *sessionListener();
     PromptSessionListener *promptSessionListener();
-    MirShell *shell();
+    MirWindowManager *windowManager();
 
 private:
     std::shared_ptr<QtEventFeeder> m_qtEventFeeder;
-    std::weak_ptr<MirShell> m_shell;
+    std::weak_ptr<SessionAuthorizer> m_sessionAuthorizer;
+    std::weak_ptr<SessionListener> m_sessionListener;
+    std::weak_ptr<PromptSessionListener> m_promptSessionListener;
+    std::weak_ptr<MirWindowManager> m_windowManager;
 };
 
 #endif // MIRSERVER_H

=== modified file 'src/platforms/mirserver/mirserverintegration.cpp'
--- src/platforms/mirserver/mirserverintegration.cpp	2015-04-01 13:16:09 +0000
+++ src/platforms/mirserver/mirserverintegration.cpp	2015-04-01 13:16:10 +0000
@@ -137,10 +137,14 @@
 
     mg::DisplayBuffer* first_buffer{nullptr};
     mg::DisplaySyncGroup* first_group{nullptr};
-    m_mirServer->the_display()->for_each_display_sync_group([&](mg::DisplaySyncGroup& group) {
-        if (!first_group) first_group = &group;
-        group.for_each_display_buffer([&](mg::DisplayBuffer& buffer) {
-            if (!first_buffer) first_buffer = &buffer;
+    m_mirServer->the_display()->for_each_display_sync_group([&](mg::DisplaySyncGroup &group) {
+        if (!first_group) {
+            first_group = &group;
+        }
+        group.for_each_display_buffer([&](mg::DisplayBuffer &buffer) {
+            if (!first_buffer) {
+                first_buffer = &buffer;
+            }
         });
     });
 

=== renamed file 'src/platforms/mirserver/mirshell.cpp' => 'src/platforms/mirserver/mirwindowmanager.cpp'
--- src/platforms/mirserver/mirshell.cpp	2015-04-01 13:16:09 +0000
+++ src/platforms/mirserver/mirwindowmanager.cpp	2015-04-01 13:16:10 +0000
@@ -14,64 +14,97 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "mirshell.h"
+#include "mirwindowmanager.h"
 #include "logging.h"
 #include "tracepoints.h" // generated from tracepoints.tp
 
 #include <mir/geometry/rectangle.h>
 #include <mir/scene/session.h>
+#include <mir/scene/surface.h>
 #include <mir/scene/surface_creation_parameters.h>
 #include <mir/shell/display_layout.h>
 #include <mir/shell/null_window_manager.h>
 
 namespace ms = mir::scene;
-using mir::shell::AbstractShell;
 
-MirShell::MirShell(
-    const std::shared_ptr<mir::shell::InputTargeter> &inputTargeter,
-    const std::shared_ptr<mir::scene::SurfaceCoordinator> &surfaceCoordinator,
-    const std::shared_ptr<mir::scene::SessionCoordinator> &sessionCoordinator,
-    const std::shared_ptr<mir::scene::PromptSessionManager> &promptSessionManager,
-    const std::shared_ptr<mir::shell::DisplayLayout> &displayLayout) :
-    AbstractShell(inputTargeter, surfaceCoordinator, sessionCoordinator, promptSessionManager,
-        [](mir::shell::FocusController*) { return std::make_shared<mir::shell::NullWindowManager>(); }),
-    m_displayLayout{displayLayout}
+MirWindowManager::MirWindowManager(const std::shared_ptr<mir::shell::DisplayLayout> &displayLayout) :
+        m_displayLayout{displayLayout}
 {
-    qCDebug(QTMIR_MIR_MESSAGES) << "MirShell::MirShell";
+    qCDebug(QTMIR_MIR_MESSAGES) << "MirWindowManager::MirWindowManager";
 }
 
-mir::frontend::SurfaceId MirShell::create_surface(const std::shared_ptr<ms::Session> &session, const ms::SurfaceCreationParameters &requestParameters)
+auto MirWindowManager::add_surface(
+    std::shared_ptr<mir::scene::Session> const& session,
+    mir::scene::SurfaceCreationParameters const& requestParameters,
+    std::function<mir::frontend::SurfaceId(std::shared_ptr<mir::scene::Session> const& session, mir::scene::SurfaceCreationParameters const& params)> const& build)
+-> mir::frontend::SurfaceId
 {
     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.
-
-     ms::SurfaceCreationParameters placedParameters = requestParameters;
-
-     // Just make it fullscreen for now
-     mir::geometry::Rectangle rect{requestParameters.top_left, requestParameters.size};
-     m_displayLayout->size_to_output(rect);
-     placedParameters.size = rect.size;
-
-     qCDebug(QTMIR_MIR_MESSAGES) << "MirShell::create_surface(): size requested ("
-         << requestParameters.size.width.as_int() << "," << requestParameters.size.height.as_int() << ") and placed ("
-         << placedParameters.size.width.as_int() << "," << placedParameters.size.height.as_int() << ")";
-
-     tracepoint(qtmirserver, surfacePlacementEnd);
-
-     return AbstractShell::create_surface(session, placedParameters);
+    // 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.
+
+    ms::SurfaceCreationParameters placedParameters = requestParameters;
+
+    // Just make it fullscreen for now
+    mir::geometry::Rectangle rect{requestParameters.top_left, requestParameters.size};
+    m_displayLayout->size_to_output(rect);
+    placedParameters.size = rect.size;
+
+    qCDebug(QTMIR_MIR_MESSAGES) << "MirWindowManager::add_surface(): size requested ("
+        << requestParameters.size.width.as_int() << "," << requestParameters.size.height.as_int() << ") and placed ("
+        << placedParameters.size.width.as_int() << "," << placedParameters.size.height.as_int() << ")";
+
+    tracepoint(qtmirserver, surfacePlacementEnd);
+
+    return build(session, placedParameters);
 }
 
-int MirShell::set_surface_attribute(
-    const std::shared_ptr<mir::scene::Session> &session,
-    const std::shared_ptr<mir::scene::Surface> &surface,
+int MirWindowManager::set_surface_attribute(
+    std::shared_ptr<mir::scene::Session> const& /*session*/,
+    std::shared_ptr<mir::scene::Surface> const& surface,
     MirSurfaceAttrib attrib,
     int value)
 {
-    auto const result = AbstractShell::set_surface_attribute(session, surface, attrib, value);
+    const auto result = surface->configure(attrib, value);
     Q_EMIT surfaceAttributeChanged(surface.get(), attrib, result);
-
     return result;
 }
+
+void MirWindowManager::add_session(std::shared_ptr<mir::scene::Session> const& /*session*/)
+{
+}
+
+void MirWindowManager::remove_session(std::shared_ptr<mir::scene::Session> const& /*session*/)
+{
+}
+
+void MirWindowManager::remove_surface(
+    std::shared_ptr<mir::scene::Session> const& /*session*/,
+    std::weak_ptr<mir::scene::Surface> const& /*surface*/)
+{
+}
+
+void MirWindowManager::add_display(mir::geometry::Rectangle const& /*area*/)
+{
+}
+
+void MirWindowManager::remove_display(mir::geometry::Rectangle const& /*area*/)
+{
+}
+
+bool MirWindowManager::handle_key_event(MirKeyboardEvent const* /*event*/)
+{
+    return false;
+}
+
+bool MirWindowManager::handle_touch_event(MirTouchEvent const* /*event*/)
+{
+    return false;
+}
+
+bool MirWindowManager::handle_pointer_event(MirPointerEvent const* /*event*/)
+{
+    return false;
+}

=== renamed file 'src/platforms/mirserver/mirshell.h' => 'src/platforms/mirserver/mirwindowmanager.h'
--- src/platforms/mirserver/mirshell.h	2015-02-04 17:17:53 +0000
+++ src/platforms/mirserver/mirwindowmanager.h	2015-04-01 13:16:10 +0000
@@ -14,10 +14,10 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef QPAMIRSERVER_SHELL_H
-#define QPAMIRSERVER_SHELL_H
+#ifndef MIRWINDOWMANAGER_H
+#define MIRWINDOWMANAGER_H
 
-#include <mir/shell/abstract_shell.h>
+#include <mir/shell/window_manager.h>
 #include <QObject>
 
 namespace mir {
@@ -26,26 +26,43 @@
     }
 }
 
-class MirShell : public QObject, public mir::shell::AbstractShell
+class MirWindowManager : public QObject, public mir::shell::WindowManager
 {
     Q_OBJECT
 
 public:
-    MirShell(
-        const std::shared_ptr<mir::shell::InputTargeter> &inputTargeter,
-        const std::shared_ptr<mir::scene::SurfaceCoordinator> &surfaceCoordinator,
-        const std::shared_ptr<mir::scene::SessionCoordinator> &sessionCoordinator,
-        const std::shared_ptr<mir::scene::PromptSessionManager> &promptSessionManager,
-        const std::shared_ptr<mir::shell::DisplayLayout> &displayLayout);
+    explicit MirWindowManager(const std::shared_ptr<mir::shell::DisplayLayout> &displayLayout);
 
-    virtual mir::frontend::SurfaceId create_surface(const std::shared_ptr<mir::scene::Session>& session, const mir::scene::SurfaceCreationParameters &params);
+    auto add_surface(
+        std::shared_ptr<mir::scene::Session> const& session,
+        mir::scene::SurfaceCreationParameters const& params,
+        std::function<mir::frontend::SurfaceId(std::shared_ptr<mir::scene::Session> const& session, mir::scene::SurfaceCreationParameters const& params)> const& build)
+    -> mir::frontend::SurfaceId override;
 
     int set_surface_attribute(
-        const std::shared_ptr<mir::scene::Session> &session,
-        const std::shared_ptr<mir::scene::Surface> &surface,
+        std::shared_ptr<mir::scene::Session> const& session,
+        std::shared_ptr<mir::scene::Surface> const& surface,
         MirSurfaceAttrib attrib,
         int value) override;
 
+    void add_session(std::shared_ptr<mir::scene::Session> const& session) override;
+
+    void remove_session(std::shared_ptr<mir::scene::Session> const& session) override;
+
+    void remove_surface(
+        std::shared_ptr<mir::scene::Session> const& session,
+        std::weak_ptr<mir::scene::Surface> const& surface) override;
+
+    void add_display(mir::geometry::Rectangle const& area) override;
+
+    void remove_display(mir::geometry::Rectangle const& area) override;
+
+    bool handle_key_event(MirKeyboardEvent const* event) override;
+
+    bool handle_touch_event(MirTouchEvent const* event) override;
+
+    bool handle_pointer_event(MirPointerEvent const* event) override;
+
 Q_SIGNALS:
     void surfaceAttributeChanged(mir::scene::Surface const*, const MirSurfaceAttrib, const int);
 
@@ -53,4 +70,4 @@
     std::shared_ptr<mir::shell::DisplayLayout> const m_displayLayout;
 };
 
-#endif /* QPAMIRSERVER_SHELL_H */
+#endif /* MIRWINDOWMANAGER_H */

=== modified file 'src/platforms/mirserver/nativeinterface.cpp'
--- src/platforms/mirserver/nativeinterface.cpp	2015-01-28 14:25:36 +0000
+++ src/platforms/mirserver/nativeinterface.cpp	2015-04-01 13:16:10 +0000
@@ -29,12 +29,17 @@
 
     if (resource == "SessionAuthorizer")
         result = m_mirServer->sessionAuthorizer();
-    else if (resource == "Shell")
-        result = m_mirServer->shell();
+    else if (resource == "WindowManager")
+        result = m_mirServer->windowManager();
     else if (resource == "SessionListener")
         result = m_mirServer->sessionListener();
     else if (resource == "PromptSessionListener")
         result = m_mirServer->promptSessionListener();
+    else if (resource == "mir::shell::Shell")
+    {
+        const std::weak_ptr<mir::shell::Shell> shell{m_mirServer->the_shell()};
+        result = shell.lock().get();
+    }
 
     return result;
 }

=== modified file 'src/platforms/mirserver/nativeinterface.h'
--- src/platforms/mirserver/nativeinterface.h	2014-12-01 11:05:01 +0000
+++ src/platforms/mirserver/nativeinterface.h	2015-04-01 13:16:10 +0000
@@ -33,7 +33,7 @@
 
     virtual void *nativeResourceForIntegration(const QByteArray &resource);
 
-    QSharedPointer<MirServer> m_mirServer;
+    const QSharedPointer<MirServer> m_mirServer;
 };
 
 #endif // NATIVEINTEGRATION_H

=== modified file 'src/platforms/mirserver/qteventfeeder.cpp'
--- src/platforms/mirserver/qteventfeeder.cpp	2015-02-19 23:03:14 +0000
+++ src/platforms/mirserver/qteventfeeder.cpp	2015-04-01 13:16:10 +0000
@@ -258,14 +258,14 @@
     return static_cast<Qt::KeyboardModifiers>(qtModifiers);
 }
 
-Qt::MouseButton getQtMouseButtonsfromMirPointerEvent(MirPointerInputEvent const* pev)
+Qt::MouseButton getQtMouseButtonsfromMirPointerEvent(MirPointerEvent const* pev)
 {
     int buttons = Qt::NoButton;
-    if (mir_pointer_input_event_get_button_state(pev, mir_pointer_input_button_primary))
+    if (mir_pointer_event_button_state(pev, mir_pointer_button_primary))
         buttons |= Qt::LeftButton;
-    if (mir_pointer_input_event_get_button_state(pev, mir_pointer_input_button_secondary))
+    if (mir_pointer_event_button_state(pev, mir_pointer_button_secondary))
         buttons |= Qt::RightButton;
-    if (mir_pointer_input_event_get_button_state(pev, mir_pointer_input_button_tertiary))
+    if (mir_pointer_event_button_state(pev, mir_pointer_button_tertiary))
         buttons |= Qt::MidButton;
 
     // TODO: Should mir back and forward buttons exist?
@@ -281,12 +281,12 @@
 
     auto timestamp = mir_input_event_get_event_time(ev) / 1000000;
 
-    auto pev = mir_input_event_get_pointer_input_event(ev);
-    auto modifiers = getQtModifiersFromMir(mir_pointer_input_event_get_modifiers(pev));
+    auto pev = mir_input_event_get_pointer_event(ev);
+    auto modifiers = getQtModifiersFromMir(mir_pointer_event_modifiers(pev));
     auto buttons = getQtMouseButtonsfromMirPointerEvent(pev);
 
-    auto local_point = QPointF(mir_pointer_input_event_get_axis_value(pev, mir_pointer_input_axis_x),
-                               mir_pointer_input_event_get_axis_value(pev, mir_pointer_input_axis_y));
+    auto local_point = QPointF(mir_pointer_event_axis_value(pev, mir_pointer_axis_x),
+                               mir_pointer_event_axis_value(pev, mir_pointer_axis_y));
 
     mQtWindowSystem->handleMouseEvent(timestamp, local_point,
                                       buttons, modifiers);
@@ -299,24 +299,24 @@
 
     ulong timestamp = mir_input_event_get_event_time(event) / 1000000;
 
-    auto kev = mir_input_event_get_key_input_event(event);
-    xkb_keysym_t xk_sym = mir_key_input_event_get_key_code(kev);
+    auto kev = mir_input_event_get_keyboard_event(event);
+    xkb_keysym_t xk_sym = mir_keyboard_event_key_code(kev);
 
     // Key modifier and unicode index mapping.
-    auto modifiers = getQtModifiersFromMir(mir_key_input_event_get_modifiers(kev));
+    auto modifiers = getQtModifiersFromMir(mir_keyboard_event_modifiers(kev));
 
     // Key action
     QEvent::Type keyType = QEvent::KeyRelease;
     bool is_auto_rep = false;
 
-    switch (mir_key_input_event_get_action(kev))
+    switch (mir_keyboard_event_action(kev))
     {
-    case mir_key_input_event_action_repeat:
+    case mir_keyboard_action_repeat:
         is_auto_rep = true; // fall-through
-    case mir_key_input_event_action_down:
+    case mir_keyboard_action_down:
         keyType = QEvent::KeyPress;
         break;
-    case mir_key_input_event_action_up:
+    case mir_keyboard_action_up:
         keyType = QEvent::KeyRelease;
         break;
     default:
@@ -332,9 +332,9 @@
     if (context) {
         // TODO: consider event.repeat_count
         QKeyEvent qKeyEvent(keyType, keyCode, modifiers,
-                            mir_key_input_event_get_scan_code(kev),
-                            mir_key_input_event_get_key_code(kev),
-                            mir_key_input_event_get_modifiers(kev),
+                            mir_keyboard_event_scan_code(kev),
+                            mir_keyboard_event_key_code(kev),
+                            mir_keyboard_event_modifiers(kev),
                             text, is_auto_rep);
         qKeyEvent.setTimestamp(timestamp);
         if (context->filterEvent(&qKeyEvent)) {
@@ -344,9 +344,9 @@
     }
 
     mQtWindowSystem->handleExtendedKeyEvent(timestamp, keyType, keyCode, modifiers,
-        mir_key_input_event_get_scan_code(kev),
-        mir_key_input_event_get_key_code(kev),
-        mir_key_input_event_get_modifiers(kev), text, is_auto_rep);
+        mir_keyboard_event_scan_code(kev),
+        mir_keyboard_event_key_code(kev),
+        mir_keyboard_event_modifiers(kev), text, is_auto_rep);
 }
 
 void QtEventFeeder::dispatchTouch(MirInputEvent const* event)
@@ -354,7 +354,7 @@
     if (!mQtWindowSystem->hasTargetWindow())
         return;
 
-    auto tev = mir_input_event_get_touch_input_event(event);
+    auto tev = mir_input_event_get_touch_event(event);
 
     // 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.
@@ -364,29 +364,29 @@
 
     // TODO: Is it worth setting the Qt::TouchPointStationary ones? Currently they are left
     //       as Qt::TouchPointMoved
-    const int kPointerCount = mir_touch_input_event_get_touch_count(tev);
+    const int kPointerCount = mir_touch_event_point_count(tev);
     for (int i = 0; i < kPointerCount; ++i) {
         QWindowSystemInterface::TouchPoint touchPoint;
 
-        const float kX = mir_touch_input_event_get_touch_axis_value(tev, i, mir_touch_input_axis_x);
-        const float kY = mir_touch_input_event_get_touch_axis_value(tev, i, mir_touch_input_axis_y);
-        const float kW = mir_touch_input_event_get_touch_axis_value(tev, i, mir_touch_input_axis_touch_major);
-        const float kH = mir_touch_input_event_get_touch_axis_value(tev, i, mir_touch_input_axis_touch_minor);
-        const float kP = mir_touch_input_event_get_touch_axis_value(tev, i, mir_touch_input_axis_pressure);
-        touchPoint.id = mir_touch_input_event_get_touch_id(tev, i);
+        const float kX = mir_touch_event_axis_value(tev, i, mir_touch_axis_x);
+        const float kY = mir_touch_event_axis_value(tev, i, mir_touch_axis_y);
+        const float kW = mir_touch_event_axis_value(tev, i, mir_touch_axis_touch_major);
+        const float kH = mir_touch_event_axis_value(tev, i, mir_touch_axis_touch_minor);
+        const float kP = mir_touch_event_axis_value(tev, i, mir_touch_axis_pressure);
+        touchPoint.id = mir_touch_event_id(tev, i);
 
         touchPoint.normalPosition = QPointF(kX / kWindowGeometry.width(), kY / kWindowGeometry.height());
         touchPoint.area = QRectF(kX - (kW / 2.0), kY - (kH / 2.0), kW, kH);
         touchPoint.pressure = kP / kMaxPressure;
-        switch (mir_touch_input_event_get_touch_action(tev, i))
+        switch (mir_touch_event_action(tev, i))
         {
-        case mir_touch_input_event_action_up:
+        case mir_touch_action_up:
             touchPoint.state = Qt::TouchPointReleased;
             break;
-        case mir_touch_input_event_action_down:
+        case mir_touch_action_down:
             touchPoint.state = Qt::TouchPointPressed;
             break;
-        case mir_touch_input_event_action_change:
+        case mir_touch_action_change:
             touchPoint.state = Qt::TouchPointMoved;
             break;
         default:

=== modified file 'src/platforms/mirserver/surfaceobserver.h'
--- src/platforms/mirserver/surfaceobserver.h	2015-04-01 13:16:09 +0000
+++ src/platforms/mirserver/surfaceobserver.h	2015-04-01 13:16:10 +0000
@@ -42,7 +42,8 @@
     void cursor_image_set_to(mir::graphics::CursorImage const&) override {}
     void orientation_set_to(MirOrientation) override {}
     void client_surface_close_requested() override {}
-    void keymap_changed(xkb_rule_names const&) override {}
+    void keymap_changed(xkb_rule_names const &) override {}
+    void renamed(char const *) override {}
 
 Q_SIGNALS:
     void framesPosted();

=== modified file 'tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp'
--- tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp	2015-02-19 23:03:14 +0000
+++ tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp	2015-04-01 13:16:10 +0000
@@ -15,8 +15,6 @@
  *
  */
 
-#define MIR_INCLUDE_DEPRECATED_EVENT_HEADER
-
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -26,6 +24,8 @@
 #include <QGuiApplication>
 #include <QWindow>
 
+#include "mir/events/event_builders.h"
+
 #include "mock_qtwindowsystem.h"
 
 using ::testing::_;
@@ -44,6 +44,8 @@
 using ::testing::HasId;
 using ::testing::StateIsMoved;
 
+namespace mev = mir::events;
+
 void PrintTo(const struct QWindowSystemInterface::TouchPoint& touchPoint, ::std::ostream* os) {
     *os << "TouchPoint("
         << "id=" << touchPoint.id
@@ -108,19 +110,10 @@
                                                               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);
+    auto ev1 = mev::make_event(MirInputDeviceId(), 123*1000000, 0);
+    mev::add_touch(*ev1, /* touch ID */ 0, mir_touch_action_down, mir_touch_tooltype_unknown,
+                   10, 10, 10, 1, 1, 10);
+    qtEventFeeder->dispatch(*ev1);
 
     ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
 
@@ -131,18 +124,10 @@
                                                               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);
+    auto ev2 = mev::make_event(MirInputDeviceId(), 125*1000000, 0);
+    mev::add_touch(*ev2, 1 /* touch ID */, mir_touch_action_down, mir_touch_tooltype_unknown,
+                   10, 10, 10, 1, 1, 10);
+    qtEventFeeder->dispatch(*ev2);
 
     ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
 }
@@ -155,19 +140,10 @@
                                                               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);
+    auto ev1 = mev::make_event(MirInputDeviceId(), 123*1000000, 0);
+    mev::add_touch(*ev1, /* touch ID */ 0, mir_touch_action_down, mir_touch_tooltype_unknown,
+                   10, 10, 10, 1, 1, 10);
+    qtEventFeeder->dispatch(*ev1);
 
     ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
 
@@ -177,18 +153,10 @@
                                                               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);
+    auto ev2 = mev::make_event(MirInputDeviceId(), 123*1000000, 0);
+    mev::add_touch(*ev2, /* touch ID */ 0, mir_touch_action_down, mir_touch_tooltype_unknown,
+                   10, 10, 10, 1, 1, 10);
+    qtEventFeeder->dispatch(*ev2);
 
     ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
 }

=== modified file 'tests/modules/MirSurfaceItem/mirsurfaceitem_test.cpp'
--- tests/modules/MirSurfaceItem/mirsurfaceitem_test.cpp	2015-02-20 15:57:36 +0000
+++ tests/modules/MirSurfaceItem/mirsurfaceitem_test.cpp	2015-04-01 13:16:10 +0000
@@ -62,26 +62,26 @@
     EXPECT_CALL(*mockSurface, type()).Times(AnyNumber()).WillRepeatedly(Return(mir_surface_type_normal));
     EXPECT_CALL(*mockSession, setSurface(_)).Times(AnyNumber());
 
-    auto getTouchEvent = [](MirEvent const& event) -> MirTouchInputEvent const*
+    auto getTouchEvent = [](MirEvent const& event) -> MirTouchEvent const*
     {
         if (mir_event_get_type(&event) != mir_event_type_input)
             return nullptr;
         auto const* input_event = mir_event_get_input_event(&event);
         if (mir_input_event_get_type(input_event) != mir_input_event_type_touch)
             return nullptr;
-        return mir_input_event_get_touch_input_event(input_event);
+        return mir_input_event_get_touch_event(input_event);
     };
 
     auto eventMatches = [&](MirEvent const& event,
                             int touch_count,
-                            MirTouchInputEventTouchAction action,
-                            MirTouchInputEventTouchId touch_id) ->void
+                            MirTouchAction action,
+                            MirTouchId touch_id) ->void
     {
         auto const* touch_event = getTouchEvent(event);
         ASSERT_NE(touch_event, nullptr);
-        ASSERT_EQ(touch_count, mir_touch_input_event_get_touch_count(touch_event));
-        ASSERT_EQ(action, mir_touch_input_event_get_touch_action(touch_event,0));
-        ASSERT_EQ(touch_id, mir_touch_input_event_get_touch_id(touch_event,0));
+        ASSERT_EQ(touch_count, mir_touch_event_point_count(touch_event));
+        ASSERT_EQ(action, mir_touch_event_action(touch_event,0));
+        ASSERT_EQ(touch_id, mir_touch_event_id(touch_event,0));
     };
 
     // The touch event sequence we expect mir::input::surface to receive from MirSurfaceItem.
@@ -89,16 +89,16 @@
     // the sequence for touch 1.
     EXPECT_CALL(*mockSurface, consume(_))
         .WillOnce(Invoke([&] (MirEvent const& mirEvent) {
-            eventMatches(mirEvent, 1, mir_touch_input_event_action_down, 0);
-        }))
-        .WillOnce(Invoke([&] (MirEvent const& mirEvent) {
-            eventMatches(mirEvent, 1, mir_touch_input_event_action_change, 0);
-        }))
-        .WillOnce(Invoke([&] (MirEvent const& mirEvent) {
-            eventMatches(mirEvent, 1, mir_touch_input_event_action_up, 0);
-        }))
-        .WillOnce(Invoke([&] (MirEvent const& mirEvent) {
-            eventMatches(mirEvent, 1, mir_touch_input_event_action_down, 1);
+            eventMatches(mirEvent, 1, mir_touch_action_down, 0);
+        }))
+        .WillOnce(Invoke([&] (MirEvent const& mirEvent) {
+            eventMatches(mirEvent, 1, mir_touch_action_change, 0);
+        }))
+        .WillOnce(Invoke([&] (MirEvent const& mirEvent) {
+            eventMatches(mirEvent, 1, mir_touch_action_up, 0);
+        }))
+        .WillOnce(Invoke([&] (MirEvent const& mirEvent) {
+            eventMatches(mirEvent, 1, mir_touch_action_down, 1);
         }));
 
 

=== modified file 'tests/modules/common/mock_mir_session.h'
--- tests/modules/common/mock_mir_session.h	2015-01-28 14:25:36 +0000
+++ tests/modules/common/mock_mir_session.h	2015-04-01 13:16:10 +0000
@@ -66,6 +66,10 @@
     void suspend_prompt_session() override {};
     void resume_prompt_session() override {};
 
+    MOCK_CONST_METHOD1(get_buffer_stream, std::shared_ptr<frontend::BufferStream>(frontend::BufferStreamId));
+    MOCK_METHOD1(destroy_buffer_stream, void(frontend::BufferStreamId));
+    MOCK_METHOD1(create_buffer_stream, frontend::BufferStreamId(graphics::BufferProperties const&));
+
 private:
     std::string m_sessionName;
     pid_t m_sessionId;

=== modified file 'tests/modules/common/mock_surface.h'
--- tests/modules/common/mock_surface.h	2015-04-01 13:16:09 +0000
+++ tests/modules/common/mock_surface.h	2015-04-01 13:16:10 +0000
@@ -66,7 +66,7 @@
     MOCK_METHOD1(set_reception_mode, void(input::InputReceptionMode mode));
     MOCK_METHOD0(request_client_surface_close, void());
     MOCK_CONST_METHOD1(buffers_ready_for_compositor, int(void const*));
-    void set_keymap(xkb_rule_names const&) override {}
+    void set_keymap(xkb_rule_names const &) override {}
 
     // from mir::input::surface
     MOCK_CONST_METHOD1(input_area_contains, bool(geometry::Point const& point));
@@ -80,9 +80,13 @@
     MOCK_CONST_METHOD0(client_input_fd, int());
     MOCK_METHOD2(configure, int(MirSurfaceAttrib attrib, int value));
     MOCK_CONST_METHOD1(query, int(MirSurfaceAttrib attrib));
+    bool modify(const Modifications &) override { return false; }
+
 
     // from mir::scene::SurfaceBufferAccess
     MOCK_METHOD1(with_most_recent_buffer_do, void(std::function<void(graphics::Buffer&)> const& exec));
+
+    MOCK_METHOD2(set_cursor_stream, void(std::shared_ptr<frontend::BufferStream> const&, geometry::Displacement const&));
 };
 
 } // namespace scene

=== modified file 'tests/modules/common/qtmir_test.h'
--- tests/modules/common/qtmir_test.h	2015-02-06 09:47:21 +0000
+++ tests/modules/common/qtmir_test.h	2015-04-01 13:16:10 +0000
@@ -109,7 +109,6 @@
             &applicationManager,
         }
         , surfaceManager{
-            mirServer,
             mirShell,
             &sessionManager
         }
@@ -150,7 +149,7 @@
     testing::NiceMock<testing::MockDesktopFileReaderFactory> desktopFileReaderFactory;
     testing::NiceMock<testing::MockSharedWakelock> sharedWakelock;
     QSharedPointer<FakeMirServer> mirServer;
-    MirShell *mirShell{nullptr};
+    mir::shell::Shell *mirShell{nullptr};
     QSharedPointer<TaskController> taskController;
     ApplicationManager applicationManager;
     SessionManager sessionManager;