Merge lp:~gerboland/miral/qt-fix-qt-rendering into lp:miral

[Gerry Boland]

[miral-qt] Add workaround to get Qt clients rendering - manually set visibility

Unmerged revisions

327. By Gerry Boland on 2016-09-13

Add workaround to get Qt apps rendering

=== modified file 'include/miral/window_info.h'
--- include/miral/window_info.h	2016-08-03 16:50:37 +0000
+++ include/miral/window_info.h	2016-09-13 12:26:41 +0000
@@ -31,6 +31,7 @@
 {
     using AspectRatio = WindowSpecification::AspectRatio;
 
+    WindowInfo();
     WindowInfo(Window const& window, WindowSpecification const& params);
     ~WindowInfo();
     WindowInfo(WindowInfo const& that);

=== renamed file 'miral-qt/src/platforms/mirserver/windowmodelnotifier.h' => 'miral-qt/src/common/windowmodelnotifier.h'
--- miral-qt/src/platforms/mirserver/windowmodelnotifier.h	2016-09-07 14:11:13 +0000
+++ miral-qt/src/common/windowmodelnotifier.h	2016-09-13 12:26:41 +0000
@@ -17,35 +17,54 @@
 #ifndef WINDOWMODELNOTIFIER_H
 #define WINDOWMODELNOTIFIER_H
 
-#include "windowmodelnotifierinterface.h"
+#include <QObject>
+#include <QPoint>
+#include <QSize>
 
 #include "miral/window_info.h"
 
-#include <QPair>
-
 namespace qtmir {
 
-class WindowModelNotifier : public WindowModelNotifierInterface
+class NewWindow {
+public:
+    NewWindow() = default;
+    NewWindow(const miral::WindowInfo &windowInfo, const std::string &persistentId = "")
+      : windowInfo(windowInfo)
+      , persistentId(persistentId)
+      , surface(windowInfo.window())
+    {}
+
+    miral::WindowInfo windowInfo;
+    std::string persistentId;
+
+    // hold copy of Surface shared pointer, as miral::Window has just a weak pointer to the Surface
+    // but MirSurface needs to share ownership of the Surface with Mir
+    std::shared_ptr<mir::scene::Surface> surface;
+};
+
+
+class WindowModelNotifier : public QObject
 {
     Q_OBJECT
 public:
-    WindowModelNotifier();
-    virtual ~WindowModelNotifier();
-
-    void addWindow(const miral::WindowInfo &windowInfo, const std::string &persistentId = "");
-    void removeWindow(const miral::WindowInfo &windowInfo);
-
-    void moveWindow(const miral::WindowInfo &windowInfo, mir::geometry::Point topLeft);
-    void resizeWindow(const miral::WindowInfo &windowInfo, mir::geometry::Size newSize);
-
-    void focusWindow(const miral::WindowInfo &windowInfo, const bool focus);
-    void raiseWindows(const std::vector<miral::Window> &windows);  //window?? Not WindowInfo??
+    WindowModelNotifier() = default;
+
+Q_SIGNALS: // **Must used Queued Connection or else events will be out of order**
+    void windowAdded(const qtmir::NewWindow &window);
+    void windowRemoved(const miral::WindowInfo &window);
+    void windowMoved(const miral::WindowInfo &window, const QPoint topLeft);
+    void windowResized(const miral::WindowInfo &window, const QSize size);
+    void windowFocusChanged(const miral::WindowInfo &window, bool focused);
+    void windowsRaised(const std::vector<miral::Window> &windows); // results in deep copy when passed over Queued connection:(
 
 private:
-    QVector<miral::Window> m_windowStack;
-    int m_focusedWindowIndex;
+    Q_DISABLE_COPY(WindowModelNotifier)
 };
 
 } // namespace qtmir
 
+Q_DECLARE_METATYPE(qtmir::NewWindow)
+Q_DECLARE_METATYPE(miral::WindowInfo)
+Q_DECLARE_METATYPE(std::vector<miral::Window>)
+
 #endif // WINDOWMODELNOTIFIER_H

=== removed file 'miral-qt/src/common/windowmodelnotifierinterface.h'
--- miral-qt/src/common/windowmodelnotifierinterface.h	2016-09-08 23:29:34 +0000
+++ miral-qt/src/common/windowmodelnotifierinterface.h	1970-01-01 00:00:00 +0000
@@ -1,107 +0,0 @@
-/*
- * Copyright (C) 2016 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 WINDOWMODELNOTIFIERINTERFACE_H
-#define WINDOWMODELNOTIFIERINTERFACE_H
-
-#include <QObject>
-#include <QSize>
-#include <QPoint>
-#include <QVector>
-
-#include "miral/window_info.h"
-
-namespace qtmir {
-
-// miral::WindowInfo missing a default constructor, needed by MOC. Need to wrap it instead
-class WindowInfo {
-public:
-    WindowInfo() = default;
-    WindowInfo(const miral::WindowInfo &windowInfo)
-      : name(windowInfo.name())
-      , type(windowInfo.type())
-      , state(windowInfo.state())
-      , restoreRect(windowInfo.restore_rect())
-      , parent(windowInfo.parent())
-      , children(windowInfo.children())
-      , minWidth(windowInfo.min_width())
-      , minHeight(windowInfo.min_height())
-      , maxWidth(windowInfo.max_width())
-      , maxHeight(windowInfo.max_height())
-    {}
-
-    mir::optional_value<std::string> name;
-    MirSurfaceType type;
-    MirSurfaceState state;
-    mir::geometry::Rectangle restoreRect;
-    miral::Window parent;
-    std::vector<miral::Window> children;
-    mir::geometry::Width minWidth;
-    mir::geometry::Height minHeight;
-    mir::geometry::Width maxWidth;
-    mir::geometry::Height maxHeight;
-};
-
-class NewWindow {
-public:
-    NewWindow() = default;
-    NewWindow(const miral::WindowInfo &windowInfo, const std::string &persistentId = "")
-      : window(windowInfo.window())
-      , windowInfo(windowInfo)
-      , persistentId(persistentId)
-      , surface(windowInfo.window())
-    {}
-
-    miral::Window window;
-    WindowInfo windowInfo;
-    std::string persistentId;
-
-    // hold copy of Surface shared pointer, as miral::Window has just a weak pointer to the Surface
-    // but MirSurface needs to share ownership of the Surface with Mir
-    std::shared_ptr<mir::scene::Surface> surface;
-};
-
-
-class WindowModelNotifierInterface : public QObject
-{
-    Q_OBJECT
-public:
-    WindowModelNotifierInterface() = default;
-    virtual ~WindowModelNotifierInterface() = default;
-
-Q_SIGNALS:
-    void windowAdded(const qtmir::NewWindow, const int index);
-    void windowRemoved(const int index);
-    void windowMoved(const QPoint topLeft, const int index);
-    void windowResized(const QSize size, const int index);
-    void windowFocused(const int index);
-    void windowInfoChanged(const qtmir::WindowInfo, const int index);
-    void windowsRaised(const QVector<int> indices);
-
-    // Assuming only 1 input method surface for now
-    void inputMethodWindowAdded(const qtmir::NewWindow);
-    void inputMethodWindowRemoved();
-
-private:
-    Q_DISABLE_COPY(WindowModelNotifierInterface)
-};
-
-} // namespace qtmir
-
-Q_DECLARE_METATYPE(qtmir::NewWindow)
-Q_DECLARE_METATYPE(qtmir::WindowInfo)
-
-#endif // WINDOWMODELNOTIFIERINTERFACE_H

=== modified file 'miral-qt/src/modules/Unity/Application/mirsurface.cpp'
--- miral-qt/src/modules/Unity/Application/mirsurface.cpp	2016-09-09 19:27:28 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurface.cpp	2016-09-13 12:26:41 +0000
@@ -198,7 +198,6 @@
 MirSurface::MirSurface(NewWindow newWindowInfo,
         WindowControllerInterface* controller)
     : MirSurfaceInterface()
-    , m_window(newWindowInfo.window)
     , m_windowInfo(newWindowInfo.windowInfo)
     , m_surface(newWindowInfo.surface)
     , m_controller(controller)
@@ -209,8 +208,8 @@
     , m_currentFrameNumber(0)
     , m_live(true)
     , m_surfaceObserver(std::make_shared<SurfaceObserver>())
-    , m_position(toQPoint(m_window.top_left()))
-    , m_size(toQSize(m_window.size()))
+    , m_position(toQPoint(m_windowInfo.window().top_left()))
+    , m_size(toQSize(m_windowInfo.window().size()))
     , m_shellChrome(Mir::NormalChrome)
 {
     DEBUG_MSG << "()";
@@ -303,7 +302,7 @@
 
 Mir::Type MirSurface::type() const
 {
-    switch (m_windowInfo.type) {
+    switch (m_windowInfo.type()) {
     case mir_surface_type_normal:
         return Mir::NormalType;
 
@@ -484,10 +483,10 @@
 
     if (m_activelyFocusedViews.isEmpty()) {
         DEBUG_MSG << "() unfocused";
-        m_controller->setActiveFocus(m_window, false);
+        m_controller->setActiveFocus(m_windowInfo.window(), false);
     } else {
         DEBUG_MSG << "() focused";
-        m_controller->setActiveFocus(m_window, true);
+        m_controller->setActiveFocus(m_windowInfo.window(), true);
     }
 
     m_neverSetSurfaceFocus = false;
@@ -505,19 +504,17 @@
     Q_EMIT closeRequested();
     m_closeTimer->start();
 
-    if (m_window) {
+    if (m_surface) {
         m_surface->request_client_surface_close();
     }
 }
 
 void MirSurface::resize(int width, int height)
 {
-    auto const &window = m_window;
-
     bool mirSizeIsDifferent = width != m_size.width() || height != m_size.height();
 
     if (clientIsRunning() && mirSizeIsDifferent) {
-        m_controller->resize(window, QSize(width, height));
+        m_controller->resize(m_windowInfo.window(), QSize(width, height));
         DEBUG_MSG << " old (" << m_size.width() << "," << m_size.height() << ")"
                   << ", new (" << width << "," << height << ")";
     }
@@ -538,7 +535,7 @@
 
 void MirSurface::requestPosition(const QPoint newPosition)
 {
-    m_controller->move(m_window, newPosition);
+    m_controller->move(m_windowInfo.window(), newPosition);
 }
 
 void MirSurface::setSize(const QSize newSize)
@@ -556,7 +553,7 @@
 
 Mir::State MirSurface::state() const
 {
-    switch (m_windowInfo.state) {
+    switch (m_windowInfo.state()) {
     case mir_surface_state_unknown:
         return Mir::UnknownState;
     case mir_surface_state_restored:
@@ -620,10 +617,10 @@
 
 QString MirSurface::name() const
 {
-    if (!m_windowInfo.name.is_set()) {
+    if (!m_windowInfo.has_name()) {
         return QStringLiteral();
     }
-    return QString::fromStdString(m_windowInfo.name.value());
+    return QString::fromStdString(m_windowInfo.name());
 }
 
 QString MirSurface::persistentId() const
@@ -670,7 +667,7 @@
         break;
     }
 
-    m_controller->setState(m_window, mirState);
+    m_controller->setState(m_windowInfo.window(), mirState);
 }
 
 void MirSurface::setLive(bool value)
@@ -699,7 +696,7 @@
 {
     auto ev = makeMirEvent(event, mir_pointer_action_button_down);
     auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
-    m_controller->deliverPointerEvent(m_window, ev1);
+    m_controller->deliverPointerEvent(m_windowInfo.window(), ev1);
     event->accept();
 }
 
@@ -707,7 +704,7 @@
 {
     auto ev = makeMirEvent(event, mir_pointer_action_motion);
     auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
-    m_controller->deliverPointerEvent(m_window, ev1);
+    m_controller->deliverPointerEvent(m_windowInfo.window(), ev1);
     event->accept();
 }
 
@@ -715,7 +712,7 @@
 {
     auto ev = makeMirEvent(event, mir_pointer_action_button_up);
     auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
-    m_controller->deliverPointerEvent(m_window, ev1);
+    m_controller->deliverPointerEvent(m_windowInfo.window(), ev1);
     event->accept();
 }
 
@@ -723,7 +720,7 @@
 {
     auto ev = makeMirEvent(event, mir_pointer_action_enter);
     auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
-    m_controller->deliverPointerEvent(m_window, ev1);
+    m_controller->deliverPointerEvent(m_windowInfo.window(), ev1);
     event->accept();
 }
 
@@ -731,7 +728,7 @@
 {
     auto ev = makeMirEvent(event, mir_pointer_action_leave);
     auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
-    m_controller->deliverPointerEvent(m_window, ev1);
+    m_controller->deliverPointerEvent(m_windowInfo.window(), ev1);
     event->accept();
 }
 
@@ -739,7 +736,7 @@
 {
     auto ev = makeMirEvent(event, mir_pointer_action_motion);
     auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
-    m_controller->deliverPointerEvent(m_window, ev1);
+    m_controller->deliverPointerEvent(m_windowInfo.window(), ev1);
     event->accept();
 }
 
@@ -747,7 +744,7 @@
 {
     auto ev = makeMirEvent(event);
     auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
-    m_controller->deliverPointerEvent(m_window, ev1);
+    m_controller->deliverPointerEvent(m_windowInfo.window(), ev1);
     event->accept();
 }
 
@@ -755,7 +752,7 @@
 {
     auto ev = makeMirEvent(qtEvent);
     auto ev1 = reinterpret_cast<MirKeyboardEvent const*>(ev.get());
-    m_controller->deliverKeyboardEvent(m_window, ev1);
+    m_controller->deliverKeyboardEvent(m_windowInfo.window(), ev1);
     qtEvent->accept();
 }
 
@@ -763,7 +760,7 @@
 {
     auto ev = makeMirEvent(qtEvent);
     auto ev1 = reinterpret_cast<MirKeyboardEvent const*>(ev.get());
-    m_controller->deliverKeyboardEvent(m_window, ev1);
+    m_controller->deliverKeyboardEvent(m_windowInfo.window(), ev1);
     qtEvent->accept();
 }
 
@@ -774,7 +771,7 @@
 {
     auto ev = makeMirEvent(mods, touchPoints, touchPointStates, timestamp);
     auto ev1 = reinterpret_cast<MirTouchEvent const*>(ev.get());
-    m_controller->deliverTouchEvent(m_window, ev1);
+    m_controller->deliverTouchEvent(m_windowInfo.window(), ev1);
 }
 
 bool MirSurface::clientIsRunning() const
@@ -796,6 +793,9 @@
     m_views.insert(viewId, MirSurface::View{false});
     DEBUG_MSG << "(" << viewId << ")" << " after=" << m_views.count();
     if (m_views.count() == 1) {
+        // FIXME: Mir has internal RenderingTracker which sets surface visibility. I think is is interfering
+        // QtMir's rendering. So manually inform client of its visibility.
+        m_surface->configure(mir_surface_attrib_visibility, mir_surface_visibility_exposed);
         Q_EMIT isBeingDisplayedChanged();
     }
 }
@@ -807,6 +807,8 @@
     if (m_views.count() == 0) {
         Q_EMIT isBeingDisplayedChanged();
         if (m_session.isNull() || !m_live) {
+            // FIXME: see above
+            m_surface->configure(mir_surface_attrib_visibility, mir_surface_visibility_occluded);
             deleteLater();
         }
     }
@@ -944,33 +946,33 @@
     return result;
 }
 
-void MirSurface::updateWindowInfo(const WindowInfo &windowInfo)
+void MirSurface::updateWindowInfo(const miral::WindowInfo &windowInfo)
 {
     qDebug() << "MirSurface::updateWindowInfo";
     // Need to compare the new windowInfo instance with the existing one to figure out what changed
     DirtyStates dirt = DirtyState::Clean;
 
-    if (windowInfo.name != m_windowInfo.name) {
+    if (windowInfo.name() != m_windowInfo.name()) {
         dirt &= DirtyState::Name; qDebug("Name changed");
     }
-    if (windowInfo.type != m_windowInfo.type) {
+    if (windowInfo.type() != m_windowInfo.type()) {
         dirt &= DirtyState::Type; qDebug("Type changed");
     }
-    if (windowInfo.state != m_windowInfo.state) {
+    if (windowInfo.state() != m_windowInfo.state()) {
         dirt &= DirtyState::State; qDebug("State changed");
     }
-    if (windowInfo.restoreRect != m_windowInfo.restoreRect) {
+    if (windowInfo.restore_rect() != m_windowInfo.restore_rect()) {
         dirt &= DirtyState::RestoreRect; qDebug("RestoreRect changed");
     }
-    if (windowInfo.children != m_windowInfo.children) {
+    if (windowInfo.children() != m_windowInfo.children()) {
         dirt &= DirtyState::Children; qDebug("Children changed");
     }
-    if (windowInfo.minWidth != m_windowInfo.minWidth
-            && windowInfo.minHeight != m_windowInfo.minHeight) {
+    if (windowInfo.min_width() != m_windowInfo.min_width()
+            && windowInfo.min_height() != m_windowInfo.min_height()) {
         dirt &= DirtyState::MinSize; qDebug("MinSize changed");
     }
-    if (windowInfo.maxWidth != m_windowInfo.maxWidth
-            && windowInfo.maxHeight != m_windowInfo.maxHeight) {
+    if (windowInfo.max_width() != m_windowInfo.max_width()
+            && windowInfo.max_height() != m_windowInfo.max_height()) {
         dirt &= DirtyState::MaxSize; qDebug("MaxHeight changed");
     }
 
@@ -1000,22 +1002,22 @@
 
 int MirSurface::minimumWidth() const
 {
-    return m_windowInfo.minWidth.as_int();
+    return m_windowInfo.min_width().as_int();
 }
 
 int MirSurface::minimumHeight() const
 {
-    return m_windowInfo.minHeight.as_int();
+    return m_windowInfo.min_height().as_int();
 }
 
 int MirSurface::maximumWidth() const
 {
-    return m_windowInfo.maxWidth.as_int();
+    return m_windowInfo.max_width().as_int();
 }
 
 int MirSurface::maximumHeight() const
 {
-    return m_windowInfo.maxHeight.as_int();
+    return m_windowInfo.max_height().as_int();
 }
 
 int MirSurface::widthIncrement() const
@@ -1058,7 +1060,7 @@
 
     m_closingState = CloseOverdue;
 
-    m_controller->requestClose(m_window);
+    m_controller->requestClose(m_windowInfo.window());
 }
 
 void MirSurface::setCloseTimer(AbstractTimer *timer)

=== modified file 'miral-qt/src/modules/Unity/Application/mirsurface.h'
--- miral-qt/src/modules/Unity/Application/mirsurface.h	2016-09-08 14:00:59 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurface.h	2016-09-13 12:26:41 +0000
@@ -32,7 +32,7 @@
 #include "mirbuffersgtexture.h"
 #include "session.h"
 #include "windowcontrollerinterface.h"
-#include "windowmodelnotifierinterface.h"
+#include "windowmodelnotifier.h"
 
 // mir
 #include <mir_toolkit/common.h>
@@ -155,12 +155,12 @@
     // Own API
     void setPosition(const QPoint newPosition);
     void setSize(const QSize newSize);
-    void updateWindowInfo(const WindowInfo &windowInfo);
+    void updateWindowInfo(const miral::WindowInfo &windowInfo);
 
     // useful for tests
     void setCloseTimer(AbstractTimer *timer);
     std::shared_ptr<SurfaceObserver> surfaceObserver() const;
-    miral::Window window() const { return m_window; }
+    miral::Window window() const { return m_windowInfo.window(); }
 
 public Q_SLOTS:
     void onCompositorSwappedBuffers() override;
@@ -184,8 +184,7 @@
     void applyKeymap();
     void updateActiveFocus();
 
-    miral::Window m_window;
-    WindowInfo m_windowInfo;
+    miral::WindowInfo m_windowInfo;
     std::shared_ptr<mir::scene::Surface> m_surface; // keep copy of the Surface for lifecycle
     QPointer<SessionInterface> m_session;
     WindowControllerInterface *const m_controller;

=== modified file 'miral-qt/src/modules/Unity/Application/windowmodel.cpp'
--- miral-qt/src/modules/Unity/Application/windowmodel.cpp	2016-09-08 23:29:34 +0000
+++ miral-qt/src/modules/Unity/Application/windowmodel.cpp	2016-09-13 12:26:41 +0000
@@ -39,30 +39,25 @@
 
     m_windowController = static_cast<WindowControllerInterface*>(nativeInterface->nativeResourceForIntegration("WindowController"));
 
-    auto windowModel = static_cast<WindowModelNotifierInterface*>(nativeInterface->nativeResourceForIntegration("WindowModelNotifier"));
+    auto windowModel = static_cast<WindowModelNotifier*>(nativeInterface->nativeResourceForIntegration("WindowModelNotifier"));
     connectToWindowModelNotifier(windowModel);
 }
 
-WindowModel::WindowModel(WindowModelNotifierInterface *notifier,
+WindowModel::WindowModel(WindowModelNotifier *notifier,
                          WindowControllerInterface *controller)
     : m_windowController(controller)
 {
     connectToWindowModelNotifier(notifier);
 }
 
-void WindowModel::connectToWindowModelNotifier(WindowModelNotifierInterface *notifier)
+void WindowModel::connectToWindowModelNotifier(WindowModelNotifier *notifier)
 {
-    connect(notifier, &WindowModelNotifierInterface::windowAdded,       this, &WindowModel::onWindowAdded,       Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifierInterface::windowRemoved,     this, &WindowModel::onWindowRemoved,     Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifierInterface::windowMoved,       this, &WindowModel::onWindowMoved,       Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifierInterface::windowResized,     this, &WindowModel::onWindowResized,     Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifierInterface::windowFocused,     this, &WindowModel::onWindowFocused,     Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifierInterface::windowInfoChanged, this, &WindowModel::onWindowInfoChanged, Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifierInterface::windowsRaised,     this, &WindowModel::onWindowsRaised,     Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifierInterface::inputMethodWindowAdded,
-            this, &WindowModel::onInputMethodWindowAdded,     Qt::QueuedConnection);
-    connect(notifier, &WindowModelNotifierInterface::inputMethodWindowRemoved,
-            this, &WindowModel::onInputMethodWindowRemoved,   Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::windowAdded,        this, &WindowModel::onWindowAdded,        Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::windowRemoved,      this, &WindowModel::onWindowRemoved,      Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::windowMoved,        this, &WindowModel::onWindowMoved,        Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::windowResized,      this, &WindowModel::onWindowResized,      Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::windowFocusChanged, this, &WindowModel::onWindowFocusChanged, Qt::QueuedConnection);
+    connect(notifier, &WindowModelNotifier::windowsRaised,      this, &WindowModel::onWindowsRaised,      Qt::QueuedConnection);
 }
 
 QHash<int, QByteArray> WindowModel::roleNames() const
@@ -72,58 +67,66 @@
     return roleNames;
 }
 
-void WindowModel::onWindowAdded(const NewWindow windowInfo, const int index)
+void WindowModel::onWindowAdded(const NewWindow &window)
 {
-    auto mirSurface = new MirSurface(windowInfo, m_windowController);
+    if (window.windowInfo.type() == mir_surface_type_inputmethod) {
+        addInputMethodWindow(window);
+        return;
+    }
+
+    const int index = m_windowModel.count();
     beginInsertRows(QModelIndex(), index, index);
-    m_windowModel.insert(index, mirSurface);
+    m_windowModel.append(new MirSurface(window, m_windowController));
     endInsertRows();
     Q_EMIT countChanged();
 }
 
-void WindowModel::onWindowRemoved(const int index)
+void WindowModel::onWindowRemoved(const miral::WindowInfo &windowInfo)
 {
+    if (windowInfo.type() == mir_surface_type_inputmethod) {
+        removeInputMethodWindow();
+        return;
+    }
+
+    const int index = findIndexOf(windowInfo.window());
+
     beginRemoveRows(QModelIndex(), index, index);
-    auto window = m_windowModel.takeAt(index);
-    if (window == m_focusedWindow) {
-        m_focusedWindow = nullptr;
-    }
+    m_windowModel.takeAt(index);
     endRemoveRows();
     Q_EMIT countChanged();
 }
 
-void WindowModel::onWindowMoved(const QPoint topLeft, const int index)
-{
-    auto mirSurface = static_cast<MirSurface *>(m_windowModel.value(index));
-    mirSurface->setPosition(topLeft);
-}
-
-void WindowModel::onWindowResized(const QSize size, const int index)
-{
-    auto mirSurface = static_cast<MirSurface *>(m_windowModel.value(index));
-    mirSurface->setSize(size);
-}
-
-void WindowModel::onWindowFocused(const int index)
-{
-    auto mirSurface = static_cast<MirSurface *>(m_windowModel.value(index));
-    if (m_focusedWindow && m_focusedWindow != mirSurface) {
-        m_focusedWindow->setFocused(false);
-    }
-    mirSurface->setFocused(true);
-    m_focusedWindow = mirSurface;
-}
-
-void WindowModel::onWindowInfoChanged(const WindowInfo windowInfo, const int pos)
-{
-    auto mirSurface = static_cast<MirSurface *>(m_windowModel.value(pos));
-    mirSurface->updateWindowInfo(windowInfo);
-
-    QModelIndex row = index(pos);
-    Q_EMIT dataChanged(row, row, QVector<int>() << SurfaceRole);
-}
-
-void WindowModel::onInputMethodWindowAdded(const NewWindow windowInfo)
+void WindowModel::onWindowMoved(const miral::WindowInfo &windowInfo, const QPoint topLeft)
+{
+    if (auto mirSurface = find(windowInfo)) {
+        mirSurface->setPosition(topLeft);
+    }
+}
+
+void WindowModel::onWindowResized(const miral::WindowInfo &windowInfo, const QSize size)
+{
+    if (auto mirSurface = find(windowInfo)) {
+        mirSurface->setSize(size);
+    }
+}
+
+void WindowModel::onWindowFocusChanged(const miral::WindowInfo &windowInfo, bool focused)
+{
+    if (auto mirSurface = find(windowInfo)) {
+        mirSurface->setFocused(focused);
+    }
+}
+
+//void WindowModel::onWindowInfoChanged(const WindowInfo windowInfo, const int pos)
+//{
+//    auto mirSurface = static_cast<MirSurface *>(m_windowModel.value(pos));
+//    mirSurface->updateWindowInfo(windowInfo);
+
+//    QModelIndex row = index(pos);
+//    Q_EMIT dataChanged(row, row, QVector<int>() << SurfaceRole);
+//}
+
+void WindowModel::addInputMethodWindow(const NewWindow &windowInfo)
 {
     if (m_inputMethodSurface) {
         qDebug("Multiple Input Method Surfaces created, removing the old one!");
@@ -133,7 +136,7 @@
     Q_EMIT inputMethodSurfaceChanged(m_inputMethodSurface);
 }
 
-void WindowModel::onInputMethodWindowRemoved()
+void WindowModel::removeInputMethodWindow()
 {
     if (m_inputMethodSurface) {
         delete m_inputMethodSurface;
@@ -142,10 +145,17 @@
     }
 }
 
-void WindowModel::onWindowsRaised(QVector<int> indices)
+void WindowModel::onWindowsRaised(const std::vector<miral::Window> &windows)
 {
     const int modelCount = m_windowModel.count();
 
+    QVector<int> indices;
+    for (const auto window: windows) {
+        int index = findIndexOf(window);
+        if (index >= 0) {
+            indices.append(index);
+        }
+    }
     // Assumption: no NO-OPs are in this list - Qt will crash on endMoveRows() if you try NO-OPs!!!
     // A NO-OP is if
     //    1. "indices" is an empty list
@@ -181,7 +191,7 @@
         beginMoveRows(parent, move, move, parent, modelCount);
 
         // QVector missing a move method in Qt5.4
-        const auto window = m_windowModel.takeAt(move);
+        const auto &window = m_windowModel.takeAt(move);
         m_windowModel.push_back(window);
 
         endMoveRows();
@@ -199,10 +209,30 @@
         return QVariant();
 
     if (role == SurfaceRole) {
-        MirSurfaceInterface *surface = m_windowModel.at(index.row());
-        return QVariant::fromValue(static_cast<MirSurfaceInterface*>(surface));
+        auto &surface = m_windowModel.at(index.row());
+        return QVariant::fromValue(surface);
     } else {
         return QVariant();
     }
 }
 
+MirSurface *WindowModel::find(const miral::WindowInfo &needle) const
+{
+    auto window = needle.window();
+    Q_FOREACH(const auto mirSurface, m_windowModel) {
+        if (mirSurface->window() == window) {
+            return mirSurface;
+        }
+    }
+    return nullptr;
+}
+
+int WindowModel::findIndexOf(const miral::Window &needle) const
+{
+    for (int i=0; i<m_windowModel.count(); i++) {
+        if (m_windowModel[i]->window() == needle) {
+            return i;
+        }
+    }
+    return -1;
+}

=== modified file 'miral-qt/src/modules/Unity/Application/windowmodel.h'
--- miral-qt/src/modules/Unity/Application/windowmodel.h	2016-09-08 23:29:34 +0000
+++ miral-qt/src/modules/Unity/Application/windowmodel.h	2016-09-13 12:26:41 +0000
@@ -19,8 +19,8 @@
 
 #include <QAbstractListModel>
 
-#include "mirsurfaceinterface.h"
-#include "windowmodelnotifierinterface.h"
+#include "mirsurface.h"
+#include "windowmodelnotifier.h"
 
 namespace qtmir {
 
@@ -40,7 +40,7 @@
     };
 
     WindowModel();
-    explicit WindowModel(WindowModelNotifierInterface *notifier,
+    explicit WindowModel(WindowModelNotifier *notifier,
                          WindowControllerInterface *controller); // For testing
 
     // QAbstractItemModel methods
@@ -51,31 +51,31 @@
 
     int count() const { return rowCount(); }
 
-    MirSurfaceInterface* inputMethodSurface() const { return m_inputMethodSurface; }
+    MirSurface* inputMethodSurface() const { return m_inputMethodSurface; }
 
 Q_SIGNALS:
     void countChanged();
     void inputMethodSurfaceChanged(MirSurfaceInterface* inputMethodSurface);
 
 private Q_SLOTS:
-    void onWindowAdded(const NewWindow windowInfo, const int index);
-    void onWindowRemoved(const int index);
-    void onWindowMoved(const QPoint topLeft, const int index);
-    void onWindowResized(const QSize size, const int index);
-    void onWindowFocused(const int index);
-    void onWindowInfoChanged(const WindowInfo windowInfo, const int index);
-    void onWindowsRaised(const QVector<int> indices);
-
-    void onInputMethodWindowAdded(const NewWindow windowInfo);
-    void onInputMethodWindowRemoved();
+    void onWindowAdded(const qtmir::NewWindow &windowInfo);
+    void onWindowRemoved(const miral::WindowInfo &window);
+    void onWindowMoved(const miral::WindowInfo &window, const QPoint topLeft);
+    void onWindowResized(const miral::WindowInfo &window, const QSize size);
+    void onWindowFocusChanged(const miral::WindowInfo &window, bool focused);
+    void onWindowsRaised(const std::vector<miral::Window> &windows);
 
 private:
-    void connectToWindowModelNotifier(WindowModelNotifierInterface *notifier);
-
-    QVector<MirSurfaceInterface *> m_windowModel;
+    void connectToWindowModelNotifier(WindowModelNotifier *notifier);
+
+    void addInputMethodWindow(const NewWindow &windowInfo);
+    void removeInputMethodWindow();
+    MirSurface* find(const miral::WindowInfo &needle) const;
+    int findIndexOf(const miral::Window &needle) const;
+
+    QVector<MirSurface*> m_windowModel;
     WindowControllerInterface *m_windowController;
-    MirSurfaceInterface* m_focusedWindow{nullptr};
-    MirSurfaceInterface* m_inputMethodSurface{nullptr};
+    MirSurface* m_inputMethodSurface{nullptr};
 };
 
 } // namespace qtmir

=== modified file 'miral-qt/src/platforms/mirserver/CMakeLists.txt'
--- miral-qt/src/platforms/mirserver/CMakeLists.txt	2016-08-19 16:41:10 +0000
+++ miral-qt/src/platforms/mirserver/CMakeLists.txt	2016-09-13 12:26:41 +0000
@@ -79,7 +79,6 @@
     creationhints.cpp
     windowcontroller.cpp
     windowmanagementpolicy.cpp
-    windowmodelnotifier.cpp
     tracepoints.c
     mirserverhooks.cpp mirserverhooks.h
     openglcontextfactory.cpp openglcontextfactory.h
@@ -88,7 +87,7 @@
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirMousePointerInterface.h
     ${MIRAL_QT_SOURCE_DIR}/src/common/windowcontrollerinterface.h
-    ${MIRAL_QT_SOURCE_DIR}/src/common/windowmodelnotifierinterface.h
+    ${MIRAL_QT_SOURCE_DIR}/src/common/windowmodelnotifier.h
 )
 
 add_library(qpa-mirserver SHARED

=== modified file 'miral-qt/src/platforms/mirserver/qmirserver_p.h'
--- miral-qt/src/platforms/mirserver/qmirserver_p.h	2016-08-22 14:33:59 +0000
+++ miral-qt/src/platforms/mirserver/qmirserver_p.h	2016-09-13 12:26:41 +0000
@@ -65,7 +65,7 @@
     std::shared_ptr<SessionAuthorizer> theApplicationAuthorizer() const
         { return m_sessionAuthorizer.the_custom_application_authorizer(); }
 
-    qtmir::WindowModelNotifierInterface *windowModelNotifier() const
+    qtmir::WindowModelNotifier *windowModelNotifier() const
         { return &m_windowModelNotifier; }
 
     qtmir::WindowControllerInterface *windowController() const

=== modified file 'miral-qt/src/platforms/mirserver/windowmanagementpolicy.cpp'
--- miral-qt/src/platforms/mirserver/windowmanagementpolicy.cpp	2016-09-07 20:33:52 +0000
+++ miral-qt/src/platforms/mirserver/windowmanagementpolicy.cpp	2016-09-13 12:26:41 +0000
@@ -21,9 +21,13 @@
 #include "miral/window_manager_tools.h"
 #include "miral/window_specification.h"
 
+#include "mirqtconversion.h"
+
 #include <mir/scene/surface.h>
 #include <QDebug>
 
+using namespace qtmir;
+
 WindowManagementPolicy::WindowManagementPolicy(const miral::WindowManagerTools &tools,
                                                qtmir::WindowModelNotifier &windowModel,
                                                qtmir::WindowController &windowController,
@@ -33,6 +37,8 @@
     , m_windowModel(windowModel)
     , m_eventFeeder(new QtEventFeeder(screensModel))
 {
+    qRegisterMetaType<qtmir::NewWindow>();
+    qRegisterMetaType<std::vector<miral::Window>>();
     windowController.setPolicy(this);
 }
 
@@ -90,17 +96,17 @@
     // TODO: attach surface observer here
     std::string persistentId = m_tools.id_for_window(windowInfo.window());
 
-    m_windowModel.addWindow(windowInfo, persistentId);
+    Q_EMIT m_windowModel.windowAdded(NewWindow{windowInfo, persistentId});
 }
 
 void WindowManagementPolicy::advise_delete_window(const miral::WindowInfo &windowInfo)
 {
-    m_windowModel.removeWindow(windowInfo);
+    Q_EMIT m_windowModel.windowRemoved(windowInfo);
 }
 
 void WindowManagementPolicy::advise_raise(const std::vector<miral::Window> &windows)
 {
-    m_windowModel.raiseWindows(windows);
+    Q_EMIT m_windowModel.windowsRaised(windows);
 }
 
 void WindowManagementPolicy::advise_new_app(miral::ApplicationInfo &/*application*/)
@@ -121,24 +127,24 @@
 void WindowManagementPolicy::advise_move_to(const miral::WindowInfo &windowInfo, Point topLeft)
 {
     qDebug("Window Moved to (%d, %d)", topLeft.x.as_int(), topLeft.y.as_int());
-    m_windowModel.moveWindow(windowInfo, topLeft);
+    Q_EMIT m_windowModel.windowMoved(windowInfo, toQPoint(topLeft));
 }
 
 void WindowManagementPolicy::advise_resize(const miral::WindowInfo &windowInfo, const Size &newSize)
 {
     qDebug("Window Resized to %dx%d", newSize.width.as_int(), newSize.height.as_int());
-    m_windowModel.resizeWindow(windowInfo, newSize);
+    Q_EMIT m_windowModel.windowResized(windowInfo, toQSize(newSize));
 }
 
 void WindowManagementPolicy::advise_focus_lost(const miral::WindowInfo &windowInfo)
 {
-    m_windowModel.focusWindow(windowInfo, false);
+    Q_EMIT m_windowModel.windowFocusChanged(windowInfo, false);
 }
 
 void WindowManagementPolicy::advise_focus_gained(const miral::WindowInfo &windowInfo)
 {
     // update Qt model ASAP, before applying Mir policy
-    m_windowModel.focusWindow(windowInfo, true);
+    Q_EMIT m_windowModel.windowFocusChanged(windowInfo, true);
 
     CanonicalWindowManagerPolicy::advise_focus_gained(windowInfo);
 }

=== removed file 'miral-qt/src/platforms/mirserver/windowmodelnotifier.cpp'
--- miral-qt/src/platforms/mirserver/windowmodelnotifier.cpp	2016-09-08 23:29:34 +0000
+++ miral-qt/src/platforms/mirserver/windowmodelnotifier.cpp	1970-01-01 00:00:00 +0000
@@ -1,152 +0,0 @@
-/*
- * Copyright (C) 2016 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 "windowmodelnotifier.h"
-
-#include "mirqtconversion.h"
-#include <QDebug>
-
-/*
- * WindowModelNotifier - tracks Mir Window Manager operations and duplicates the window stack
- * that Mir has created internally. Any changes to this model are emitted as notify
- * signals to the Qt GUI thread which will effectively duplicate this model again.
- *
- * Use a window ID as a shared identifier between this Mir-side model and the Qt-side model
- */
-
-using namespace qtmir;
-
-WindowModelNotifier::WindowModelNotifier()
-{
-    qRegisterMetaType<qtmir::NewWindow>();
-    qRegisterMetaType<qtmir::WindowInfo>();
-    qRegisterMetaType<QVector<int>>();
-}
-
-WindowModelNotifier::~WindowModelNotifier()
-{
-
-}
-
-void WindowModelNotifier::addWindow(const miral::WindowInfo &windowInfo, const std::string &persistentId)
-{
-    if (windowInfo.type() == mir_surface_type_inputmethod) {
-        NewWindow newWindowInfo{windowInfo};
-        Q_EMIT inputMethodWindowAdded(newWindowInfo);
-        return;
-    }
-
-    auto stackPosition = m_windowStack.count();
-    m_windowStack.push_back(windowInfo.window()); // ASSUMPTION: Mir should tell us where in stack
-
-    NewWindow newWindowInfo{windowInfo, persistentId};
-    Q_EMIT windowAdded(newWindowInfo, stackPosition);
-}
-
-void WindowModelNotifier::removeWindow(const miral::WindowInfo &windowInfo)
-{
-    if (windowInfo.type() == mir_surface_type_inputmethod) {
-        Q_EMIT inputMethodWindowRemoved();
-        return;
-    }
-
-    const int pos = m_windowStack.indexOf(windowInfo.window());
-    if (pos < 0) {
-        qDebug("Unknown window removed");
-        return;
-    }
-    m_windowStack.removeAt(pos);
-    Q_EMIT windowRemoved(pos);
-}
-
-void WindowModelNotifier::focusWindow(const miral::WindowInfo &windowInfo, const bool focus)
-{
-    const int pos = m_windowStack.indexOf(windowInfo.window());
-    if (pos < 0) {
-        qDebug("Unknown window focused");
-        return;
-    }
-
-    if (focus && m_focusedWindowIndex != pos) {
-        m_focusedWindowIndex = pos;
-        Q_EMIT windowFocused(pos);
-    }
-}
-
-void WindowModelNotifier::moveWindow(const miral::WindowInfo &windowInfo, mir::geometry::Point topLeft)
-{
-    const int pos = m_windowStack.indexOf(windowInfo.window());
-    if (pos < 0) {
-        qDebug("Unknown window moved");
-        return;
-    }
-
-    // Note: windowInfo.window() is in the state before the move
-    Q_EMIT windowMoved(toQPoint(topLeft), pos);
-}
-
-void WindowModelNotifier::resizeWindow(const miral::WindowInfo &windowInfo, mir::geometry::Size newSize)
-{
-    const int pos = m_windowStack.indexOf(windowInfo.window());
-    if (pos < 0) {
-        qDebug("Unknown window resized");
-        return;
-    }
-
-    // Note: windowInfo.window() is in the state before the resize
-    Q_EMIT windowResized(toQSize(newSize), pos);
-}
-
-void WindowModelNotifier::raiseWindows(const std::vector<miral::Window> &windows)
-{
-    QVector<int> indices;
-    for (auto window: windows) {
-        const int pos = m_windowStack.indexOf(window);
-        if (pos < 0) {
-            qDebug("Unknown window raised");
-            continue;
-        }
-        indices.push_back(pos);
-    }
-
-    // Filter some NO-OP (raise list of windows which is already raised and in that order)
-    // A NO-OP is if
-    //    1. "indices" is an empty list
-    //    2. "indices" of the form (modelCount - 1, modelCount - 2,...)
-    {
-        bool noop = true;
-        int counter = m_windowStack.count() - 1;
-        Q_FOREACH(int index, indices) {
-            if (index != counter) {
-                noop = false;
-                break;
-            }
-            counter--;
-        }
-
-        if (noop) {
-            return;
-        }
-    }
-
-    for (int i=indices.count()-1; i>=0; i--) {
-        // QVector missing a move method in Qt5.4
-        auto window = m_windowStack.takeAt(indices[i]);
-        m_windowStack.push_back(window);
-    }
-
-    Q_EMIT windowsRaised(indices);
-}

=== modified file 'miral-qt/tests/modules/WindowManager/mirsurface_test.cpp'
--- miral-qt/tests/modules/WindowManager/mirsurface_test.cpp	2016-08-23 13:28:03 +0000
+++ miral-qt/tests/modules/WindowManager/mirsurface_test.cpp	2016-09-13 12:26:41 +0000
@@ -26,7 +26,7 @@
 #include <QSignalSpy>
 
 // src/common
-#include "windowmodelnotifierinterface.h"
+#include "windowmodelnotifier.h"
 
 // the test subject
 #include <Unity/Application/mirsurface.h>
@@ -86,7 +86,6 @@
     miral::Window mockWindow(stubSession, mockSurface);
     ms::SurfaceCreationParameters spec;
     miral::WindowInfo mockWindowInfo(mockWindow, spec);
-    QScopedPointer<WindowInfo> windowInfo(new WindowInfo(mockWindowInfo));
 
     EXPECT_CALL(*mockSurface.get(),buffers_ready_for_compositor(_))
         .WillRepeatedly(Return(1));

=== modified file 'miral-qt/tests/modules/WindowManager/windowmodel_test.cpp'
--- miral-qt/tests/modules/WindowManager/windowmodel_test.cpp	2016-09-08 23:44:44 +0000
+++ miral-qt/tests/modules/WindowManager/windowmodel_test.cpp	2016-09-13 12:26:41 +0000
@@ -57,7 +57,7 @@
         QLoggingCategory::setFilterRules(QStringLiteral("qtmir.surfaces=false"));
     }
 
-    miral::WindowInfo createMirALWindowInfo(QPoint position = {160, 320}, QSize size = {100, 200})
+    NewWindow createNewWindow(QPoint position = {160, 320}, QSize size = {100, 200})
     {
         const miral::Application app{stubSession};
         stubSurface->setSize(size);
@@ -66,17 +66,19 @@
         ms::SurfaceCreationParameters windowSpec;
 //        windowSpec.of_size(toMirSize(size)); // useless, Window/Surface has the size actually used
         windowSpec.of_position(toMirPoint(position));
-        return miral::WindowInfo{window, windowSpec};
+        miral::WindowInfo windowInfo{window, windowSpec};
+        return NewWindow{windowInfo, ""};
     }
 
-    miral::WindowInfo createMirALWindowInfoForInputMethod()
+    NewWindow createNewWindowForInputMethod()
     {
         const miral::Application app{stubSession};
         const miral::Window window{app, stubSurface};
 
         ms::SurfaceCreationParameters windowSpec;
         windowSpec.of_type(mir_surface_type_inputmethod);
-        return miral::WindowInfo{window, windowSpec};
+        miral::WindowInfo windowInfo{window, windowSpec};
+        return NewWindow{windowInfo, ""};
     }
 
     MirSurface *getMirSurfaceFromModel(const WindowModel &model, int index)
@@ -113,7 +115,7 @@
 };
 
 /*
- * Test: that the WindowModelNotifier.addWindow causes the Qt-side WindowModel to
+ * Test: that the WindowModelNotifier.windowAdded causes the Qt-side WindowModel to
  * increment model count
  */
 TEST_F(WindowModelTest, WhenAddWindowNotifiedModelCountIncrements)
@@ -121,16 +123,16 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo = createMirALWindowInfo();
+    auto newWindow = createNewWindow();
 
-    notifier.addWindow(mirWindowInfo);
+    notifier.windowAdded(newWindow);
     flushEvents();
 
     EXPECT_EQ(1, model.count());
 }
 
 /*
- * Test: that the WindowModelNotifier.addWindow causes the Qt-side WindowModel to
+ * Test: that the WindowModelNotifier.windowAdded causes the Qt-side WindowModel to
  * emit the countChanged signal.
  */
 TEST_F(WindowModelTest, WhenAddWindowNotifiedModelEmitsCountChangedSignal)
@@ -138,18 +140,18 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo = createMirALWindowInfo();
+    auto newWindow = createNewWindow();
 
     QSignalSpy spyCountChanged(&model, SIGNAL(countChanged()));
 
-    notifier.addWindow(mirWindowInfo);
+    notifier.windowAdded(newWindow);
     flushEvents();
 
     EXPECT_EQ(1, spyCountChanged.count());
 }
 
 /*
- * Test: that the WindowModelNotifier.addWindow causes the Qt-side WindowModel to
+ * Test: that the WindowModelNotifier.windowAdded causes the Qt-side WindowModel to
  * gain an entry which has the correct miral::Window
  */
 TEST_F(WindowModelTest, WhenAddWindowNotifiedNewModelEntryHasCorrectWindow)
@@ -157,17 +159,17 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo = createMirALWindowInfo();
+    auto newWindow = createNewWindow();
 
-    notifier.addWindow(mirWindowInfo);
+    notifier.windowAdded(newWindow);
     flushEvents();
 
     auto miralWindow = getMirALWindowFromModel(model, 0);
-    EXPECT_EQ(mirWindowInfo.window(), miralWindow);
+    EXPECT_EQ(newWindow.windowInfo.window(), miralWindow);
 }
 
 /*
- * Test: that the WindowModelNotifier.removeWindow causes the Qt-side WindowModel to
+ * Test: that the WindowModelNotifier.windowRemoved causes the Qt-side WindowModel to
  * remove the Window from the model, and emit the countChanged signal.
  */
 TEST_F(WindowModelTest, WhenRemoveWindowNotifiedModelCountDecrements)
@@ -175,18 +177,18 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo = createMirALWindowInfo();
-    notifier.addWindow(mirWindowInfo);
+    auto newWindow = createNewWindow();
+    notifier.windowAdded(newWindow);
 
     // Test removing the window
-    notifier.removeWindow(mirWindowInfo);
+    notifier.windowRemoved(newWindow.windowInfo);
     flushEvents();
 
     EXPECT_EQ(0, model.count());
 }
 
 /*
- * Test: that the WindowModelNotifier.removeWindow causes the Qt-side WindowModel to
+ * Test: that the WindowModelNotifier.windowRemoved causes the Qt-side WindowModel to
  * emit the countChanged signal.
  */
 TEST_F(WindowModelTest, WhenRemoveWindowNotifiedModelEmitsCountChangedSignal)
@@ -194,21 +196,21 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo = createMirALWindowInfo();
-    notifier.addWindow(mirWindowInfo);
+    auto newWindow = createNewWindow();
+    notifier.windowAdded(newWindow);
     flushEvents();
 
     // Test removing the window
     QSignalSpy spyCountChanged(&model, SIGNAL(countChanged()));
 
-    notifier.removeWindow(mirWindowInfo);
+    notifier.windowRemoved(newWindow.windowInfo);
     flushEvents();
 
     EXPECT_EQ(1, spyCountChanged.count());
 }
 
 /*
- * Test: that calling WindowModelNotifier.addWindow causes Qt-side WindowModel to
+ * Test: that calling WindowModelNotifier.windowAdded causes Qt-side WindowModel to
  * have 2 windows in the correct order.
  */
 TEST_F(WindowModelTest, WhenAddingTwoWindowsModelHasCorrectOrder)
@@ -216,18 +218,18 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo1 = createMirALWindowInfo();
-    auto mirWindowInfo2 = createMirALWindowInfo();
+    auto newWindow1 = createNewWindow();
+    auto newWindow2 = createNewWindow();
 
-    notifier.addWindow(mirWindowInfo1);
-    notifier.addWindow(mirWindowInfo2);
+    notifier.windowAdded(newWindow1);
+    notifier.windowAdded(newWindow2);
     flushEvents();
 
     ASSERT_EQ(2, model.count());
     auto miralWindow1 = getMirALWindowFromModel(model, 0);
-    EXPECT_EQ(mirWindowInfo1.window(), miralWindow1);
+    EXPECT_EQ(newWindow1.windowInfo.window(), miralWindow1);
     auto miralWindow2 = getMirALWindowFromModel(model, 1);
-    EXPECT_EQ(mirWindowInfo2.window(), miralWindow2);
+    EXPECT_EQ(newWindow2.windowInfo.window(), miralWindow2);
 }
 
 /*
@@ -238,19 +240,19 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo1 = createMirALWindowInfo();
-    auto mirWindowInfo2 = createMirALWindowInfo();
+    auto newWindow1 = createNewWindow();
+    auto newWindow2 = createNewWindow();
 
-    notifier.addWindow(mirWindowInfo1);
-    notifier.addWindow(mirWindowInfo2);
+    notifier.windowAdded(newWindow1);
+    notifier.windowAdded(newWindow2);
 
     // Remove second window
-    notifier.removeWindow(mirWindowInfo2);
+    notifier.windowRemoved(newWindow2.windowInfo);
     flushEvents();
 
     ASSERT_EQ(1, model.count());
     auto miralWindow = getMirALWindowFromModel(model, 0);
-    EXPECT_EQ(mirWindowInfo1.window(), miralWindow);
+    EXPECT_EQ(newWindow1.windowInfo.window(), miralWindow);
 }
 
 /*
@@ -261,19 +263,19 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo1 = createMirALWindowInfo();
-    auto mirWindowInfo2 = createMirALWindowInfo();
+    auto newWindow1 = createNewWindow();
+    auto newWindow2 = createNewWindow();
 
-    notifier.addWindow(mirWindowInfo1);
-    notifier.addWindow(mirWindowInfo2);
+    notifier.windowAdded(newWindow1);
+    notifier.windowAdded(newWindow2);
 
     // Remove first window
-    notifier.removeWindow(mirWindowInfo1);
+    notifier.windowRemoved(newWindow1.windowInfo);
     flushEvents();
 
     ASSERT_EQ(1, model.count());
     auto miralWindow = getMirALWindowFromModel(model, 0);
-    EXPECT_EQ(mirWindowInfo2.window(), miralWindow);
+    EXPECT_EQ(newWindow2.windowInfo.window(), miralWindow);
 }
 
 /*
@@ -284,22 +286,22 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo1 = createMirALWindowInfo();
-    auto mirWindowInfo2 = createMirALWindowInfo();
-    auto mirWindowInfo3 = createMirALWindowInfo();
-
-    notifier.addWindow(mirWindowInfo1);
-    notifier.addWindow(mirWindowInfo2);
-    notifier.removeWindow(mirWindowInfo1);
-
-    notifier.addWindow(mirWindowInfo3);
+    auto newWindow1 = createNewWindow();
+    auto newWindow2 = createNewWindow();
+    auto newWindow3 = createNewWindow();
+
+    notifier.windowAdded(newWindow1);
+    notifier.windowAdded(newWindow2);
+    notifier.windowRemoved(newWindow1.windowInfo);
+
+    notifier.windowAdded(newWindow3);
     flushEvents();
 
     ASSERT_EQ(2, model.count());
     auto miralWindow2 = getMirALWindowFromModel(model, 0);
-    EXPECT_EQ(mirWindowInfo2.window(), miralWindow2);
+    EXPECT_EQ(newWindow2.windowInfo.window(), miralWindow2);
     auto miralWindow3 = getMirALWindowFromModel(model, 1);
-    EXPECT_EQ(mirWindowInfo3.window(), miralWindow3);
+    EXPECT_EQ(newWindow3.windowInfo.window(), miralWindow3);
 }
 
 /*
@@ -310,22 +312,22 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo1 = createMirALWindowInfo();
-    auto mirWindowInfo2 = createMirALWindowInfo();
-    auto mirWindowInfo3 = createMirALWindowInfo();
-
-    notifier.addWindow(mirWindowInfo1);
-    notifier.addWindow(mirWindowInfo2);
-    notifier.addWindow(mirWindowInfo3);
-
-    notifier.removeWindow(mirWindowInfo2);
+    auto newWindow1 = createNewWindow();
+    auto newWindow2 = createNewWindow();
+    auto newWindow3 = createNewWindow();
+
+    notifier.windowAdded(newWindow1);
+    notifier.windowAdded(newWindow2);
+    notifier.windowAdded(newWindow3);
+
+    notifier.windowRemoved(newWindow2.windowInfo);
     flushEvents();
 
     ASSERT_EQ(2, model.count());
     auto miralWindow1 = getMirALWindowFromModel(model, 0);
-    EXPECT_EQ(mirWindowInfo1.window(), miralWindow1);
+    EXPECT_EQ(newWindow1.windowInfo.window(), miralWindow1);
     auto miralWindow3 = getMirALWindowFromModel(model, 1);
-    EXPECT_EQ(mirWindowInfo3.window(), miralWindow3);
+    EXPECT_EQ(newWindow3.windowInfo.window(), miralWindow3);
 }
 
 /*
@@ -336,16 +338,16 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo1 = createMirALWindowInfo();
-    notifier.addWindow(mirWindowInfo1);
+    auto newWindow1 = createNewWindow();
+    notifier.windowAdded(newWindow1);
 
     // Raise first window
-    notifier.raiseWindows({mirWindowInfo1.window()});
+    notifier.windowsRaised({newWindow1.windowInfo.window()});
     flushEvents();
 
     ASSERT_EQ(1, model.count());
     auto topWindow = getMirALWindowFromModel(model, 0);
-    EXPECT_EQ(mirWindowInfo1.window(), topWindow);
+    EXPECT_EQ(newWindow1.windowInfo.window(), topWindow);
 }
 
 /*
@@ -356,19 +358,19 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo1 = createMirALWindowInfo();
-    auto mirWindowInfo2 = createMirALWindowInfo();
-    notifier.addWindow(mirWindowInfo1);
-    notifier.addWindow(mirWindowInfo2);
+    auto newWindow1 = createNewWindow();
+    auto newWindow2 = createNewWindow();
+    notifier.windowAdded(newWindow1);
+    notifier.windowAdded(newWindow2);
 
     // Raise second window (currently on top)
-    notifier.raiseWindows({mirWindowInfo2.window()});
+    notifier.windowsRaised({newWindow2.windowInfo.window()});
     flushEvents();
 
     // Check second window still on top
     ASSERT_EQ(2, model.count());
     auto topWindow = getMirALWindowFromModel(model, 1);
-    EXPECT_EQ(mirWindowInfo2.window(), topWindow);
+    EXPECT_EQ(newWindow2.windowInfo.window(), topWindow);
 }
 
 /*
@@ -379,19 +381,19 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo1 = createMirALWindowInfo();
-    auto mirWindowInfo2 = createMirALWindowInfo();
-    notifier.addWindow(mirWindowInfo1);
-    notifier.addWindow(mirWindowInfo2);
+    auto newWindow1 = createNewWindow();
+    auto newWindow2 = createNewWindow();
+    notifier.windowAdded(newWindow1);
+    notifier.windowAdded(newWindow2);
 
     // Raise first window (currently at bottom)
-    notifier.raiseWindows({mirWindowInfo1.window()});
+    notifier.windowsRaised({newWindow1.windowInfo.window()});
     flushEvents();
 
     // Check first window now on top
     ASSERT_EQ(2, model.count());
     auto topWindow = getMirALWindowFromModel(model, 1);
-    EXPECT_EQ(mirWindowInfo1.window(), topWindow);
+    EXPECT_EQ(newWindow1.windowInfo.window(), topWindow);
 }
 
 /*
@@ -402,12 +404,12 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo1 = createMirALWindowInfo();
-    auto mirWindowInfo2 = createMirALWindowInfo();
-    auto mirWindowInfo3 = createMirALWindowInfo();
-    notifier.addWindow(mirWindowInfo1);
-    notifier.addWindow(mirWindowInfo2);
-    notifier.addWindow(mirWindowInfo3);
+    auto newWindow1 = createNewWindow();
+    auto newWindow2 = createNewWindow();
+    auto newWindow3 = createNewWindow();
+    notifier.windowAdded(newWindow1);
+    notifier.windowAdded(newWindow2);
+    notifier.windowAdded(newWindow3);
 
     // Current model state
     // 2:   Window3
@@ -415,7 +417,7 @@
     // 0:   Window1
 
     // Raise windows 1 & 2 (currently at bottom)
-    notifier.raiseWindows({mirWindowInfo1.window(), mirWindowInfo2.window()});
+    notifier.windowsRaised({newWindow1.windowInfo.window(), newWindow2.windowInfo.window()});
 
     // Model should now be like this:
     // 2:   Window1
@@ -425,11 +427,11 @@
 
     ASSERT_EQ(3, model.count());
     auto topWindow = getMirALWindowFromModel(model, 2);
-    EXPECT_EQ(mirWindowInfo1.window(), topWindow);
+    EXPECT_EQ(newWindow1.windowInfo.window(), topWindow);
     auto middleWindow = getMirALWindowFromModel(model, 1);
-    EXPECT_EQ(mirWindowInfo2.window(), middleWindow);
+    EXPECT_EQ(newWindow2.windowInfo.window(), middleWindow);
     auto bottomWindow = getMirALWindowFromModel(model, 0);
-    EXPECT_EQ(mirWindowInfo3.window(), bottomWindow);
+    EXPECT_EQ(newWindow3.windowInfo.window(), bottomWindow);
 }
 
 /*
@@ -440,17 +442,17 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo1 = createMirALWindowInfo();
-    auto mirWindowInfo2 = createMirALWindowInfo();
-    notifier.addWindow(mirWindowInfo1);
-    notifier.addWindow(mirWindowInfo2);
+    auto newWindow1 = createNewWindow();
+    auto newWindow2 = createNewWindow();
+    notifier.windowAdded(newWindow1);
+    notifier.windowAdded(newWindow2);
 
     // Current model state
     // 1:   Window2
     // 0:   Window1
 
     // Raise windows 1 & 2 (in opposite order)
-    notifier.raiseWindows({mirWindowInfo1.window(), mirWindowInfo2.window()});
+    notifier.windowsRaised({newWindow1.windowInfo.window(), newWindow2.windowInfo.window()});
 
     // Model should now be like this:
     // 1:   Window1
@@ -459,9 +461,9 @@
 
     ASSERT_EQ(2, model.count());
     auto topWindow = getMirALWindowFromModel(model, 1);
-    EXPECT_EQ(mirWindowInfo1.window(), topWindow);
+    EXPECT_EQ(newWindow1.windowInfo.window(), topWindow);
     auto bottomWindow = getMirALWindowFromModel(model, 0);
-    EXPECT_EQ(mirWindowInfo2.window(), bottomWindow);
+    EXPECT_EQ(newWindow2.windowInfo.window(), bottomWindow);
 }
 
 /*
@@ -473,12 +475,12 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo1 = createMirALWindowInfo();
-    auto mirWindowInfo2 = createMirALWindowInfo();
-    auto mirWindowInfo3 = createMirALWindowInfo();
-    notifier.addWindow(mirWindowInfo1);
-    notifier.addWindow(mirWindowInfo2);
-    notifier.addWindow(mirWindowInfo3);
+    auto newWindow1 = createNewWindow();
+    auto newWindow2 = createNewWindow();
+    auto newWindow3 = createNewWindow();
+    notifier.windowAdded(newWindow1);
+    notifier.windowAdded(newWindow2);
+    notifier.windowAdded(newWindow3);
 
     // Current model state
     // 2:   Window3
@@ -486,7 +488,7 @@
     // 0:   Window1
 
     // Raise windows 2 & 1 (i.e. bottom two, but in opposite order)
-    notifier.raiseWindows({mirWindowInfo2.window(), mirWindowInfo1.window()});
+    notifier.windowsRaised({newWindow2.windowInfo.window(), newWindow1.windowInfo.window()});
 
     // Model should now be like this:
     // 2:   Window2
@@ -496,11 +498,11 @@
 
     ASSERT_EQ(3, model.count());
     auto topWindow = getMirALWindowFromModel(model, 2);
-    EXPECT_EQ(mirWindowInfo2.window(), topWindow);
+    EXPECT_EQ(newWindow2.windowInfo.window(), topWindow);
     auto middleWindow = getMirALWindowFromModel(model, 1);
-    EXPECT_EQ(mirWindowInfo1.window(), middleWindow);
+    EXPECT_EQ(newWindow1.windowInfo.window(), middleWindow);
     auto bottomWindow = getMirALWindowFromModel(model, 0);
-    EXPECT_EQ(mirWindowInfo3.window(), bottomWindow);
+    EXPECT_EQ(newWindow3.windowInfo.window(), bottomWindow);
 }
 
 /*
@@ -513,8 +515,8 @@
 
     QPoint position(100, 200);
 
-    auto mirWindowInfo = createMirALWindowInfo(position);
-    notifier.addWindow(mirWindowInfo);
+    auto newWindow = createNewWindow(position);
+    notifier.windowAdded(newWindow);
     flushEvents();
 
     auto surface = getMirSurfaceFromModel(model, 0);
@@ -532,13 +534,13 @@
     QPoint oldPosition(100, 200),
            newPosition(150, 220);
 
-    auto mirWindowInfo = createMirALWindowInfo(oldPosition);
-    notifier.addWindow(mirWindowInfo);
+    auto newWindow = createNewWindow(oldPosition);
+    notifier.windowAdded(newWindow);
 
     auto surface = getMirSurfaceFromModel(model, 0);
 
     // Move window, check new position set
-    notifier.moveWindow(mirWindowInfo, toMirPoint(newPosition));
+    notifier.windowMoved(newWindow.windowInfo, newPosition);
     flushEvents();
 
     EXPECT_EQ(newPosition, surface->position());
@@ -555,15 +557,15 @@
     QPoint oldPosition(100, 200),
            newPosition(150, 220);
 
-    auto mirWindowInfo1 = createMirALWindowInfo(oldPosition);
-    auto mirWindowInfo2 = createMirALWindowInfo(QPoint(300, 400));
-    notifier.addWindow(mirWindowInfo1);
-    notifier.addWindow(mirWindowInfo2);
+    auto newWindow1 = createNewWindow(oldPosition);
+    auto newWindow2 = createNewWindow(QPoint(300, 400));
+    notifier.windowAdded(newWindow1);
+    notifier.windowAdded(newWindow2);
 
-    auto surface = getMirSurfaceFromModel(model, 0); // will be MirSurface for mirWindowInfo1
+    auto surface = getMirSurfaceFromModel(model, 0); // will be MirSurface for newWindow1
 
     // Move window, check new position set
-    notifier.moveWindow(mirWindowInfo1, toMirPoint(newPosition));
+    notifier.windowMoved(newWindow1.windowInfo, newPosition);
     flushEvents();
 
     EXPECT_EQ(newPosition, surface->position());
@@ -579,15 +581,15 @@
 
     QPoint fixedPosition(300, 400);
 
-    auto mirWindowInfo1 = createMirALWindowInfo(QPoint(100, 200));
-    auto mirWindowInfo2 = createMirALWindowInfo(fixedPosition);
-    notifier.addWindow(mirWindowInfo1);
-    notifier.addWindow(mirWindowInfo2);
+    auto newWindow1 = createNewWindow(QPoint(100, 200));
+    auto newWindow2 = createNewWindow(fixedPosition);
+    notifier.windowAdded(newWindow1);
+    notifier.windowAdded(newWindow2);
 
-    auto surface = getMirSurfaceFromModel(model, 1); // will be MirSurface for mirWindowInfo2
+    auto surface = getMirSurfaceFromModel(model, 1); // will be MirSurface for newWindow2
 
     // Move window, check new position set
-    notifier.moveWindow(mirWindowInfo1, toMirPoint(QPoint(350, 420)));
+    notifier.windowMoved(newWindow1.windowInfo, QPoint(350, 420));
     flushEvents();
 
     // Ensure other window untouched
@@ -604,8 +606,8 @@
 
     QSize size(300, 200);
 
-    auto mirWindowInfo1 = createMirALWindowInfo(QPoint(), size);
-    notifier.addWindow(mirWindowInfo1);
+    auto newWindow1 = createNewWindow(QPoint(), size);
+    notifier.windowAdded(newWindow1);
     flushEvents();
 
     auto surface = getMirSurfaceFromModel(model, 0);
@@ -622,13 +624,13 @@
 
     QSize newSize(150, 220);
 
-    auto mirWindowInfo1 = createMirALWindowInfo(QPoint(), QSize(300, 200));
-    notifier.addWindow(mirWindowInfo1);
+    auto newWindow1 = createNewWindow(QPoint(), QSize(300, 200));
+    notifier.windowAdded(newWindow1);
 
     auto surface = getMirSurfaceFromModel(model, 0);
 
     // Resize window, check new size set
-    notifier.resizeWindow(mirWindowInfo1, toMirSize(newSize));
+    notifier.windowResized(newWindow1.windowInfo, newSize);
     flushEvents();
 
     EXPECT_EQ(newSize, surface->size());
@@ -644,15 +646,15 @@
 
     QSize newSize(150, 220);
 
-    auto mirWindowInfo1 = createMirALWindowInfo(QPoint(), QSize(100, 200));
-    auto mirWindowInfo2 = createMirALWindowInfo(QPoint(), QSize(300, 400));
-    notifier.addWindow(mirWindowInfo1);
-    notifier.addWindow(mirWindowInfo2);
+    auto newWindow1 = createNewWindow(QPoint(), QSize(100, 200));
+    auto newWindow2 = createNewWindow(QPoint(), QSize(300, 400));
+    notifier.windowAdded(newWindow1);
+    notifier.windowAdded(newWindow2);
 
     auto surface = getMirSurfaceFromModel(model, 0);
 
     // Resize window, check new size set
-    notifier.resizeWindow(mirWindowInfo1, toMirSize(newSize));
+    notifier.windowResized(newWindow1.windowInfo, newSize);
     flushEvents();
 
     EXPECT_EQ(newSize, surface->size());
@@ -668,15 +670,15 @@
 
     QSize fixedSize(300, 400);
 
-    auto mirWindowInfo1 = createMirALWindowInfo(QPoint(), QSize(100, 200));
-    auto mirWindowInfo2 = createMirALWindowInfo(QPoint(), fixedSize);
-    notifier.addWindow(mirWindowInfo1);
-    notifier.addWindow(mirWindowInfo2);
+    auto newWindow1 = createNewWindow(QPoint(), QSize(100, 200));
+    auto newWindow2 = createNewWindow(QPoint(), fixedSize);
+    notifier.windowAdded(newWindow1);
+    notifier.windowAdded(newWindow2);
 
     auto surface = getMirSurfaceFromModel(model, 1);
 
     // Resize window
-    notifier.resizeWindow(mirWindowInfo1, toMirSize(QSize(150, 220)));
+    notifier.windowResized(newWindow1.windowInfo, QSize(150, 220));
     flushEvents();
 
     // Ensure other window untouched
@@ -684,7 +686,7 @@
 }
 
 /*
- * Test: that the WindowModelNotifier.addWindow for an Input Method Window causes
+ * Test: that the WindowModelNotifier.windowAdded for an Input Method Window causes
  * the Qt-side WindowModel to register the input method surface
  */
 TEST_F(WindowModelTest, WhenAddInputMethodWindowNotifiedModelEmitsInputMethodChangedSignal)
@@ -692,18 +694,18 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo = createMirALWindowInfoForInputMethod();
+    auto newWindow = createNewWindowForInputMethod();
 
     QSignalSpy spyCountChanged(&model, SIGNAL(inputMethodSurfaceChanged(MirSurfaceInterface*)));
 
-    notifier.addWindow(mirWindowInfo);
+    notifier.windowAdded(newWindow);
     flushEvents();
 
     EXPECT_EQ(1, spyCountChanged.count());
 }
 
 /*
- * Test: that the WindowModelNotifier.addWindow for an Input Method Window causes
+ * Test: that the WindowModelNotifier.windowAdded for an Input Method Window causes
  * the Qt-side WindowModel::inputMethodSurface property to be correctly set
  */
 TEST_F(WindowModelTest, WhenAddInputMethodWindowNotifiedModelPropertyHasCorrectWindow)
@@ -711,17 +713,17 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo = createMirALWindowInfoForInputMethod();
+    auto newWindow = createNewWindowForInputMethod();
 
-    notifier.addWindow(mirWindowInfo);
+    notifier.windowAdded(newWindow);
     flushEvents();
 
     auto miralWindow = static_cast<MirSurface*>(model.inputMethodSurface())->window();
-    EXPECT_EQ(mirWindowInfo.window(), miralWindow);
+    EXPECT_EQ(newWindow.windowInfo.window(), miralWindow);
 }
 
 /*
- * Test: that the WindowModelNotifier.removeWindow for an Input Method Window causes
+ * Test: that the WindowModelNotifier.windowRemoved for an Input Method Window causes
  * the Qt-side WindowModel to reset the WindowModel::inputMethodSurface property to null
  */
 TEST_F(WindowModelTest, WhenRemoveInputMethodWindowNotifiedModelPropertyReset)
@@ -729,11 +731,11 @@
     WindowModelNotifier notifier;
     WindowModel model(&notifier, nullptr); // no need for controller in this testcase
 
-    auto mirWindowInfo = createMirALWindowInfoForInputMethod();
-    notifier.addWindow(mirWindowInfo);
+    auto newWindow = createNewWindowForInputMethod();
+    notifier.windowAdded(newWindow);
 
     // Test removing the window
-    notifier.removeWindow(mirWindowInfo);
+    notifier.windowRemoved(newWindow.windowInfo);
     flushEvents();
 
     EXPECT_EQ(nullptr, model.inputMethodSurface());

=== modified file 'miral/window_info.cpp'
--- miral/window_info.cpp	2016-08-05 13:38:53 +0000
+++ miral/window_info.cpp	2016-09-13 12:26:41 +0000
@@ -35,6 +35,7 @@
 struct miral::WindowInfo::Self
 {
     Self(Window window, WindowSpecification const& params);
+    Self();
 
     Window window;
     mir::optional_value<std::string> name;
@@ -77,6 +78,18 @@
         output_id = params.output_id().value();
 }
 
+miral::WindowInfo::Self::Self() :
+    type{mir_surface_type_normal},
+    state{mir_surface_state_unknown},
+    preferred_orientation{mir_orientation_mode_any}
+{
+}
+
+miral::WindowInfo::WindowInfo() :
+    self{std::make_unique<Self>()}
+{
+}
+
 miral::WindowInfo::WindowInfo(
     Window const& window,
     WindowSpecification const& params) :