Merge lp:~alan-griffiths/miral/spike-miral-qt-integration into lp:miral

[Alan Griffiths]

Another pass at removing MirServer so that its use can be replaced by miral::MirRunner

[lp:~alan-griffiths/miral/spike-miral-qt-integration]

301. By Alan Griffiths on 2016-08-18

Revert change to startup wait

302. By Alan Griffiths on 2016-08-18

merge lp:~alan-griffiths/miral/add-MirRunner-add_start_callback

303. By Alan Griffiths on 2016-08-18

Replace miral-qt MirServer with miral::MirRunner

304. By Alan Griffiths on 2016-08-18

Delete mysteryous FIXME

305. By Alan Griffiths on 2016-08-18

QMirServerPrivate can't be a functor, don't force it to look like one

306. By Alan Griffiths on 2016-08-18

A bit more tidy-up

Unmerged revisions

=== modified file 'miral-qt/src/platforms/mirserver/CMakeLists.txt'
--- miral-qt/src/platforms/mirserver/CMakeLists.txt	2016-08-15 16:13:40 +0000
+++ miral-qt/src/platforms/mirserver/CMakeLists.txt	2016-08-18 07:54:15 +0000
@@ -83,7 +83,7 @@
     windowmanagementpolicy.cpp
     windowmodel.cpp
     tracepoints.c
-    usingqtcompositor.cpp usingqtcompositor.h
+    setqtcompositor.cpp setqtcompositor.h
 # We need to run moc on these headers
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirMousePointerInterface.h

=== modified file 'miral-qt/src/platforms/mirserver/mirserver.cpp'
--- miral-qt/src/platforms/mirserver/mirserver.cpp	2016-08-16 14:32:17 +0000
+++ miral-qt/src/platforms/mirserver/mirserver.cpp	2016-08-18 07:54:15 +0000
@@ -14,82 +14,4 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QCoreApplication>
-
 #include "mirserver.h"
-
-// local
-#include "argvHelper.h"
-#include "screensmodel.h"
-#include "logging.h"
-#include "usingqtcompositor.h"
-
-// std
-#include <memory>
-
-// egl
-#define MESA_EGL_NO_X11_HEADERS
-#include <EGL/egl.h>
-
-// mir
-#include <mir/shell/shell.h>
-
-// miral
-#include <miral/set_terminator.h>
-
-namespace mg = mir::graphics;
-namespace mo  = mir::options;
-namespace msh = mir::shell;
-namespace ms = mir::scene;
-
-MirServer::MirServer(int &argc, char **argv,
-                     const QSharedPointer<ScreensModel> &screensModel, QObject* parent)
-    : QObject(parent)
-    , m_screensModel(screensModel)
-{
-    bool unknownArgsFound = false;
-    set_command_line_handler([&argc, &argv, &unknownArgsFound](int filteredCount, const char* const filteredArgv[]) {
-        unknownArgsFound = true;
-        // Want to edit argv to match that which Mir returns, as those are for to Qt alone to process. Edit existing
-        // argc as filteredArgv only defined in this scope.
-        qtmir::editArgvToMatch(argc, argv, filteredCount, filteredArgv);
-    });
-
-    // Casting char** to be a const char** safe as Mir won't change it, nor will we
-    set_command_line(argc, const_cast<const char **>(argv));
-
-    usingQtCompositor(*this);
-
-    miral::SetTerminator{[](int)
-        {
-            qDebug() << "Signal caught by Mir, stopping Mir server..";
-            QCoreApplication::quit();
-        }}(*this);
-
-    add_init_callback([this, &screensModel] {
-        screensModel->init(the_display(), the_compositor(), the_shell());
-    });
-
-    if (!unknownArgsFound) { // mir parsed all the arguments, so edit argv to pretend to have just argv[0]
-        argc = 1;
-    }
-
-    qCDebug(QTMIR_MIR_MESSAGES) << "MirServer created";
-    qCDebug(QTMIR_MIR_MESSAGES) << "Command line arguments passed to Qt:" << QCoreApplication::arguments();
-}
-
-// Override default implementation to ensure we terminate the ScreensModel first.
-// Code path followed when Qt tries to shutdown the server.
-void MirServer::stop()
-{
-    m_screensModel->terminate();
-    mir::Server::stop();
-}
-
-
-/************************************ Shell side ************************************/
-
-QSharedPointer<ScreensModel> MirServer::screensModel() const
-{
-    return m_screensModel;
-}

=== modified file 'miral-qt/src/platforms/mirserver/mirserver.h'
--- miral-qt/src/platforms/mirserver/mirserver.h	2016-08-15 11:39:14 +0000
+++ miral-qt/src/platforms/mirserver/mirserver.h	2016-08-18 07:54:15 +0000
@@ -35,16 +35,11 @@
     Q_OBJECT
 
 public:
-    MirServer(int &argc, char **argv, const QSharedPointer<ScreensModel> &, QObject* parent = 0);
+    MirServer(QObject* parent = 0) : QObject(parent)
+    {
+    }
+
     ~MirServer() = default;
-
-    void stop();
-
-    QSharedPointer<ScreensModel> screensModel() const;
-
-private:
-
-    const QSharedPointer<ScreensModel> m_screensModel;
 };
 
 #endif // MIRSERVER_H

=== modified file 'miral-qt/src/platforms/mirserver/qmirserver.cpp'
--- miral-qt/src/platforms/mirserver/qmirserver.cpp	2016-08-12 16:55:12 +0000
+++ miral-qt/src/platforms/mirserver/qmirserver.cpp	2016-08-18 07:54:15 +0000
@@ -16,7 +16,6 @@
 
 // Qt
 #include <QObject>
-#include <QCoreApplication>
 #include <QDebug>
 #include <QOpenGLContext>
 
@@ -24,7 +23,6 @@
 #include "mirserver.h"
 #include "qmirserver.h"
 #include "qmirserver_p.h"
-#include "screen.h"
 #include "miropenglcontext.h"
 
 QMirServer::QMirServer(int &argc, char **argv, QObject *parent)
@@ -33,9 +31,9 @@
 {
     Q_D(QMirServer);
 
-    d->server = QSharedPointer<MirServer>(new MirServer(argc, argv, d->screensModel));
+    d->server = QSharedPointer<MirServer>(new MirServer());
 
-    d->serverThread = new MirServerThread(d);
+    d->serverThread = new MirServerThread(argc, argv, d);
 
     connect(d->serverThread, &MirServerThread::stopped, this, &QMirServer::stopped);
 }
@@ -110,15 +108,15 @@
 
     if (d->server) {
         if (resource == "SessionAuthorizer")
-            result = d->m_usingQtMirSessionAuthorizer.the_application_authorizer().get();
+            result = d->the_application_authorizer().get();
         else if (resource == "SessionListener")
-            result = d->m_usingQtMirSessionListener.sessionListener();
+            result = d->sessionListener();
         else if (resource == "PromptSessionListener")
-            result = d->m_usingQtMirPromptSessionListener.promptSessionListener();
+            result = d->promptSessionListener();
         else if (resource == "WindowController")
-            result = d->m_usingQtMirWindowManager.windowController();
+            result = d->windowController();
         else if (resource == "WindowModel")
-            result = d->m_usingQtMirWindowManager.windowModel();
+            result = d->windowModel();
         else if (resource == "ScreensController")
             result = screensController().data();
     }

=== modified file 'miral-qt/src/platforms/mirserver/qmirserver_p.cpp'
--- miral-qt/src/platforms/mirserver/qmirserver_p.cpp	2016-08-15 11:52:27 +0000
+++ miral-qt/src/platforms/mirserver/qmirserver_p.cpp	2016-08-18 07:54:15 +0000
@@ -15,6 +15,7 @@
  */
 
 #include "qmirserver_p.h"
+#include <QCoreApplication>
 
 // Mir
 #include <mir/main_loop.h>
@@ -27,15 +28,54 @@
 #include "sessionlistener.h"
 #include "sessionauthorizer.h"
 #include "windowmanagementpolicy.h"
+#include "argvHelper.h"
+#include "setqtcompositor.h"
+
+// miral
+#include <miral/add_init_callback.h>
+#include <miral/set_command_line_hander.h>
+#include <miral/set_terminator.h>
+#include <miral/set_window_managment_policy.h>
 
 void MirServerThread::run()
 {
-    // This should eventually be replaced by miral::MirRunner::run()
-    server->m_usingQtMirSessionAuthorizer(*server->server);
-    server->m_usingQtMirSessionListener(*server->server);
-    server->m_usingQtMirPromptSessionListener(*server->server);
-    server->m_usingQtMirWindowManager(*server->server);
+    bool unknownArgsFound = false;
+
+    miral::SetCommandLineHandler setCommandLineHandler{[this, &unknownArgsFound](int filteredCount, const char* const filteredArgv[])
+    {
+        unknownArgsFound = true;
+        // Want to edit argv to match that which Mir returns, as those are for to Qt alone to process. Edit existing
+        // argc as filteredArgv only defined in this scope.
+        qtmir::editArgvToMatch(argc, argv, filteredCount, filteredArgv);
+    }};
+
+    miral::AddInitCallback addInitCallback{[&, this]
+    {
+        if (!unknownArgsFound) { // mir parsed all the arguments, so edit argv to pretend to have just argv[0]
+            argc = 1;
+        }
+        qCDebug(QTMIR_MIR_MESSAGES) << "MirServer created";
+        qCDebug(QTMIR_MIR_MESSAGES) << "Command line arguments passed to Qt:" << QCoreApplication::arguments();
+    }};
+
+    miral::SetTerminator setTerminator{[](int)
+    {
+        qDebug() << "Signal caught by Mir, stopping Mir server..";
+        QCoreApplication::quit();
+    }};
+
+    qtmir::SetQtCompositor setQtCompositor{server->screensModel};
+
+    // Casting char** to be a const char** safe as Mir won't change it, nor will we
+    server->server->set_command_line(argc, const_cast<const char **>(argv));
+
+    // This should eventually be replaced by miral::MirRunner::run_with()
+    (*server)(*server->server);
     mir_display_configuration_policy(*server->server);
+    setCommandLineHandler(*server->server);
+    addInitCallback(*server->server);
+    setQtCompositor(*server->server);
+    setTerminator(*server->server);
 
     try {
         server->server->apply_settings();
@@ -63,6 +103,7 @@
 
 void MirServerThread::stop()
 {
+    server->screensModel->terminate();
     server->server->stop();
 }
 
@@ -73,54 +114,64 @@
     return mir_running;
 }
 
-void UsingQtMirSessionListener::operator()(mir::Server& server)
-{
+struct QMirServerPrivate::Self
+{
+    Self(const QSharedPointer<ScreensModel> &model);
+    const QSharedPointer<ScreensModel> &m_screensModel;
+    miral::SetWindowManagmentPolicy m_policy;
+    qtmir::WindowController m_windowController;
+    qtmir::WindowModel m_windowModel;
+    std::weak_ptr<SessionListener> m_sessionListener;
+    std::weak_ptr<PromptSessionListener> m_promptSessionListener;
+};
+
+SessionListener *QMirServerPrivate::sessionListener() const
+{
+    return self->m_sessionListener.lock().get();
+}
+
+QMirServerPrivate::Self::Self(const QSharedPointer<ScreensModel> &model)
+    : m_screensModel(model)
+    , m_policy(miral::set_window_managment_policy<WindowManagementPolicy>(m_windowModel, m_windowController, m_screensModel))
+{
+}
+
+qtmir::WindowModelInterface *QMirServerPrivate::windowModel() const
+{
+    return &self->m_windowModel;
+}
+
+qtmir::WindowControllerInterface *QMirServerPrivate::windowController() const
+{
+    return &self->m_windowController;
+}
+
+QMirServerPrivate::QMirServerPrivate() :
+    self{std::make_shared<Self>(screensModel)}
+{
+}
+
+PromptSessionListener *QMirServerPrivate::promptSessionListener() const
+{
+    return self->m_promptSessionListener.lock().get();
+}
+
+void QMirServerPrivate::operator()(mir::Server& server)
+{
+    qtmir::SetSessionAuthorizer::operator()(server);
     server.override_the_session_listener([this]
         {
             auto const result = std::make_shared<SessionListener>();
-            m_sessionListener = result;
+            self->m_sessionListener = result;
             return result;
         });
-}
-
-SessionListener *UsingQtMirSessionListener::sessionListener()
-{
-    return m_sessionListener.lock().get();
-}
-
-void UsingQtMirPromptSessionListener::operator()(mir::Server& server)
-{
+
     server.override_the_prompt_session_listener([this]
         {
             auto const result = std::make_shared<PromptSessionListener>();
-            m_promptSessionListener = result;
+            self->m_promptSessionListener = result;
             return result;
         });
-}
-
-PromptSessionListener *UsingQtMirPromptSessionListener::promptSessionListener()
-{
-    return m_promptSessionListener.lock().get();
-}
-
-UsingQtMirWindowManager::UsingQtMirWindowManager(const QSharedPointer<ScreensModel> &model)
-    : m_screensModel(model)
-    , m_policy(miral::set_window_managment_policy<WindowManagementPolicy>(m_windowModel, m_windowController, m_screensModel))
-{
-}
-
-void UsingQtMirWindowManager::operator()(mir::Server& server)
-{
-    m_policy(server);
-}
-
-qtmir::WindowModelInterface *UsingQtMirWindowManager::windowModel()
-{
-    return &m_windowModel;
-}
-
-qtmir::WindowControllerInterface *UsingQtMirWindowManager::windowController()
-{
-    return &m_windowController;
-}
-
+
+    self->m_policy(server);
+}

=== modified file 'miral-qt/src/platforms/mirserver/qmirserver_p.h'
--- miral-qt/src/platforms/mirserver/qmirserver_p.h	2016-08-12 16:55:12 +0000
+++ miral-qt/src/platforms/mirserver/qmirserver_p.h	2016-08-18 07:54:15 +0000
@@ -33,7 +33,6 @@
 
 //miral
 #include <miral/application_authorizer.h>
-#include "miral/set_window_managment_policy.h"
 
 class MirServer;
 class QMirServer;
@@ -42,57 +41,32 @@
 class SessionListener;
 class SessionAuthorizer;
 
-// TODO the UsingQtMirXXX classes introduced here are a step towards
-//      decoupling from libmirserver and using a libmiral-style API
-using UsingQtMirSessionAuthorizer = miral::SetApplicationAuthorizer<SessionAuthorizer>;
-
-class UsingQtMirSessionListener
-{
-public:
-    void operator()(mir::Server& server);
-    SessionListener *sessionListener();
-
-private:
-    std::weak_ptr<SessionListener> m_sessionListener;
-};
-
-class UsingQtMirPromptSessionListener
-{
-public:
-    void operator()(mir::Server& server);
-    PromptSessionListener *promptSessionListener();
-
-private:
-    std::weak_ptr<PromptSessionListener> m_promptSessionListener;
-};
-
-class UsingQtMirWindowManager
-{
-public:
-    UsingQtMirWindowManager(const QSharedPointer<ScreensModel> &model);
-    void operator()(mir::Server& server);
-    qtmir::WindowModelInterface *windowModel();
-    qtmir::WindowControllerInterface *windowController();
-
-private:
-    const QSharedPointer<ScreensModel> &m_screensModel;
-    miral::SetWindowManagmentPolicy m_policy;
-    qtmir::WindowController m_windowController;
-    qtmir::WindowModel m_windowModel;
-};
-
-class QMirServerPrivate
-{
-public:
-    QSharedPointer<ScreensModel> screensModel{new ScreensModel()};
+namespace qtmir
+{
+using SetSessionAuthorizer = miral::SetApplicationAuthorizer<SessionAuthorizer>;
+}
+
+class QMirServerPrivate : private qtmir::SetSessionAuthorizer
+{
+public:
+    QMirServerPrivate();
+    const QSharedPointer<ScreensModel> screensModel{new ScreensModel()};
     QSharedPointer<MirServer> server;
     QSharedPointer<ScreensController> screensController;
     MirServerThread *serverThread;
 
-    UsingQtMirSessionAuthorizer m_usingQtMirSessionAuthorizer;
-    UsingQtMirSessionListener mutable m_usingQtMirSessionListener;
-    UsingQtMirPromptSessionListener mutable m_usingQtMirPromptSessionListener;
-    UsingQtMirWindowManager mutable m_usingQtMirWindowManager{screensModel};
+    void operator()(mir::Server& server);
+
+    SessionListener *sessionListener() const;
+    PromptSessionListener *promptSessionListener() const;
+    qtmir::WindowModelInterface *windowModel() const;
+    qtmir::WindowControllerInterface *windowController() const;
+
+    using qtmir::SetSessionAuthorizer::the_application_authorizer;
+
+private:
+    struct Self;
+    std::shared_ptr<Self> const self;
 };
 
 class MirServerThread : public QThread
@@ -100,8 +74,8 @@
     Q_OBJECT
 
 public:
-    MirServerThread(QMirServerPrivate* server)
-        : server(server)
+    MirServerThread(int &argc, char **argv, QMirServerPrivate* server)
+        : argc{argc}, argv{argv}, server(server)
     {}
 
     bool waitForMirStartup();
@@ -118,6 +92,8 @@
     std::condition_variable started_cv;
     bool mir_running{false};
 
+    int &argc;
+    char **argv;
     QMirServerPrivate* const server;
 };
 

=== modified file 'miral-qt/src/platforms/mirserver/screensmodel.cpp'
--- miral-qt/src/platforms/mirserver/screensmodel.cpp	2016-08-16 14:15:26 +0000
+++ miral-qt/src/platforms/mirserver/screensmodel.cpp	2016-08-18 07:54:15 +0000
@@ -48,9 +48,10 @@
 }
 
 // init only after MirServer has initialized - runs on MirServerThread!!!
-void ScreensModel::init(const std::shared_ptr<mir::graphics::Display> &display,
-                        const std::shared_ptr<mir::compositor::Compositor> &compositor,
-                        const std::shared_ptr<mir::compositor::DisplayListener> &displayListener)
+void ScreensModel::init(
+    const std::shared_ptr<mir::graphics::Display>& display,
+    const std::shared_ptr<QtCompositor>& compositor,
+    const std::shared_ptr<mir::compositor::DisplayListener>& displayListener)
 {
     m_display = display;
     m_compositor = compositor;
@@ -59,7 +60,7 @@
     // Use a Blocking Queued Connection to enforce synchronization of Qt GUI thread with Mir thread(s)
     // on compositor shutdown. Compositor startup can be lazy.
     // Queued connections work because the thread affinity of this class is with the Qt GUI thread.
-    auto qtCompositor = static_cast<QtCompositor *>(compositor.get());
+    auto qtCompositor = compositor.get();
     connect(qtCompositor, &QtCompositor::starting,
             this, &ScreensModel::onCompositorStarting);
     connect(qtCompositor, &QtCompositor::stopping,
@@ -70,8 +71,7 @@
 // Runs on MirServerThread!!!
 void ScreensModel::terminate()
 {
-    auto qtCompositor = static_cast<QtCompositor *>(m_compositor.get());
-    qtCompositor->disconnect();
+    m_compositor->disconnect();
 }
 
 void ScreensModel::onCompositorStarting()

=== modified file 'miral-qt/src/platforms/mirserver/screensmodel.h'
--- miral-qt/src/platforms/mirserver/screensmodel.h	2016-08-16 14:15:26 +0000
+++ miral-qt/src/platforms/mirserver/screensmodel.h	2016-08-18 07:54:15 +0000
@@ -28,10 +28,11 @@
 
 namespace mir {
     namespace graphics { class Display; }
-    namespace compositor { class Compositor; class DisplayListener; }
+    namespace compositor { class DisplayListener; }
 }
 class Screen;
 class QWindow;
+class QtCompositor;
 
 /*
  * ScreensModel monitors the Mir display configuration and compositor status, and updates
@@ -73,9 +74,10 @@
 
 public:
     // called by MirServer
-    void init(const std::shared_ptr<mir::graphics::Display> &display,
-              const std::shared_ptr<mir::compositor::Compositor> &compositor,
-              const std::shared_ptr<mir::compositor::DisplayListener> &displayListener);
+    void init(
+        const std::shared_ptr<mir::graphics::Display>& display,
+        const std::shared_ptr<QtCompositor>& compositor,
+        const std::shared_ptr<mir::compositor::DisplayListener>& displayListener);
     void terminate();
 
     // override for testing purposes
@@ -91,7 +93,7 @@
     void allWindowsSetExposed(bool exposed);
 
     std::weak_ptr<mir::graphics::Display> m_display;
-    std::shared_ptr<mir::compositor::Compositor> m_compositor;
+    std::shared_ptr<QtCompositor> m_compositor;
     std::shared_ptr<mir::compositor::DisplayListener> m_displayListener;
     QList<Screen*> m_screenList;
     bool m_compositing;

=== renamed file 'miral-qt/src/platforms/mirserver/usingqtcompositor.cpp' => 'miral-qt/src/platforms/mirserver/setqtcompositor.cpp'
--- miral-qt/src/platforms/mirserver/usingqtcompositor.cpp	2016-08-15 16:13:40 +0000
+++ miral-qt/src/platforms/mirserver/setqtcompositor.cpp	2016-08-18 07:54:15 +0000
@@ -16,17 +16,19 @@
  * Authored by: Alan Griffiths <[e-mail]>
  */
 
-#include "usingqtcompositor.h"
+#include "setqtcompositor.h"
 
 // local
 #include "mircursorimages.h"
 #include "mirglconfig.h"
 #include "mirserverstatuslistener.h"
 #include "qtcompositor.h"
+#include "screensmodel.h"
 
 // mir
 #include <mir/graphics/cursor.h>
 #include <mir/server.h>
+#include <mir/shell/shell.h>
 
 namespace mg = mir::graphics;
 
@@ -47,10 +49,19 @@
 };
 }
 
-void usingQtCompositor(mir::Server& server)
-{
-    server.override_the_compositor([]
-        { return std::make_shared<QtCompositor>(); });
+qtmir::SetQtCompositor::SetQtCompositor(QSharedPointer<ScreensModel> const& screensModel) :
+    m_screensModel{screensModel}
+{
+}
+
+void qtmir::SetQtCompositor::operator()(mir::Server& server)
+{
+    server.override_the_compositor([this]
+    {
+        auto result = std::make_shared<QtCompositor>();
+        m_compositor = result;
+        return result;
+    });
 
     server.override_the_gl_config([]
         { return std::make_shared<MirGLConfig>(); });
@@ -63,4 +74,17 @@
 
     server.wrap_cursor([&](std::shared_ptr<mg::Cursor> const& wrapped)
         { return std::make_shared<HiddenCursorWrapper>(wrapped); });
+
+    server.add_init_callback([&, this]
+        {
+            if (auto const compositor = m_compositor.lock())
+            {
+                m_screensModel->init(server.the_display(), compositor, server.the_shell());
+            }
+            else
+            {
+                throw std::logic_error("No m_compositor available. Server not running?");
+            }
+        });
 }
+

=== renamed file 'miral-qt/src/platforms/mirserver/usingqtcompositor.h' => 'miral-qt/src/platforms/mirserver/setqtcompositor.h'
--- miral-qt/src/platforms/mirserver/usingqtcompositor.h	2016-08-15 16:14:50 +0000
+++ miral-qt/src/platforms/mirserver/setqtcompositor.h	2016-08-18 07:54:15 +0000
@@ -16,12 +16,32 @@
  * Authored by: Alan Griffiths <[e-mail]>
  */
 
-#ifndef USING_QT_COMPOSITOR_H
-#define USING_QT_COMPOSITOR_H
+#ifndef QTMIR_SET_QT_COMPOSITOR_H
+#define QTMIR_SET_QT_COMPOSITOR_H
+
+#include <QSharedPointer>
+
+#include <memory>
 
 namespace mir { class Server; }
 
+class QtCompositor;
+class ScreensModel;
+
+namespace qtmir
+{
 // Configure the server for using the Qt compositor
-void usingQtCompositor(mir::Server& server);
-
-#endif //USING_QT_COMPOSITOR_H
+class SetQtCompositor
+{
+public:
+    explicit SetQtCompositor(QSharedPointer<ScreensModel> const& screensModel);
+
+    void operator()(mir::Server& server);
+
+private:
+    QSharedPointer<ScreensModel> const m_screensModel;
+    std::weak_ptr<QtCompositor> m_compositor;
+};
+}
+
+#endif //QTMIR_SET_QT_COMPOSITOR_H

=== modified file 'miral-qt/tests/framework/fake_displayconfigurationoutput.h'
--- miral-qt/tests/framework/fake_displayconfigurationoutput.h	2016-06-01 22:06:51 +0000
+++ miral-qt/tests/framework/fake_displayconfigurationoutput.h	2016-08-18 07:54:15 +0000
@@ -18,6 +18,7 @@
 #define FAKE_DISPLAYCONFIGURATIONOUTPUT_H
 
 #include <mir/graphics/display_configuration.h>
+#include <mir/version.h>
 
 namespace mg = mir::graphics;
 namespace geom = mir::geometry;
@@ -46,7 +47,12 @@
     mir_orientation_normal,
     1.0f,
     mir_form_factor_unknown
-};
+
+#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 25, 0)
+    ,
+    mir_subpixel_arrangement_unknown
+#endif
+    };
 
 const mg::DisplayConfigurationOutput fakeOutput2
 {
@@ -72,6 +78,10 @@
     mir_orientation_left,
     1.0f,
     mir_form_factor_unknown
+#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 25, 0)
+        ,
+    mir_subpixel_arrangement_unknown
+#endif
 };
 
 #endif // FAKE_DISPLAYCONFIGURATIONOUTPUT_H

=== modified file 'miral-qt/tests/mirserver/ScreensModel/testable_screensmodel.h'
--- miral-qt/tests/mirserver/ScreensModel/testable_screensmodel.h	2016-07-27 13:59:34 +0000
+++ miral-qt/tests/mirserver/ScreensModel/testable_screensmodel.h	2016-08-18 07:54:15 +0000
@@ -28,7 +28,7 @@
     }
 
     void do_init(const std::shared_ptr<mir::graphics::Display> &display,
-                 const std::shared_ptr<mir::compositor::Compositor> &compositor,
+                 const std::shared_ptr<QtCompositor> &compositor,
                  const std::shared_ptr<mir::compositor::DisplayListener> &displayListener)
     {
         init(display, compositor, displayListener);