Merge lp:~albaguirre/qtubuntu/use-mir-rs-api into lp:qtubuntu

[Alberto Aguirre]

Avoid use of deprecated mir EGL related apis.

With the new mesa update, the EGLNativeDisplayType is MirConnection * and the EGLNativeWindowType is a MirRenderSurface *.

Ignore deprecation warnings on use of MirRenderSurface - its "deprecated" because it'll be renamed in mir 1.0.

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:392
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/222/
Executed test runs:
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build/4820/console
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/4848
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=xenial+overlay/4659/console
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=zesty/4659
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=zesty/4659/artifact/output/*zip*/output.zip
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=xenial+overlay/4659/console
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=zesty/4659
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=zesty/4659/artifact/output/*zip*/output.zip
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=xenial+overlay/4659/console
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=zesty/4659
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=zesty/4659/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/222/rebuild

review: Needs Fixing (continuous-integration)

[Alan Griffiths (alan-griffiths)]

This would be nicely simplified by lp:~alan-griffiths/mir/deprecation-macros plus -DMIR_DEPRECATE_RENDERSURFACES=0

[Alan Griffiths (alan-griffiths)]

Looks mostly sensible, but I need to get more familiar with qtubuntu to be sure.

Can we aim to land lp:~alan-griffiths/mir/deprecation-macros and use -DMIR_DEPRECATE_RENDERSURFACES=0 - or building against trunk Mir an issue?

review: Needs Information

[Gerry Boland (gerboland)]

I have a question about how pixel formats work with the newer Mir API. I see you've removed code where Qt could set a desired pixel format on the mir surface - is this feature impossible to replicate?

This was done because sometimes the EGL config chosen may have an alpha buffer enabled, even if Qt doesn't need it. We used the mir pixel format to inform the Mir compositor that blending is not required in that case - a nice optimisation.

review: Needs Information

[Gerry Boland (gerboland)]

I agree with Alan that using his deprecation bits would be nice, but I'd be ok with landing this in the current state if we need this to land first.

[Alan Griffiths (alan-griffiths)]

> I have a question about how pixel formats work with the newer Mir API. I see
> you've removed code where Qt could set a desired pixel format on the mir
> surface - is this feature impossible to replicate?

Mir currently has "Window" and "RenderSurface" but not "surface". I assume you mean "RenderSurface"?

> This was done because sometimes the EGL config chosen may have an alpha buffer
> enabled, even if Qt doesn't need it. We used the mir pixel format to inform
> the Mir compositor that blending is not required in that case - a nice
> optimisation.

I don't see that in the RS code, but I'm still learning my way around it.

[Gerry Boland (gerboland)]

And the obvious question: can we jump to using non-deprecated APIs in one go?

[Alan Griffiths (alan-griffiths)]

> And the obvious question: can we jump to using non-deprecated APIs in one go?

It depends.

The reason for the current situation being that we can't introduce the intended "surface" APIs until we delete the current ones.

The RS APIs are a temporary workaround to enable the "surface" functionality without a name clash.

If we decide not to rename MirRenderSurface => MirSurface in 1.0 we can just remove the deprecation of render surface.

[Gerry Boland (gerboland)]

+ // Assume that the buffer size matches the surface size at creation time
I'd rather not make that assumption. Does the new API loose this functionality?

[Gerry Boland (gerboland)]

+bool UbuntuSurface::needsRepaint() const
+{
+ return mNeedsRepaint;

This can totally go away AFAICS, since this changes the buffer "ownership" drastically. Before when we got a surface resize event, we had to keep swapping buffers until we got one sized at the new size - so we had to keep force repainting until that happened. Now since Qt owns the buffer, it can resize immediately.

Removing all the needsRepaint stuff also makes resizing smoother IMO in my tests here.

[Gerry Boland (gerboland)]

overall looks ok, I just
- miss the pixel format optimisation
- would ultimately like to remove any deprecated api use (but not necessarily in this MP)

[Alberto Aguirre (albaguirre)]

> I have a question about how pixel formats work with the newer Mir API. I see
> you've removed code where Qt could set a desired pixel format on the mir
> surface - is this feature impossible to replicate?
>
> This was done because sometimes the EGL config chosen may have an alpha buffer
> enabled, even if Qt doesn't need it. We used the mir pixel format to inform
> the Mir compositor that blending is not required in that case - a nice
> optimisation.

The pixel format for EGL rendering is now set through the chosen EGLConfig. The new mir mesa path will actually obey the pixel format selected.

If you want to use mir_pixel_format enums, you can specify a EGL_NATIVE_VISUAL_ID in the attribs list during eglChooseConfig and it'll be respected.

[Alberto Aguirre (albaguirre)]

> + // Assume that the buffer size matches the surface size at creation time
> I'd rather not make that assumption. Does the new API loose this
> functionality?

If the size chosen by the server is changed, it now gets delivered as a resize event as long as the event handler was registered through the window spec. This means that the same resizing logic is applied.

I tested this slightly by using the fullscreen window manager option in mir's demo server.

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:396
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/223/
Executed test runs:
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build/4923/console
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/4951
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=xenial+overlay/4759/console
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=zesty/4759
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=zesty/4759/artifact/output/*zip*/output.zip
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=xenial+overlay/4759/console
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=zesty/4759
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=zesty/4759/artifact/output/*zip*/output.zip
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=xenial+overlay/4759/console
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=zesty/4759
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=zesty/4759/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/223/rebuild

review: Needs Fixing (continuous-integration)

[Alberto Aguirre (albaguirre)]

> overall looks ok, I just
> - miss the pixel format optimisation
I'll look into that, I should just be able to use EGL_NATIVE_VISUAL_ID.

[Alberto Aguirre (albaguirre)]

> Looks mostly sensible, but I need to get more familiar with qtubuntu to be
> sure.
>
> Can we aim to land lp:~alan-griffiths/mir/deprecation-macros and use
> -DMIR_DEPRECATE_RENDERSURFACES=0 - or building against trunk Mir an issue?

Shouldn't be an issue on a local machine, but qtubuntu's CI would be.

[lp:~albaguirre/qtubuntu/use-mir-rs-api]

397. By Alberto Aguirre on 2017-05-27

Cleanup #pragmas and unneeded repaints when resizing.

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:397
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/224/
Executed test runs:
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build/4924/console
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/4952
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=xenial+overlay/4760/console
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=zesty/4760/console
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=xenial+overlay/4760/console
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=zesty/4760/console
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=xenial+overlay/4760/console
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=zesty/4760/console

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/224/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

397. By Alberto Aguirre on 2017-05-27

Cleanup #pragmas and unneeded repaints when resizing.

396. By Alberto Aguirre on 2017-04-06

Avoid using mir_window_get_parameters, it will be deprecated

395. By Alberto Aguirre on 2017-04-05

Remove mir_event_type_key and mir_event_type_motion as they are deprecated.

394. By Alberto Aguirre on 2017-04-05

Use MirRenderSurface for pixmap cursors.

Creating buffer streams directly will be deprecated in mir in the near future, instead use render surfaces.

393. By Alberto Aguirre on 2017-04-05

Update resizing now that client can drive the buffer size through mir_render_surface_set_size.

392. By Alberto Aguirre on 2017-03-31

Avoid use of deprecated mir EGL related apis.

With the new mesa update, the EGLNativeDisplayType is MirConnection and the EGLNativeWindowType is a MirRenderSurface.
Ignore deprecation warnings on use of MirRenderSurface - its "deprecated" because it'll be renamed in mir 1.0.

=== modified file 'debian/control'
--- debian/control	2017-01-10 06:41:48 +0000
+++ debian/control	2017-05-27 01:33:26 +0000
@@ -4,14 +4,13 @@
 Build-Depends: debhelper (>= 9),
                libatspi2.0-dev,
                libcontent-hub-dev (>= 0.2),
-               libegl1-mesa-dev,
+               libegl1-mesa-dev (>= 17.0.2),
                libfontconfig1-dev,
                libfreetype6-dev,
-               libgles2-mesa-dev,
+               libgles2-mesa-dev (>= 17.0.2),
                libglib2.0-dev,
                libinput-dev,
-               libmirclient-dev (>= 0.25.0),
-               libmirclient-debug-extension-dev,
+               libmirclient-dev (>= 0.26.1),
                libmtdev-dev,
                libubuntu-application-api-dev (>= 2.9.0),
                libudev-dev,
 
=== modified file 'src/ubuntumirclient/qmirclientcursor.cpp'
--- src/ubuntumirclient/qmirclientcursor.cpp	2017-03-28 17:12:13 +0000
+++ src/ubuntumirclient/qmirclientcursor.cpp	2017-05-27 01:33:26 +0000
@@ -138,11 +138,17 @@
 {
 public:
     CursorWindowSpec(MirConnection *connection, const char *name)
-    :  spec(mir_create_window_spec(connection))
+    :  CursorWindowSpec(connection)
     {
         mir_window_spec_set_cursor_name(spec, name);
     }
 
+    CursorWindowSpec(MirConnection *connection, MirRenderSurface *surface, int hotspotX, int hotspotY)
+    :  CursorWindowSpec(connection)
+    {
+        mir_window_spec_set_cursor_render_surface(spec, surface, hotspotX, hotspotY);
+    }
+
     ~CursorWindowSpec()
     {
         mir_window_spec_release(spec);
@@ -153,8 +159,60 @@
         mir_window_apply_spec(window, spec);
     }
 private:
+    CursorWindowSpec(MirConnection *connection) : spec(mir_create_window_spec(connection)) {}
     MirWindowSpec * const spec;
 };
+
+class BufferStream
+{
+public:
+    BufferStream(MirRenderSurface *surface, int width, int height)
+    : stream(mir_render_surface_get_buffer_stream(surface, width, height, mir_pixel_format_argb_8888))
+    {
+    }
+
+    void draw(QImage const& image)
+    {
+        MirGraphicsRegion region;
+        const bool validRegion = mir_buffer_stream_get_graphics_region(stream, &region);
+        if (!validRegion)
+            throw std::runtime_error("Could not get graphics region to draw into");
+
+        auto regionLine = region.vaddr;
+        Q_ASSERT(image.bytesPerLine() <= region.stride);
+
+        for (int i = 0; i < image.height(); ++i) {
+           memcpy(regionLine, image.scanLine(i), image.bytesPerLine());
+           regionLine += region.stride;
+        }
+        mir_buffer_stream_swap_buffers_sync(stream);
+    }
+
+private:
+    MirBufferStream * const stream;
+};
+
+class RenderSurface
+{
+public:
+    RenderSurface(MirConnection *connection, int width, int height)
+    : surface(mir_connection_create_render_surface_sync(connection, width, height)),
+      stream(surface, width, height)
+    {
+        if (!mir_render_surface_is_valid(surface)) {
+            throw std::runtime_error(mir_render_surface_get_error_message(surface));
+        }
+    }
+
+    ~RenderSurface() { mir_render_surface_release(surface); }
+    operator MirRenderSurface *() const { return surface; }
+    void draw(QImage const& image) { stream.draw(image); }
+
+private:
+    MirRenderSurface * const surface;
+    BufferStream stream;
+};
+
 } // anonymous namespace
 
 void QMirClientCursor::changeCursor(QCursor *windowCursor, QWindow *window)
@@ -196,30 +254,15 @@
         image = image.convertToFormat(QImage::Format_ARGB32);
     }
 
-    MirBufferStream *bufferStream = mir_connection_create_buffer_stream_sync(mConnection,
-            image.width(), image.height(), mir_pixel_format_argb_8888, mir_buffer_usage_software);
-
-    {
-        MirGraphicsRegion region;
-        mir_buffer_stream_get_graphics_region(bufferStream, &region);
-
-        char *regionLine = region.vaddr;
-        Q_ASSERT(image.bytesPerLine() <= region.stride);
-        for (int i = 0; i < image.height(); ++i) {
-            memcpy(regionLine, image.scanLine(i), image.bytesPerLine());
-            regionLine += region.stride;
-        }
-    }
-
-    mir_buffer_stream_swap_buffers_sync(bufferStream);
-
-    {
-        auto configuration = mir_cursor_configuration_from_buffer_stream(bufferStream, cursor.hotSpot().x(), cursor.hotSpot().y());
-        mir_window_configure_cursor(window, configuration);
-        mir_cursor_configuration_destroy(configuration);
-    }
-
-    mir_buffer_stream_release_sync(bufferStream);
+    try {
+        RenderSurface surface(mConnection, image.width(), image.height());
+        surface.draw(image);
+
+        CursorWindowSpec spec(mConnection, surface, cursor.hotSpot().x(), cursor.hotSpot().y());
+        spec.apply(window);
+    } catch(std::exception const& e) {
+        qWarning("Error applying pixmap cursor: %s", e.what());
+    }
 }
 
 void QMirClientCursor::applyDefaultCursorConfiguration(MirWindow *window)
 
=== modified file 'src/ubuntumirclient/qmirclientinput.cpp'
--- src/ubuntumirclient/qmirclientinput.cpp	2017-02-21 18:24:45 +0000
+++ src/ubuntumirclient/qmirclientinput.cpp	2017-05-27 01:33:26 +0000
@@ -232,10 +232,6 @@
 {
     switch (t)
     {
-    case mir_event_type_key:
-        return "key";
-    case mir_event_type_motion:
-        return "motion";
     case mir_event_type_window:
         return "window";
     case mir_event_type_resize:
 
=== modified file 'src/ubuntumirclient/qmirclientintegration.cpp'
--- src/ubuntumirclient/qmirclientintegration.cpp	2017-04-04 00:46:48 +0000
+++ src/ubuntumirclient/qmirclientintegration.cpp	2017-05-27 01:33:26 +0000
@@ -130,8 +130,7 @@
     QSurfaceFormat::setDefaultFormat(defaultFormat);
 
     // Initialize EGL.
-    mEglNativeDisplay = mir_connection_get_egl_native_display(mMirConnection);
-    ASSERT((mEglDisplay = eglGetDisplay(mEglNativeDisplay)) != EGL_NO_DISPLAY);
+    ASSERT((mEglDisplay = eglGetDisplay(mMirConnection)) != EGL_NO_DISPLAY);
     ASSERT(eglInitialize(mEglDisplay, nullptr, nullptr) == EGL_TRUE);
 
     // Has debug mode been requsted, either with "-testability" switch or QT_LOAD_TESTABILITY env var
 
=== modified file 'src/ubuntumirclient/qmirclientintegration.h'
--- src/ubuntumirclient/qmirclientintegration.h	2017-03-15 09:21:47 +0000
+++ src/ubuntumirclient/qmirclientintegration.h	2017-05-27 01:33:26 +0000
@@ -89,7 +89,7 @@
     // New methods.
     MirConnection *mirConnection() const { return mMirConnection; }
     EGLDisplay eglDisplay() const { return mEglDisplay; }
-    EGLNativeDisplayType eglNativeDisplay() const { return mEglNativeDisplay; }
+    EGLNativeDisplayType eglNativeDisplay() const { return mMirConnection; }
     QMirClientAppStateController *appStateController() const { return mAppStateController.data(); }
     QMirClientScreenObserver *screenObserver() const { return mScreenObserver.data(); }
     QMirClientDebugExtension *debugExtension() const { return mDebugExtension.data(); }
@@ -125,7 +125,6 @@
 
     // EGL related
     EGLDisplay mEglDisplay{EGL_NO_DISPLAY};
-    EGLNativeDisplayType mEglNativeDisplay;
 };
 
 #endif // QMIRCLIENTINTEGRATION_H
 
=== modified file 'src/ubuntumirclient/qmirclientwindow.cpp'
--- src/ubuntumirclient/qmirclientwindow.cpp	2017-03-28 17:12:13 +0000
+++ src/ubuntumirclient/qmirclientwindow.cpp	2017-05-27 01:33:26 +0000
@@ -75,12 +75,6 @@
 
 using Spec = std::unique_ptr<MirWindowSpec, MirSpecDeleter>;
 
-EGLNativeWindowType nativeWindowFor(MirWindow *surf)
-{
-    auto stream = mir_window_get_buffer_stream(surf);
-    return reinterpret_cast<EGLNativeWindowType>(mir_buffer_stream_get_egl_native_window(stream));
-}
-
 const char *qtWindowStateToStr(Qt::WindowState state)
 {
     switch (state) {
@@ -114,24 +108,6 @@
     Q_UNREACHABLE();
 }
 
-const char *mirPixelFormatToStr(MirPixelFormat pixelFormat)
-{
-    switch (pixelFormat) {
-    case mir_pixel_format_invalid:   return "invalid";
-    case mir_pixel_format_abgr_8888: return "ABGR8888";
-    case mir_pixel_format_xbgr_8888: return "XBGR8888";
-    case mir_pixel_format_argb_8888: return "ARGB8888";
-    case mir_pixel_format_xrgb_8888: return "XRGB8888";
-    case mir_pixel_format_bgr_888:   return "BGR888";
-    case mir_pixel_format_rgb_888:   return "RGB888";
-    case mir_pixel_format_rgb_565:   return "RGB565";
-    case mir_pixel_format_rgba_5551: return "RGBA5551";
-    case mir_pixel_format_rgba_4444: return "RGBA4444";
-    case mir_pixel_formats:          Q_UNREACHABLE();
-    }
-    Q_UNREACHABLE();
-}
-
 const char *mirWindowTypeToStr(MirWindowType type)
 {
     switch (type) {
@@ -221,12 +197,23 @@
     return requiresParent(qtWindowTypeToMirWindowType(type));
 }
 
-Spec makeSurfaceSpec(QWindow *window, MirPixelFormat pixelFormat, QMirClientWindow *parentWindowHandle,
-                     MirConnection *connection)
-{
-    const auto geometry = window->geometry();
-    const int width = geometry.width() > 0 ? geometry.width() : 1;
-    const int height = geometry.height() > 0 ? geometry.height() : 1;
+QRect geometryFor(QWindow *window)
+{
+    auto geometry = window->geometry();
+    if (geometry.width() < 1)
+        geometry.setWidth(1);
+    if (geometry.height() < 1)
+        geometry.setHeight(1);
+
+    return geometry;
+}
+
+Spec makeWindowSpec(QWindow *window, QMirClientWindow *parentWindowHandle,
+                    MirRenderSurface *surface, MirConnection *connection)
+{
+    const auto geometry = geometryFor(window);
+    const int width = geometry.width();
+    const int height = geometry.height();
     auto type = qtWindowTypeToMirWindowType(window->type());
 
     MirRectangle location{geometry.x(), geometry.y(), 0, 0};
@@ -272,7 +259,6 @@
         // There's no helper function for satellite windows. Guess they're not very popular
         spec = Spec{mir_create_window_spec(connection)};
         mir_window_spec_set_type(spec.get(), mir_window_type_satellite);
-        mir_window_spec_set_buffer_usage(spec.get(), mir_buffer_usage_hardware);
         mir_window_spec_set_parent(spec.get(), parent);
         mir_window_spec_set_width(spec.get(), width);
         mir_window_spec_set_height(spec.get(), height);
@@ -282,9 +268,9 @@
         break;
     }
 
-    mir_window_spec_set_pixel_format(spec.get(), pixelFormat);
+    mir_window_spec_add_render_surface(spec.get(), surface, width, height, 0, 0);
 
-    qCDebug(mirclient, "makeSurfaceSpec(window=%p): %s spec (type=0x%x, position=(%d, %d)px, size=(%dx%d)px)",
+    qCDebug(mirclient, "makeWindowSpec(window=%p): %s spec (type=0x%x, position=(%d, %d)px, size=(%dx%d)px)",
             window, mirWindowTypeToStr(type), window->type(), location.left, location.top, width, height);
 
     return spec;
@@ -331,14 +317,29 @@
     mir_window_spec_set_input_shape(spec, rects, count);
 }
 
+MirRenderSurface *createMirSurface(QWindow *window, MirConnection *connection)
+{
+    const auto geometry = geometryFor(window);
+    const int width = geometry.width();
+    const int height = geometry.height();
+
+    auto surface = mir_connection_create_render_surface_sync(connection, width, height);
+    if (!mir_render_surface_is_valid(surface))
+    {
+        auto errorMsg = mir_render_surface_get_error_message(surface);
+        qFatal("Failed to create mir surface: %s", errorMsg);
+    }
+    return surface;
+}
+
 MirWindow *createMirWindow(QWindow *window, int mirOutputId, QMirClientWindow *parentWindowHandle,
-                             MirPixelFormat pixelFormat, MirConnection *connection,
-                             MirWindowEventCallback inputCallback, void *inputContext)
+                           MirRenderSurface *surface, MirConnection *connection,
+                           MirWindowEventCallback eventCallback, void *context)
 {
-    auto spec = makeSurfaceSpec(window, pixelFormat, parentWindowHandle, connection);
+    auto spec = makeWindowSpec(window, parentWindowHandle, surface, connection);
 
     // Install event handler as early as possible
-    mir_window_spec_set_event_handler(spec.get(), inputCallback, inputContext);
+    mir_window_spec_set_event_handler(spec.get(), eventCallback, context);
 
     const auto title = window->title().toUtf8();
     mir_window_spec_set_name(spec.get(), title.constData());
@@ -358,9 +359,14 @@
         mir_window_spec_set_state(spec.get(), mir_window_state_hidden);
     }
 
-    auto surface = mir_create_window_sync(spec.get());
-    Q_ASSERT(mir_window_is_valid(surface));
-    return surface;
+    auto mirWindow = mir_create_window_sync(spec.get());
+    if (!mir_window_is_valid(mirWindow))
+    {
+        auto errorMsg = mir_window_get_error_message(mirWindow);
+        qFatal("Failed to create mir window: %s", errorMsg);
+    }
+
+    return mirWindow;
 }
 
 QMirClientWindow *getParentIfNecessary(QWindow *window, QMirClientInput *input)
@@ -377,18 +383,6 @@
     return parentWindowHandle;
 }
 
-MirPixelFormat disableAlphaBufferIfPossible(MirPixelFormat pixelFormat)
-{
-    switch (pixelFormat) {
-    case mir_pixel_format_abgr_8888:
-        return mir_pixel_format_xbgr_8888;
-    case mir_pixel_format_argb_8888:
-        return mir_pixel_format_xrgb_8888;
-    default: // can do nothing, leave it alone
-        return pixelFormat;
-    }
-}
-
 // FIXME - in order to work around https://bugs.launchpad.net/mir/+bug/1346633
 // we need to guess the panel height (3GU)
 int panelHeight()
@@ -426,7 +420,6 @@
 
     void onSwapBuffersDone();
     void handleSurfaceResized(int width, int height);
-    int needsRepaint() const;
 
     MirWindowState state() const { return mir_window_get_state(mMirWindow); }
     void setState(MirWindowState state);
@@ -448,7 +441,7 @@
     QString persistentSurfaceId();
 
 private:
-    static void surfaceEventCallback(MirWindow* surface, const MirEvent *event, void* context);
+    static void windowEventCallback(MirWindow* surface, const MirEvent *event, void* context);
     void postEvent(const MirEvent *event);
 
     QWindow * const mWindow;
@@ -458,14 +451,12 @@
     QMirClientWindow * mParentWindowHandle{nullptr};
 
     MirWindow* mMirWindow;
+    MirRenderSurface* mMirSurface;
     const EGLDisplay mEglDisplay;
     EGLSurface mEglSurface;
 
-    bool mNeedsRepaint;
     bool mParented;
-    QSize mBufferSize;
     QSurfaceFormat mFormat;
-    MirPixelFormat mPixelFormat;
 
     QMutex mTargetSizeMutex;
     QSize mTargetSize;
@@ -479,7 +470,6 @@
     , mInput(input)
     , mConnection(connection)
     , mEglDisplay(display)
-    , mNeedsRepaint(false)
     , mParented(mWindow->transientParent() || mWindow->parent())
     , mFormat(mWindow->requestedFormat())
     , mShellChrome(mWindow->flags() & LowChromeWindowHint ? mir_shell_chrome_low : mir_shell_chrome_normal)
@@ -506,50 +496,33 @@
 
     mFormat = q_glFormatFromConfig(display, config, mFormat);
 
-    // Have Mir decide the pixel format most suited to the chosen EGLConfig. This is the only way
-    // Mir will know what EGLConfig has been chosen - it cannot deduce it from the buffers.
-    mPixelFormat = mir_connection_get_egl_pixel_format(connection, display, config);
-    // But the chosen EGLConfig might have an alpha buffer enabled, even if not requested by the client.
-    // If that's the case, try to edit the chosen pixel format in order to disable the alpha buffer.
-    // This is an optimization for the compositor, as it can avoid blending this surface.
-    if (mWindow->requestedFormat().alphaBufferSize() < 0) {
-        mPixelFormat = disableAlphaBufferIfPossible(mPixelFormat);
-    }
-
     const auto outputId = static_cast<QMirClientScreen *>(mWindow->screen()->handle())->mirOutputId();
 
     mParentWindowHandle = getParentIfNecessary(mWindow, input);
 
-    mMirWindow = createMirWindow(mWindow, outputId, mParentWindowHandle, mPixelFormat, connection, surfaceEventCallback, this);
-    mEglSurface = eglCreateWindowSurface(mEglDisplay, config, nativeWindowFor(mMirWindow), nullptr);
+    mMirSurface = createMirSurface(mWindow, connection);
+    mMirWindow = createMirWindow(mWindow, outputId, mParentWindowHandle, mMirSurface, connection, windowEventCallback, this);
+    mEglSurface = eglCreateWindowSurface(mEglDisplay, config, reinterpret_cast<EGLNativeWindowType>(mMirSurface), nullptr);
 
     mNeedsExposeCatchup = mir_window_get_visibility(mMirWindow) == mir_window_visibility_occluded;
 
-    // Window manager can give us a final size different from what we asked for
-    // so let's check what we ended up getting
-    MirWindowParameters parameters;
-    mir_window_get_parameters(mMirWindow, &parameters);
-
+    // Assume that the buffer size matches the surface size at creation time
     auto geom = mWindow->geometry();
-    geom.setWidth(parameters.width);
-    geom.setHeight(parameters.height);
-
-    // Assume that the buffer size matches the surface size at creation time
-    mBufferSize = geom.size();
-    platformWindow->QPlatformWindow::setGeometry(geom);
-    QWindowSystemInterface::handleGeometryChange(mWindow, geom);
 
     qCDebug(mirclient) << "Created surface with geometry:" << geom << "title:" << mWindow->title();
     qCDebug(mirclientGraphics)
                        << "Requested format:" << mWindow->requestedFormat()
-                       << "\nActual format:" << mFormat
-                       << "with associated Mir pixel format:" << mirPixelFormatToStr(mPixelFormat);
+                       << "\nActual format:" << mFormat;
 }
 
 UbuntuSurface::~UbuntuSurface()
 {
-    if (mEglSurface != EGL_NO_SURFACE)
+    if (mEglSurface != EGL_NO_SURFACE) {
         eglDestroySurface(mEglDisplay, mEglSurface);
+    }
+    if (mMirSurface) {
+        mir_render_surface_release(mMirSurface);
+    }
     if (mMirWindow) {
         mir_window_release_sync(mMirWindow);
     }
@@ -606,30 +579,23 @@
 {
     QMutexLocker lock(&mTargetSizeMutex);
 
-    // mir's resize event is mainly a signal that we need to redraw our content. We use the
-    // width/height as identifiers to figure out if this is the latest surface resize event
-    // that has posted, discarding any old ones. This avoids issuing too many redraw events.
-    // see TODO in postEvent as the ideal way we should handle this.
-    // The actual buffer size may or may have not changed at this point, so let the rendering
-    // thread drive the window geometry updates.
-    mNeedsRepaint = mTargetSize.width() == width && mTargetSize.height() == height;
-}
-
-int UbuntuSurface::needsRepaint() const
-{
-    if (mNeedsRepaint) {
-        if (mTargetSize != mBufferSize) {
-            //If the buffer hasn't changed yet, we need at least two redraws,
-            //once to get the new buffer size and propagate the geometry changes
-            //and the second to redraw the content at the new size
-            return 2;
-        } else {
-            // The buffer size has already been updated so we only need one redraw
-            // to render at the new size
-            return 1;
-        }
+    // There could have been a flurry of resize events, only process the latest event
+    const bool needsResize = mTargetSize.width() == width && mTargetSize.height() == height;
+    if (needsResize) {
+        // Resize the buffers
+        mir_render_surface_set_size(mMirSurface, width, height);
+
+        //Resize the window
+        Spec spec{mir_create_window_spec(mConnection)};
+        mir_window_spec_add_render_surface(spec.get(), mMirSurface, width, height, 0, 0);
+        mir_window_apply_spec(mMirWindow, spec.get());
+
+        QRect newGeometry = mPlatformWindow->geometry();
+        newGeometry.setSize(mTargetSize);
+
+        mPlatformWindow->QPlatformWindow::setGeometry(newGeometry);
+        QWindowSystemInterface::handleGeometryChange(mWindow, newGeometry);
     }
-    return 0;
 }
 
 void UbuntuSurface::setState(MirWindowState state)
@@ -653,35 +619,13 @@
     static int sFrameNumber = 0;
     ++sFrameNumber;
 
-    EGLint eglSurfaceWidth = -1;
-    EGLint eglSurfaceHeight = -1;
-    eglQuerySurface(mEglDisplay, mEglSurface, EGL_WIDTH, &eglSurfaceWidth);
-    eglQuerySurface(mEglDisplay, mEglSurface, EGL_HEIGHT, &eglSurfaceHeight);
-
-    const bool validSize = eglSurfaceWidth > 0 && eglSurfaceHeight > 0;
-
-    if (validSize && (mBufferSize.width() != eglSurfaceWidth || mBufferSize.height() != eglSurfaceHeight)) {
-
-        qCDebug(mirclientBufferSwap, "onSwapBuffersDone(window=%p) [%d] - size changed (%d, %d) => (%d, %d)",
-               mWindow, sFrameNumber, mBufferSize.width(), mBufferSize.height(), eglSurfaceWidth, eglSurfaceHeight);
-
-        mBufferSize.rwidth() = eglSurfaceWidth;
-        mBufferSize.rheight() = eglSurfaceHeight;
-
-        QRect newGeometry = mPlatformWindow->geometry();
-        newGeometry.setSize(mBufferSize);
-
-        mPlatformWindow->QPlatformWindow::setGeometry(newGeometry);
-        QWindowSystemInterface::handleGeometryChange(mWindow, newGeometry);
-    } else {
-        qCDebug(mirclientBufferSwap, "onSwapBuffersDone(window=%p) [%d] - buffer size (%d,%d)",
-               mWindow, sFrameNumber, mBufferSize.width(), mBufferSize.height());
-    }
+    qCDebug(mirclientBufferSwap, "onSwapBuffersDone(window=%p) [%d]",
+            mWindow, sFrameNumber);
 }
 
-void UbuntuSurface::surfaceEventCallback(MirWindow *surface, const MirEvent *event, void* context)
+void UbuntuSurface::windowEventCallback(MirWindow *window, const MirEvent *event, void* context)
 {
-    Q_UNUSED(surface);
+    Q_UNUSED(window);
     Q_ASSERT(context != nullptr);
 
     auto s = static_cast<UbuntuSurface *>(context);
@@ -692,9 +636,8 @@
 {
     const auto eventType = mir_event_get_type(event);
     if (mir_event_type_resize == eventType) {
-        // TODO: The current event queue just accumulates all resize events;
-        // It would be nicer if we could update just one event if that event has not been dispatched.
-        // As a workaround, we use the width/height as an identifier of this latest event
+        // The event queue just accumulates all resize events;
+        // Use the width and height as an identifier of this latest event
         // so the event handler (handleSurfaceResized) can discard/ignore old ones.
         const auto resizeEvent = mir_event_get_resize_event(event);
         const auto width =  mir_resize_event_get_width(resizeEvent);
@@ -786,19 +729,6 @@
     qCDebug(mirclient, "handleSurfaceResize(window=%p, size=(%dx%d)px", window(), width, height);
 
     mSurface->handleSurfaceResized(width, height);
-
-    // This resize event could have occurred just after the last buffer swap for this window.
-    // This means the client may still be holding a buffer with the older size. The first redraw call
-    // will then render at the old size. After swapping the client now will get a new buffer with the
-    // updated size but it still needs re-rendering so another redraw may be needed.
-    // A mir API to drop the currently held buffer would help here, so that we wouldn't have to redraw twice
-    auto const numRepaints = mSurface->needsRepaint();
-    lock.unlock();
-    qCDebug(mirclient, "handleSurfaceResize(window=%p) redraw %d times", window(), numRepaints);
-    for (int i = 0; i < numRepaints; i++) {
-        qCDebug(mirclient, "handleSurfaceResize(window=%p) repainting size=(%dx%d)dp", window(), geometry().size().width(), geometry().size().height());
-        QWindowSystemInterface::handleExposeEvent(window(), QRect(QPoint(), geometry().size()));
-    }
 }
 
 void QMirClientWindow::handleSurfaceExposeChange(bool exposed)
 
=== modified file 'src/ubuntumirclient/ubuntumirclient.pro'
--- src/ubuntumirclient/ubuntumirclient.pro	2017-03-29 13:39:50 +0000
+++ src/ubuntumirclient/ubuntumirclient.pro	2017-05-27 01:33:26 +0000
@@ -6,7 +6,7 @@
 
 CONFIG += plugin no_keywords qpa/genericunixfontdatabase
 
-DEFINES += MESA_EGL_NO_X11_HEADERS
+DEFINES += MESA_EGL_NO_X11_HEADERS MIR_DEPRECATE_RENDERSURFACES=0 MIR_ENABLE_DEPRECATIONS=0
 # CONFIG += c++11 # only enables C++0x
 QMAKE_CXXFLAGS += -fvisibility=hidden -fvisibility-inlines-hidden -std=c++11 -Werror -Wall
 QMAKE_LFLAGS += -std=c++11 -Wl,-no-undefined