Merge lp:~dandrader/qtubuntu/rasterGLSurface into lp:qtubuntu

[Daniel d'Andrada]

Add support for QQuickWidgets

- Advertise RasterGLSurface capability

- Implement proper offscreen rendering support using EGL pixel buffers.

- Don't create mir surfaces for Qt::Desktop QWindows. Proper
implementation still pending

To test:
Build & run lp:~dandrader/+junk/qwidget

If you can see the "Hello World" in a red rect, it's working.

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

PASSED: Continuous integration, rev:330
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/93/
Executed test runs:
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build/2209
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/2237
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/2143
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/2143
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-1-sourcepkg/release=yakkety/2143
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=vivid+overlay/2134
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=vivid+overlay/2134/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=xenial+overlay/2134
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=xenial+overlay/2134/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=yakkety/2134
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=yakkety/2134/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=vivid+overlay/2134
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=vivid+overlay/2134/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=xenial+overlay/2134
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=xenial+overlay/2134/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=yakkety/2134
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=yakkety/2134/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=vivid+overlay/2134
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=vivid+overlay/2134/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=xenial+overlay/2134
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=xenial+overlay/2134/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=yakkety/2134
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=yakkety/2134/artifact/output/*zip*/output.zip

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

review: Approve (continuous-integration)

Unmerged revisions

330. By Daniel d'Andrada on 2016-07-04

Add support for QQuickWidgets

- Advertise RasterGLSurface capability

- Implement proper offscreen rendering support using EGL pixel buffers.

- Don't create mir surfaces for Qt::Desktop QWindows. Proper
implementation still pending

329. By Daniel d'Andrada on 2016-07-01

merge lp:~gerboland/qtubuntu/eglconvenience-retry

=== modified file 'README'
--- README	2016-06-20 08:37:56 +0000
+++ README	2016-07-04 17:59:30 +0000
@@ -23,13 +23,10 @@
     $ qmlscene -platform ubuntumirclient Foo.qml
     $ QT_QPA_PLATFORM=ubuntumirclient qmlscene Foo.qml
 
-  The QPA plugins expose the following environment variables:
-
-    QTUBUNTU_SWAPINTERVAL: Specifies the required swap interval as an
-                           integer. 1 by default.
-
-    QTUBUNTU_MULTISAMPLE: Enables multisampling with using 4 samples
-                          per fragment.
+  This QPA plugin exposes the following environment variables:
+
+    QT_QPA_EGLFS_SWAPINTERVAL: Specifies the required swap interval as an
+                               integer. 1 by default.
 
     QTUBUNTU_NO_THREADED_OPENGL: Disables QtQuick threaded OpenGL
                                  rendering.
@@ -51,6 +48,8 @@
   * ubuntumirclient.swapBuffers - Messages related to surface buffer swapping.
   * ubuntumirclient             - For all other messages.
 
+  The QT_QPA_EGLFS_DEBUG environment variable prints a little more information
+  from Qt's internals.
 
 4. Building
 -----------

=== added file 'src/ubuntumirclient/desktopwindow.cpp'
--- src/ubuntumirclient/desktopwindow.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntumirclient/desktopwindow.cpp	2016-07-04 17:59:30 +0000
@@ -0,0 +1,26 @@
+/*
+ * 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 "desktopwindow.h"
+
+// local
+#include "logging.h"
+
+UbuntuDesktopWindow::UbuntuDesktopWindow(QWindow *window)
+    : QPlatformWindow(window)
+{
+    qCDebug(ubuntumirclient, "UbuntuDesktopWindow(window=%p)", window);
+}

=== added file 'src/ubuntumirclient/desktopwindow.h'
--- src/ubuntumirclient/desktopwindow.h	1970-01-01 00:00:00 +0000
+++ src/ubuntumirclient/desktopwindow.h	2016-07-04 17:59:30 +0000
@@ -0,0 +1,29 @@
+/*
+ * 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 UBUNTU_DESKTOP_WINDOW_H
+#define UBUNTU_DESKTOP_WINDOW_H
+
+#include <qpa/qplatformwindow.h>
+
+// TODO Implement it. For now it's just an empty, dummy class.
+class UbuntuDesktopWindow : public QPlatformWindow
+{
+public:
+    UbuntuDesktopWindow(QWindow*);
+};
+
+#endif // UBUNTU_DESKTOP_WINDOW_H

=== modified file 'src/ubuntumirclient/glcontext.cpp'
--- src/ubuntumirclient/glcontext.cpp	2016-06-20 08:37:56 +0000
+++ src/ubuntumirclient/glcontext.cpp	2016-07-04 17:59:30 +0000
@@ -16,7 +16,6 @@
 
 #include "glcontext.h"
 #include "logging.h"
-#include "offscreensurface.h"
 #include "window.h"
 
 #include <QOpenGLFramebufferObject>
@@ -25,58 +24,12 @@
 
 namespace {
 
-void printOpenGLESConfig() {
-    static bool once = true;
-    if (once) {
-        const char* string = (const char*) glGetString(GL_VENDOR);
-        qCDebug(ubuntumirclient, "OpenGL ES vendor: %s", string);
-        string = (const char*) glGetString(GL_RENDERER);
-        qCDebug(ubuntumirclient, "OpenGL ES renderer: %s", string);
-        string = (const char*) glGetString(GL_VERSION);
-        qCDebug(ubuntumirclient, "OpenGL ES version: %s", string);
-        string = (const char*) glGetString(GL_SHADING_LANGUAGE_VERSION);
-        qCDebug(ubuntumirclient, "OpenGL ES Shading Language version: %s", string);
-        string = (const char*) glGetString(GL_EXTENSIONS);
-        qCDebug(ubuntumirclient, "OpenGL ES extensions: %s", string);
-        once = false;
-    }
-}
-
-void printEglConfig(EGLDisplay display, EGLConfig config) {
+void printEglConfig(EGLDisplay display, EGLConfig config)
+{
     Q_ASSERT(display != EGL_NO_DISPLAY);
     Q_ASSERT(config != nullptr);
 
-    static const struct { const EGLint attrib; const char* name; } kAttribs[] = {
-        { EGL_BUFFER_SIZE, "EGL_BUFFER_SIZE" },
-        { EGL_ALPHA_SIZE, "EGL_ALPHA_SIZE" },
-        { EGL_BLUE_SIZE, "EGL_BLUE_SIZE" },
-        { EGL_GREEN_SIZE, "EGL_GREEN_SIZE" },
-        { EGL_RED_SIZE, "EGL_RED_SIZE" },
-        { EGL_DEPTH_SIZE, "EGL_DEPTH_SIZE" },
-        { EGL_STENCIL_SIZE, "EGL_STENCIL_SIZE" },
-        { EGL_CONFIG_CAVEAT, "EGL_CONFIG_CAVEAT" },
-        { EGL_CONFIG_ID, "EGL_CONFIG_ID" },
-        { EGL_LEVEL, "EGL_LEVEL" },
-        { EGL_MAX_PBUFFER_HEIGHT, "EGL_MAX_PBUFFER_HEIGHT" },
-        { EGL_MAX_PBUFFER_PIXELS, "EGL_MAX_PBUFFER_PIXELS" },
-        { EGL_MAX_PBUFFER_WIDTH, "EGL_MAX_PBUFFER_WIDTH" },
-        { EGL_NATIVE_RENDERABLE, "EGL_NATIVE_RENDERABLE" },
-        { EGL_NATIVE_VISUAL_ID, "EGL_NATIVE_VISUAL_ID" },
-        { EGL_NATIVE_VISUAL_TYPE, "EGL_NATIVE_VISUAL_TYPE" },
-        { EGL_SAMPLES, "EGL_SAMPLES" },
-        { EGL_SAMPLE_BUFFERS, "EGL_SAMPLE_BUFFERS" },
-        { EGL_SURFACE_TYPE, "EGL_SURFACE_TYPE" },
-        { EGL_TRANSPARENT_TYPE, "EGL_TRANSPARENT_TYPE" },
-        { EGL_TRANSPARENT_BLUE_VALUE, "EGL_TRANSPARENT_BLUE_VALUE" },
-        { EGL_TRANSPARENT_GREEN_VALUE, "EGL_TRANSPARENT_GREEN_VALUE" },
-        { EGL_TRANSPARENT_RED_VALUE, "EGL_TRANSPARENT_RED_VALUE" },
-        { EGL_BIND_TO_TEXTURE_RGB, "EGL_BIND_TO_TEXTURE_RGB" },
-        { EGL_BIND_TO_TEXTURE_RGBA, "EGL_BIND_TO_TEXTURE_RGBA" },
-        { EGL_MIN_SWAP_INTERVAL, "EGL_MIN_SWAP_INTERVAL" },
-        { EGL_MAX_SWAP_INTERVAL, "EGL_MAX_SWAP_INTERVAL" },
-        { -1, NULL }
-    };
-    const char* string = eglQueryString(display, EGL_VENDOR);
+    const char *string = eglQueryString(display, EGL_VENDOR);
     qCDebug(ubuntumirclient, "EGL vendor: %s", string);
 
     string = eglQueryString(display, EGL_VERSION);
@@ -85,93 +38,19 @@
     string = eglQueryString(display, EGL_EXTENSIONS);
     qCDebug(ubuntumirclient, "EGL extensions: %s", string);
 
-    qCDebug(ubuntumirclient, "EGL configuration attibutes:");
-    for (int index = 0; kAttribs[index].attrib != -1; index++) {
-        EGLint value;
-        if (eglGetConfigAttrib(display, config, kAttribs[index].attrib, &value))
-            qCDebug(ubuntumirclient, "  %s: %d", kAttribs[index].name, static_cast<int>(value));
-    }
-}
-
-QString eglErrorToString(EGLint errorNumber)
-{
-    #define EGL_ERROR_CASE(error) case error: return QString(#error);
-
-    switch (errorNumber) {
-        EGL_ERROR_CASE(EGL_SUCCESS)
-        EGL_ERROR_CASE(EGL_NOT_INITIALIZED)
-        EGL_ERROR_CASE(EGL_BAD_ACCESS)
-        EGL_ERROR_CASE(EGL_BAD_ALLOC)
-        EGL_ERROR_CASE(EGL_BAD_ATTRIBUTE)
-        EGL_ERROR_CASE(EGL_BAD_CONTEXT)
-        EGL_ERROR_CASE(EGL_BAD_CONFIG)
-        EGL_ERROR_CASE(EGL_BAD_CURRENT_SURFACE)
-        EGL_ERROR_CASE(EGL_BAD_DISPLAY)
-        EGL_ERROR_CASE(EGL_BAD_SURFACE)
-        EGL_ERROR_CASE(EGL_BAD_MATCH)
-        EGL_ERROR_CASE(EGL_BAD_PARAMETER)
-        EGL_ERROR_CASE(EGL_BAD_NATIVE_PIXMAP)
-        EGL_ERROR_CASE(EGL_BAD_NATIVE_WINDOW)
-        EGL_ERROR_CASE(EGL_CONTEXT_LOST)
-        default:
-            return QString("?");
-    }
-
-    #undef EGL_ERROR_CASE
-}
-
-EGLenum api_in_use()
-{
-    #ifdef QTUBUNTU_USE_OPENGL
-    return EGL_OPENGL_API;
-    #else
-    return EGL_OPENGL_ES_API;
-    #endif
-}
-
-const int kSwapInterval = 1;
-
-int qGetEnvIntValue(const char *varName, bool *ok)
-{
-    return qgetenv(varName).toInt(ok);
+    qCDebug(ubuntumirclient, "EGL configuration attributes:");
+    q_printEglConfig(display, config);
 }
 
 } // anonymous namespace
 
-UbuntuOpenGLContext::UbuntuOpenGLContext(const QSurfaceFormat &surfaceFormat, UbuntuOpenGLContext *share,
-                                         EGLDisplay display, EGLConfig config)
-    : mSurfaceFormat(surfaceFormat)
-    , mEglDisplay(display)
+UbuntuOpenGLContext::UbuntuOpenGLContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share,
+                                         EGLDisplay display)
+    : QEGLPlatformContext(format, share, display, 0)
 {
-    // Create an OpenGL ES 2 context.
-    QVector<EGLint> attribs;
-    attribs.append(EGL_CONTEXT_CLIENT_VERSION);
-    attribs.append(2);
-    attribs.append(EGL_NONE);
-    ASSERT(eglBindAPI(api_in_use()) == EGL_TRUE);
-
     if (ubuntumirclient().isDebugEnabled()) {
-        printEglConfig(mEglDisplay, config);
+        printEglConfig(display, eglConfig());
     }
-
-    // Set vblank swap interval.
-    bool ok;
-    int swapInterval = qGetEnvIntValue("QTUBUNTU_SWAPINTERVAL", &ok);
-    if (!ok)
-        swapInterval = kSwapInterval;
-
-    qCDebug(ubuntumirclient, "Setting swap interval to %d", swapInterval);
-    eglSwapInterval(mEglDisplay, swapInterval);
-
-    mEglContext = eglCreateContext(mEglDisplay, config, share ? share->eglContext() : EGL_NO_CONTEXT,
-                                   attribs.constData());
-
-    Q_ASSERT(mEglContext != EGL_NO_CONTEXT);
-}
-
-UbuntuOpenGLContext::~UbuntuOpenGLContext()
-{
-    ASSERT(eglDestroyContext(mEglDisplay, mEglContext) == EGL_TRUE);
 }
 
 static bool needsFBOReadBackWorkaround()
@@ -179,7 +58,7 @@
     static bool set = false;
     static bool needsWorkaround = false;
 
-    if (!set) {
+    if (Q_UNLIKELY(!set)) {
         const char *rendererString = reinterpret_cast<const char *>(glGetString(GL_RENDERER));
         needsWorkaround = qstrncmp(rendererString, "Mali-400", 8) == 0
                           || qstrncmp(rendererString, "Mali-T7", 7) == 0
@@ -194,55 +73,41 @@
 {
     Q_ASSERT(surface->surface()->surfaceType() == QSurface::OpenGLSurface);
 
-    if (surface->surface()->surfaceClass() == QSurface::Offscreen) {
-        auto offscreen = static_cast<UbuntuOffscreenSurface *>(surface);
-        if (!offscreen->buffer()) {
-            auto buffer = new QOpenGLFramebufferObject(surface->surface()->size());
-            offscreen->setBuffer(buffer);
-        }
-        return offscreen->buffer()->bind();
-    } else {
-        EGLSurface eglSurface = static_cast<UbuntuWindow*>(surface)->eglSurface();
-        ASSERT(eglBindAPI(api_in_use()) == EGL_TRUE);
-
-        EGLBoolean result = eglMakeCurrent(mEglDisplay, eglSurface, eglSurface, mEglContext);
-        if (result == EGL_FALSE) {
-            qCCritical(ubuntumirclient, "eglMakeCurrent() failed with %s",
-                    qPrintable(eglErrorToString(eglGetError())));
-            return false;
-        }
-
+    const bool ret = QEGLPlatformContext::makeCurrent(surface);
+
+    if (Q_LIKELY(ret)) {
         QOpenGLContextPrivate *ctx_d = QOpenGLContextPrivate::get(context());
         if (!ctx_d->workaround_brokenFBOReadBack && needsFBOReadBackWorkaround()) {
             ctx_d->workaround_brokenFBOReadBack = true;
         }
-
-        if (ubuntumirclient().isDebugEnabled()) {
-            printOpenGLESConfig();
-        }
-        return true;
-    }
-}
-
-void UbuntuOpenGLContext::doneCurrent()
-{
-    ASSERT(eglBindAPI(api_in_use()) == EGL_TRUE);
-    ASSERT(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT) == EGL_TRUE);
-}
-
-void UbuntuOpenGLContext::swapBuffers(QPlatformSurface* surface)
-{
-    UbuntuWindow *ubuntuWindow = static_cast<UbuntuWindow*>(surface);
-
-    EGLSurface eglSurface = ubuntuWindow->eglSurface();
-    ASSERT(eglBindAPI(api_in_use()) == EGL_TRUE);
-    ASSERT(eglSwapBuffers(mEglDisplay, eglSurface) == EGL_TRUE);
-
+    }
+
+    return ret;
+}
+
+// WORKAROUND for bug 1594198 - avoid having Qt use GLESv3
+QSurfaceFormat UbuntuOpenGLContext::format() const
+{
+    auto format = QEGLPlatformContext::format();
+    if (format.renderableType() == QSurfaceFormat::OpenGLES && format.majorVersion() > 2) {
+        format.setMajorVersion(2);
+    }
+    return format;
+}
+
+// Following method used internally in the base class QEGLPlatformContext to access
+// the egl surface of a QPlatformSurface/UbuntuWindow
+EGLSurface UbuntuOpenGLContext::eglSurfaceForPlatformSurface(QPlatformSurface *surface)
+{
+    auto ubuntuWindow = static_cast<UbuntuWindow *>(surface);
+    return ubuntuWindow->eglSurface();
+}
+
+void UbuntuOpenGLContext::swapBuffers(QPlatformSurface *surface)
+{
+    QEGLPlatformContext::swapBuffers(surface);
+
+    // notify window on swap completion
+    auto ubuntuWindow = static_cast<UbuntuWindow *>(surface);
     ubuntuWindow->onSwapBuffersDone();
 }
-
-void (*UbuntuOpenGLContext::getProcAddress(const QByteArray& procName)) ()
-{
-    ASSERT(eglBindAPI(api_in_use()) == EGL_TRUE);
-    return eglGetProcAddress(procName.constData());
-}

=== modified file 'src/ubuntumirclient/glcontext.h'
--- src/ubuntumirclient/glcontext.h	2016-06-20 08:37:56 +0000
+++ src/ubuntumirclient/glcontext.h	2016-07-04 17:59:30 +0000
@@ -18,30 +18,24 @@
 #define UBUNTU_OPENGL_CONTEXT_H
 
 #include <qpa/qplatformopenglcontext.h>
+#include <private/qeglplatformcontext_p.h>
 
 #include <EGL/egl.h>
 
-class UbuntuOpenGLContext : public QPlatformOpenGLContext
+class UbuntuOpenGLContext : public QEGLPlatformContext
 {
 public:
-    UbuntuOpenGLContext(const QSurfaceFormat &surfaceFormat, UbuntuOpenGLContext *share,
-                        EGLDisplay display, EGLConfig config);
-    virtual ~UbuntuOpenGLContext();
-
-    // QPlatformOpenGLContext methods.
-    QSurfaceFormat format() const override { return mSurfaceFormat; }
-    void swapBuffers(QPlatformSurface *surface) override;
-    bool makeCurrent(QPlatformSurface *surface) override;
-    void doneCurrent() override;
-    bool isValid() const override { return mEglContext != EGL_NO_CONTEXT; }
-    void (*getProcAddress(const QByteArray& procName)) () override;
-
-    EGLContext eglContext() const { return mEglContext; }
-
-private:
-    const QSurfaceFormat mSurfaceFormat;
-    EGLContext mEglContext;
-    EGLDisplay mEglDisplay;
+    UbuntuOpenGLContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share,
+                        EGLDisplay display);
+
+    // QEGLPlatformContext methods.
+    void swapBuffers(QPlatformSurface *surface) final;
+    bool makeCurrent(QPlatformSurface *surface) final;
+
+    QSurfaceFormat format() const final;
+
+protected:
+    EGLSurface eglSurfaceForPlatformSurface(QPlatformSurface *surface) final;
 };
 
 #endif // UBUNTU_OPENGL_CONTEXT_H

=== modified file 'src/ubuntumirclient/integration.cpp'
--- src/ubuntumirclient/integration.cpp	2016-06-20 08:37:56 +0000
+++ src/ubuntumirclient/integration.cpp	2016-07-04 17:59:30 +0000
@@ -18,11 +18,11 @@
 #include "integration.h"
 #include "backingstore.h"
 #include "clipboard.h"
+#include "desktopwindow.h"
 #include "glcontext.h"
 #include "input.h"
 #include "logging.h"
 #include "nativeinterface.h"
-#include "offscreensurface.h"
 #include "screen.h"
 #include "theme.h"
 #include "window.h"
@@ -30,7 +30,7 @@
 // Qt
 #include <QFileInfo>
 #include <QGuiApplication>
-#include <private/qguiapplication_p.h>
+#include <private/qeglpbuffer_p.h>
 #include <qpa/qplatformnativeinterface.h>
 #include <qpa/qplatforminputcontextfactory_p.h>
 #include <qpa/qplatforminputcontext.h>
@@ -95,31 +95,17 @@
 
     mMirConnection = u_application_instance_get_mir_connection(mInstance);
 
+    // Choose the default surface format suited to the Mir platform
+    QSurfaceFormat defaultFormat;
+    defaultFormat.setRedBufferSize(8);
+    defaultFormat.setGreenBufferSize(8);
+    defaultFormat.setBlueBufferSize(8);
+    QSurfaceFormat::setDefaultFormat(defaultFormat);
+
     // Initialize EGL.
-    ASSERT(eglBindAPI(EGL_OPENGL_ES_API) == EGL_TRUE);
-
     mEglNativeDisplay = mir_connection_get_egl_native_display(mMirConnection);
     ASSERT((mEglDisplay = eglGetDisplay(mEglNativeDisplay)) != EGL_NO_DISPLAY);
     ASSERT(eglInitialize(mEglDisplay, nullptr, nullptr) == EGL_TRUE);
-
-    // Configure EGL buffers format for all Windows.
-    mSurfaceFormat.setRedBufferSize(8);
-    mSurfaceFormat.setGreenBufferSize(8);
-    mSurfaceFormat.setBlueBufferSize(8);
-    mSurfaceFormat.setAlphaBufferSize(8);
-    mSurfaceFormat.setDepthBufferSize(24);
-    mSurfaceFormat.setStencilBufferSize(8);
-    if (!qEnvironmentVariableIsEmpty("QTUBUNTU_MULTISAMPLE")) {
-        mSurfaceFormat.setSamples(4);
-        qCDebug(ubuntumirclient, "setting MSAA to 4 samples");
-    }
-#ifdef QTUBUNTU_USE_OPENGL
-    mSurfaceFormat.setRenderableType(QSurfaceFormat::OpenGL);
-#else
-    mSurfaceFormat.setRenderableType(QSurfaceFormat::OpenGLES);
-#endif
-
-    mEglConfig = q_configFromGLFormat(mEglDisplay, mSurfaceFormat, true);
 }
 
 void UbuntuClientIntegration::initialize()
@@ -226,7 +212,12 @@
 
 QPlatformWindow* UbuntuClientIntegration::createPlatformWindow(QWindow* window) const
 {
-    return new UbuntuWindow(window, mClipboard, mInput, mNativeInterface, mEglDisplay, mEglConfig, mMirConnection);
+    if (window->type() == Qt::Desktop) {
+        // Desktop windows should not be backed up by a mir surface as they don't draw anything (nor should).
+        return new UbuntuDesktopWindow(window);
+    } else {
+        return new UbuntuWindow(window, mClipboard, mInput, mNativeInterface, mEglDisplay, mMirConnection);
+    }
 }
 
 bool UbuntuClientIntegration::hasCapability(QPlatformIntegration::Capability cap) const
@@ -250,6 +241,7 @@
         }
     case MultipleWindows:
     case NonFullScreenWindows:
+    case RasterGLSurface:
         return true;
     default:
         return QPlatformIntegration::hasCapability(cap);
@@ -269,8 +261,25 @@
 QPlatformOpenGLContext* UbuntuClientIntegration::createPlatformOpenGLContext(
         QOpenGLContext* context) const
 {
-    return new UbuntuOpenGLContext(mSurfaceFormat, static_cast<UbuntuOpenGLContext*>(context->shareHandle()),
-                                   mEglDisplay, mEglConfig);
+    QSurfaceFormat format(context->format());
+
+    auto platformContext = new UbuntuOpenGLContext(format, context->shareHandle(), mEglDisplay);
+    if (!platformContext->isValid()) {
+        // Older Intel Atom-based devices only support OpenGL 1.4 compatibility profile but by default
+        // QML asks for at least OpenGL 2.0. The XCB GLX backend ignores this request and returns a
+        // 1.4 context, but the XCB EGL backend tries to honour it, and fails. The 1.4 context appears to
+        // have sufficient capabilities on MESA (i915) to render correctly however. So reduce the default
+        // requested OpenGL version to 1.0 to ensure EGL will give us a working context (lp:1549455).
+        static const bool isMesa = QString(eglQueryString(mEglDisplay, EGL_VENDOR)).contains(QStringLiteral("Mesa"));
+        if (isMesa) {
+            qCDebug(ubuntumirclient, "Attempting to choose OpenGL 1.4 context which may suit Mesa");
+            format.setMajorVersion(1);
+            format.setMinorVersion(4);
+            delete platformContext;
+            platformContext = new UbuntuOpenGLContext(format, context->shareHandle(), mEglDisplay);
+        }
+    }
+    return platformContext;
 }
 
 QStringList UbuntuClientIntegration::themeNames() const
@@ -314,7 +323,7 @@
 QPlatformOffscreenSurface *UbuntuClientIntegration::createPlatformOffscreenSurface(
         QOffscreenSurface *surface) const
 {
-    return new UbuntuOffscreenSurface(surface);
+    return new QEGLPbuffer(mEglDisplay, QSurfaceFormat::defaultFormat(), surface);
 }
 
 void UbuntuClientIntegration::destroyScreen(UbuntuScreen *screen)

=== modified file 'src/ubuntumirclient/integration.h'
--- src/ubuntumirclient/integration.h	2016-06-20 08:37:56 +0000
+++ src/ubuntumirclient/integration.h	2016-07-04 17:59:30 +0000
@@ -62,9 +62,7 @@
 
     // New methods.
     MirConnection *mirConnection() const { return mMirConnection; }
-    QSurfaceFormat surfaceFormat() const { return mSurfaceFormat; }
     EGLDisplay eglDisplay() const { return mEglDisplay; }
-    EGLConfig eglConfig() const { return mEglConfig; }
     EGLNativeDisplayType eglNativeDisplay() const { return mEglNativeDisplay; }
     UbuntuScreenObserver *screenObserver() const { return mScreenObserver.data(); }
 
@@ -97,9 +95,7 @@
 
     // EGL related
     EGLDisplay mEglDisplay{EGL_NO_DISPLAY};
-    EGLConfig mEglConfig{nullptr};
     EGLNativeDisplayType mEglNativeDisplay;
-    QSurfaceFormat mSurfaceFormat;
 };
 
 #endif // UBUNTU_CLIENT_INTEGRATION_H

=== removed file 'src/ubuntumirclient/offscreensurface.cpp'
--- src/ubuntumirclient/offscreensurface.cpp	2016-01-04 17:18:51 +0000
+++ src/ubuntumirclient/offscreensurface.cpp	1970-01-01 00:00:00 +0000
@@ -1,47 +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 "offscreensurface.h"
-
-#include <QOffscreenSurface>
-#include <QOpenGLFramebufferObject>
-
-UbuntuOffscreenSurface::UbuntuOffscreenSurface(QOffscreenSurface *offscreenSurface)
-    : QPlatformOffscreenSurface(offscreenSurface)
-    , m_buffer(nullptr)
-    , m_format(offscreenSurface->requestedFormat())
-{
-}
-
-QSurfaceFormat UbuntuOffscreenSurface::format() const
-{
-    return m_format;
-}
-
-bool UbuntuOffscreenSurface::isValid() const
-{
-    return m_buffer != nullptr && m_buffer->isValid();
-}
-
-QOpenGLFramebufferObject* UbuntuOffscreenSurface::buffer() const
-{
-    return m_buffer;
-}
-
-void UbuntuOffscreenSurface::setBuffer(QOpenGLFramebufferObject *buffer)
-{
-    m_buffer = buffer;
-}

=== removed file 'src/ubuntumirclient/offscreensurface.h'
--- src/ubuntumirclient/offscreensurface.h	2016-01-04 17:18:51 +0000
+++ src/ubuntumirclient/offscreensurface.h	1970-01-01 00:00:00 +0000
@@ -1,41 +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 UBUNTU_OFFSCREEN_SURFACE_H
-#define UBUNTU_OFFSCREEN_SURFACE_H
-
-#include <qpa/qplatformoffscreensurface.h>
-#include <QSurfaceFormat>
-
-class QOpenGLFramebufferObject;
-
-class UbuntuOffscreenSurface : public QPlatformOffscreenSurface
-{
-public:
-    UbuntuOffscreenSurface(QOffscreenSurface *offscreenSurface);
-
-    QSurfaceFormat format() const override;
-    bool isValid() const override;
-
-    QOpenGLFramebufferObject* buffer() const;
-    void setBuffer(QOpenGLFramebufferObject *buffer);
-
-private:
-    QOpenGLFramebufferObject *m_buffer;
-    QSurfaceFormat m_format;
-};
-
-#endif // UBUNTU_OFFSCREEN_SURFACE_H

=== modified file 'src/ubuntumirclient/ubuntumirclient.pro'
--- src/ubuntumirclient/ubuntumirclient.pro	2016-05-30 17:14:14 +0000
+++ src/ubuntumirclient/ubuntumirclient.pro	2016-07-04 17:59:30 +0000
@@ -18,11 +18,11 @@
     backingstore.cpp \
     clipboard.cpp \
     cursor.cpp \
+    desktopwindow.cpp \
     glcontext.cpp \
     input.cpp \
     integration.cpp \
     nativeinterface.cpp \
-    offscreensurface.cpp \
     platformservices.cpp \
     plugin.cpp \
     screen.cpp \
@@ -34,12 +34,12 @@
     backingstore.h \
     clipboard.h \
     cursor.h \
+    desktopwindow.h \
     glcontext.h \
     input.h \
     integration.h \
     logging.h \
     nativeinterface.h \
-    offscreensurface.h \
     orientationchangeevent_p.h \
     platformservices.h \
     plugin.h \

=== modified file 'src/ubuntumirclient/window.cpp'
--- src/ubuntumirclient/window.cpp	2016-06-20 08:37:56 +0000
+++ src/ubuntumirclient/window.cpp	2016-07-04 17:59:30 +0000
@@ -29,6 +29,7 @@
 #include <QMutexLocker>
 #include <QSize>
 #include <QtMath>
+#include <private/qeglconvenience_p.h>
 
 // Platform API
 #include <ubuntu/application/instance.h>
@@ -101,6 +102,24 @@
     }
 }
 
+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:
+    default:                         return "???";
+    }
+}
+
 MirSurfaceState qtWindowStateToMirSurfaceState(Qt::WindowState state)
 {
     switch (state) {
@@ -124,14 +143,6 @@
     return id++;
 }
 
-MirPixelFormat defaultPixelFormatFor(MirConnection *connection)
-{
-    MirPixelFormat format;
-    unsigned int nformats;
-    mir_connection_get_available_surface_formats(connection, &format, 1, &nformats);
-    return format;
-}
-
 UAUiWindowRole roleFor(QWindow *window)
 {
     QVariant roleVariant = window->property("role");
@@ -151,12 +162,11 @@
     return parent ? static_cast<UbuntuWindow *>(parent->handle()) : nullptr;
 }
 
-Spec makeSurfaceSpec(QWindow *window, UbuntuInput *input, MirConnection *connection)
+Spec makeSurfaceSpec(QWindow *window, UbuntuInput *input, MirPixelFormat pixelFormat, MirConnection *connection)
 {
     const auto geom = window->geometry();
     const int width = geom.width() > 0 ? geom.width() : 1;
     const int height = geom.height() > 0 ? geom.height() : 1;
-    const auto pixelFormat = defaultPixelFormatFor(connection);
 
     if (U_ON_SCREEN_KEYBOARD_ROLE == roleFor(window)) {
         qCDebug(ubuntumirclient, "makeSurfaceSpec(window=%p) - creating input method surface (width=%d, height=%d", window, width, height);
@@ -217,11 +227,11 @@
     }
 }
 
-MirSurface *createMirSurface(QWindow *window, int mirOutputId, UbuntuInput *input,
+MirSurface *createMirSurface(QWindow *window, int mirOutputId, UbuntuInput *input, MirPixelFormat pixelFormat,
                              MirConnection *connection, mir_surface_event_callback inputCallback,
                              void* inputContext)
 {
-    auto spec = makeSurfaceSpec(window, input, connection);
+    auto spec = makeSurfaceSpec(window, input, pixelFormat, connection);
 
     // Install event handler as early as possible
     mir_surface_spec_set_event_handler(spec.get(), inputCallback, inputContext);
@@ -244,6 +254,18 @@
     return surface;
 }
 
+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()
@@ -266,8 +288,7 @@
 class UbuntuSurface
 {
 public:
-    UbuntuSurface(UbuntuWindow *platformWindow, EGLDisplay display, EGLConfig config, int mirOutputId,
-                  UbuntuInput *input, MirConnection *connection)
+    UbuntuSurface(UbuntuWindow *platformWindow, EGLDisplay display, UbuntuInput *input, MirConnection *connection)
         : mWindow(platformWindow->window())
         , mPlatformWindow(platformWindow)
         , mInput(input)
@@ -275,9 +296,44 @@
         , mEglDisplay(display)
         , mNeedsRepaint(false)
         , mParented(mWindow->transientParent() || mWindow->parent())
+        , mFormat(mWindow->requestedFormat())
         , mShellChrome(mWindow->flags() & LowChromeWindowHint ? mir_shell_chrome_low : mir_shell_chrome_normal)
     {
-        mMirSurface = createMirSurface(mWindow, mirOutputId, input, connection, surfaceEventCallback, this);
+        // Have Qt choose most suitable EGLConfig for the requested surface format, and update format to reflect it
+        EGLConfig config = q_configFromGLFormat(display, mFormat, true);
+        if (config == 0) {
+            // Older Intel Atom-based devices only support OpenGL 1.4 compatibility profile but by default
+            // QML asks for at least OpenGL 2.0. The XCB GLX backend ignores this request and returns a
+            // 1.4 context, but the XCB EGL backend tries to honour it, and fails. The 1.4 context appears to
+            // have sufficient capabilities on MESA (i915) to render correctly however. So reduce the default
+            // requested OpenGL version to 1.0 to ensure EGL will give us a working context (lp:1549455).
+            static const bool isMesa = QString(eglQueryString(display, EGL_VENDOR)).contains(QStringLiteral("Mesa"));
+            if (isMesa) {
+                qCDebug(ubuntumirclient, "Attempting to choose OpenGL 1.4 context which may suit Mesa");
+                mFormat.setMajorVersion(1);
+                mFormat.setMinorVersion(4);
+                config = q_configFromGLFormat(display, mFormat, true);
+            }
+        }
+        if (config == 0) {
+            qCritical() << "Qt failed to choose a suitable EGLConfig to suit the surface format" << mFormat;
+        }
+
+        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.
+        auto pixelFormat = 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 optimisation for the compositor, as it can avoid blending this surface.
+        if (mWindow->requestedFormat().alphaBufferSize() < 0) {
+            pixelFormat = disableAlphaBufferIfPossible(pixelFormat);
+        }
+
+        const auto outputId = static_cast<UbuntuScreen *>(mWindow->screen()->handle())->mirOutputId();
+
+        mMirSurface = createMirSurface(mWindow, outputId, input, pixelFormat, connection, surfaceEventCallback, this);
         mEglSurface = eglCreateWindowSurface(mEglDisplay, config, nativeWindowFor(mMirSurface), nullptr);
 
         // Window manager can give us a final size different from what we asked for
@@ -299,8 +355,11 @@
         platformWindow->QPlatformWindow::setGeometry(geom);
         QWindowSystemInterface::handleGeometryChange(mWindow, geom);
 
-        qCDebug(ubuntumirclient, "created surface at (%d, %d) with size (%d, %d), title '%s', role: '%d'\n",
-             geom.x(), geom.y(), geom.width(), geom.height(), mWindow->title().toUtf8().constData(), roleFor(mWindow));
+        qCDebug(ubuntumirclient) << "Created surface with geometry:" << geom << "title:" << mWindow->title()
+                                 << "role:" << roleFor(mWindow)
+                                 << "\nRequested format:" << mWindow->requestedFormat()
+                                 << "\nActual format:" << mFormat
+                                 << "with associated Mir pixel format:" << mirPixelFormatToStr(pixelFormat);
     }
 
     ~UbuntuSurface()
@@ -335,6 +394,8 @@
     void setSurfaceParent(MirSurface*);
     bool hasParent() const { return mParented; }
 
+    QSurfaceFormat format() const { return mFormat; }
+
 private:
     static void surfaceEventCallback(MirSurface* surface, const MirEvent *event, void* context);
     void postEvent(const MirEvent *event);
@@ -351,6 +412,7 @@
     bool mNeedsRepaint;
     bool mParented;
     QSize mBufferSize;
+    QSurfaceFormat mFormat;
 
     QMutex mTargetSizeMutex;
     QSize mTargetSize;
@@ -509,8 +571,7 @@
 }
 
 UbuntuWindow::UbuntuWindow(QWindow *w, const QSharedPointer<UbuntuClipboard> &clipboard,
-                           UbuntuInput *input, UbuntuNativeInterface *native, EGLDisplay eglDisplay,
-                           EGLConfig eglConfig, MirConnection *mirConnection)
+                           UbuntuInput *input, UbuntuNativeInterface *native, EGLDisplay eglDisplay, MirConnection *mirConnection)
     : QObject(nullptr)
     , QPlatformWindow(w)
     , mId(makeId())
@@ -520,8 +581,7 @@
     , mWindowVisible(false)
     , mWindowExposed(true)
     , mNativeInterface(native)
-    , mSurface(new UbuntuSurface{this, eglDisplay, eglConfig,
-               static_cast<UbuntuScreen*>(w->screen()->handle())->mirOutputId(), input, mirConnection})
+    , mSurface(new UbuntuSurface{this, eglDisplay, input, mirConnection})
     , mScale(1.0)
     , mFormFactor(mir_form_factor_unknown)
 {
@@ -709,6 +769,11 @@
     return mWindowVisible && mWindowExposed;
 }
 
+QSurfaceFormat UbuntuWindow::format() const
+{
+    return mSurface->format();
+}
+
 void* UbuntuWindow::eglSurface() const
 {
     return mSurface->eglSurface();

=== modified file 'src/ubuntumirclient/window.h'
--- src/ubuntumirclient/window.h	2016-06-20 08:37:56 +0000
+++ src/ubuntumirclient/window.h	2016-07-04 17:59:30 +0000
@@ -40,7 +40,7 @@
     Q_OBJECT
 public:
     UbuntuWindow(QWindow *w, const QSharedPointer<UbuntuClipboard> &clipboard,
-                 UbuntuInput *input, UbuntuNativeInterface* native, EGLDisplay eglDisplay, EGLConfig eglConfig,
+                 UbuntuInput *input, UbuntuNativeInterface* native, EGLDisplay eglDisplay,
                  MirConnection *mirConnection);
     virtual ~UbuntuWindow();
 
@@ -54,6 +54,8 @@
     void propagateSizeHints() override;
     bool isExposed() const override;
 
+    QSurfaceFormat format() const override;
+
     // Additional Window properties exposed by NativeInterface
     MirFormFactor formFactor() const { return mFormFactor; }
     float scale() const { return mScale; }