Use ozone for x11

Switch to use ozone also for x11/glx. This way we have a
more elegant approach to hook in our gl surface classes
and we use ozone for all linux qpa backends. Moreover,
we have now also more fine grain control to reimplement
gl surface handling logic.

This also aims to fix currently broken wayland backend,
but instead of patching the broken x11 calls, we simply reuse
ozone which does not use x11 for ozone egl.

Add webengine-x11 check to handle ozone glx plugin compilation.

For ozone egl backend reimplement missing functions.

Task-number: QTBUG-65682
Task-number: QTBUG-51631
Change-Id: I8b45c6f4d09a1c703efb12b6452d78ab385371ab
Reviewed-by: Jüri Valdmann <juri.valdmann@qt.io>

8 files changed, 316 insertions, 24 deletions

diff --git a/src/core/ozone/gl_ozone_egl_qt.cpp b/src/core/ozone/gl_ozone_egl_qt.cpp
index a9b3da5e2..bc7b2b756 100644
--- a/src/core/ozone/gl_ozone_egl_qt.cpp
+++ b/src/core/ozone/gl_ozone_egl_qt.cpp
@@ -38,11 +38,13 @@
 ****************************************************************************/
 
 #if defined(USE_OZONE)
-
+#include "gl_ozone_egl_qt.h"
+#include "gl_context_qt.h"
+#include "gl_surface_egl_qt.h"
 #include "base/files/file_path.h"
 #include "base/native_library.h"
 #include "gl_context_qt.h"
-#include "ozone/gl_ozone_egl_qt.h"
+#include "gl_ozone_egl_qt.h"
 #include "ui/gl/gl_context_egl.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
@@ -55,10 +57,12 @@
 
 #ifndef QT_NO_OPENGL
 #include <QOpenGLContext>
+QT_BEGIN_NAMESPACE
 Q_GUI_EXPORT QOpenGLContext *qt_gl_global_share_context();
+QT_END_NAMESPACE
 #endif
 
-namespace QtWebEngineCore {
+namespace ui {
 
 base::NativeLibrary LoadLibrary(const base::FilePath& filename) {
     base::NativeLibraryLoadError error;
@@ -103,6 +107,39 @@ bool GLOzoneEGLQt::LoadGLES2Bindings(gl::GLImplementation /*implementation*/)
     return true;
 }
 
+bool GLOzoneEGLQt::InitializeGLOneOffPlatform()
+{
+    if (!gl::GLSurfaceEGLQt::InitializeOneOff()) {
+        LOG(ERROR) << "GLOzoneEGLQt::InitializeOneOff failed.";
+        return false;
+    }
+    return true;
+}
+
+bool GLOzoneEGLQt::InitializeExtensionSettingsOneOffPlatform()
+{
+    return gl::GLSurfaceEGLQt::InitializeExtensionSettingsOneOff();
+}
+
+scoped_refptr<gl::GLSurface> GLOzoneEGLQt::CreateViewGLSurface(gfx::AcceleratedWidget window)
+{
+    return nullptr;
+}
+
+scoped_refptr<gl::GLSurface> GLOzoneEGLQt::CreateOffscreenGLSurface(const gfx::Size &size)
+{
+    scoped_refptr<gl::GLSurface> surface = new gl::GLSurfaceEGLQt(size);
+    if (surface->Initialize(gl::GLSurfaceFormat()))
+        return surface;
+
+    surface = new gl::GLSurfacelessQtEGL(size);
+    if (surface->Initialize(gl::GLSurfaceFormat()))
+        return surface;
+
+    LOG(WARNING) << "Failed to create offscreen GL surface";
+    return nullptr;
+}
+
 intptr_t GLOzoneEGLQt::GetNativeDisplay()
 {
     static void *display = GLContextHelper::getNativeDisplay();
@@ -113,6 +150,6 @@ intptr_t GLOzoneEGLQt::GetNativeDisplay()
     return reinterpret_cast<intptr_t>(EGL_DEFAULT_DISPLAY);
 }
 
-} // namespace QtWebEngineCore
+} // namespace ui
 
 #endif // defined(USE_OZONE)
diff --git a/src/core/ozone/gl_ozone_egl_qt.h b/src/core/ozone/gl_ozone_egl_qt.h
index fc609c51c..c24d03a81 100644
--- a/src/core/ozone/gl_ozone_egl_qt.h
+++ b/src/core/ozone/gl_ozone_egl_qt.h
@@ -44,18 +44,16 @@
 
 #include "ui/ozone/common/gl_ozone_egl.h"
 
-namespace QtWebEngineCore {
+namespace ui {
 
-class GLOzoneEGLQt : public ui::GLOzoneEGL {
+class GLOzoneEGLQt : public GLOzoneEGL {
 public:
-    scoped_refptr<gl::GLSurface> CreateViewGLSurface(gfx::AcceleratedWidget /*window*/) override
-    {
-        return nullptr;
-    }
-    scoped_refptr<gl::GLSurface> CreateOffscreenGLSurface(const gfx::Size& /*size*/) override
-    {
-        return nullptr;
-    }
+    bool InitializeGLOneOffPlatform() override;
+    bool InitializeExtensionSettingsOneOffPlatform() override;
+    scoped_refptr<gl::GLSurface> CreateViewGLSurface(
+            gfx::AcceleratedWidget window) override;
+    scoped_refptr<gl::GLSurface> CreateOffscreenGLSurface(
+            const gfx::Size& size) override;
 
 protected:
     // Returns native platform display handle. This is used to obtain the EGL
@@ -66,7 +64,7 @@ protected:
     bool LoadGLES2Bindings(gl::GLImplementation implementation) override;
 };
 
-} // namespace QtWebEngineCore
+} // namespace ui
 
 #endif // defined(USE_OZONE)
 
diff --git a/src/core/ozone/gl_ozone_glx_qt.cpp b/src/core/ozone/gl_ozone_glx_qt.cpp
new file mode 100644
index 000000000..9a0fea7c7
--- /dev/null
+++ b/src/core/ozone/gl_ozone_glx_qt.cpp
@@ -0,0 +1,143 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWebEngine module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+
+#include "gl_ozone_glx_qt.h"
+#include "gl_surface_glx_qt.h"
+#include "ui/gl/gl_context_glx.h"
+#include "ui/gl/gl_gl_api_implementation.h"
+#include "ui/gl/gl_glx_api_implementation.h"
+#include <dlfcn.h>
+
+namespace ui {
+
+bool GLOzoneGLXQt::InitializeGLOneOffPlatform() {
+    if (!gl::GLSurfaceGLXQt::InitializeOneOff()) {
+        LOG(ERROR) << "GLSurfaceGLXQt::InitializeOneOff failed.";
+        return false;
+    }
+    return true;
+}
+
+bool GLOzoneGLXQt::InitializeStaticGLBindings(
+        gl::GLImplementation implementation) {
+
+    base::NativeLibrary library = dlopen(NULL, RTLD_LAZY);
+    if (!library) {
+        LOG(ERROR) << "Failed to open GL context " << dlerror();
+        return false;
+    }
+
+    gl::GLGetProcAddressProc get_proc_address =
+            reinterpret_cast<gl::GLGetProcAddressProc>(
+                base::GetFunctionPointerFromNativeLibrary(library,
+                                                          "glXGetProcAddress"));
+    if (!get_proc_address) {
+        LOG(ERROR) << "glxGetProcAddress not found.";
+        base::UnloadNativeLibrary(library);
+        return false;
+    }
+
+    gl::SetGLGetProcAddressProc(get_proc_address);
+    gl::AddGLNativeLibrary(library);
+    gl::SetGLImplementation(gl::kGLImplementationDesktopGL);
+
+    gl::InitializeStaticGLBindingsGL();
+    gl::InitializeStaticGLBindingsGLX();
+
+    return true;
+}
+
+void GLOzoneGLXQt::InitializeDebugGLBindings() {
+    gl::InitializeDebugGLBindingsGL();
+    gl::InitializeDebugGLBindingsGLX();
+}
+
+void GLOzoneGLXQt::SetDisabledExtensionsPlatform(
+        const std::string& disabled_extensions) {
+    gl::SetDisabledExtensionsGLX(disabled_extensions);
+}
+
+void GLOzoneGLXQt::ShutdownGL() {
+    gl::ClearBindingsGL();
+    gl::ClearBindingsGLX();
+}
+
+bool GLOzoneGLXQt::GetGLWindowSystemBindingInfo(
+        gl::GLWindowSystemBindingInfo* info) {
+    return gl::GetGLWindowSystemBindingInfoGLX(info);
+}
+
+scoped_refptr<gl::GLContext> GLOzoneGLXQt::CreateGLContext(
+        gl::GLShareGroup* share_group,
+        gl::GLSurface* compatible_surface,
+        const gl::GLContextAttribs& attribs) {
+    return gl::InitializeGLContext(new gl::GLContextGLX(share_group),
+                                   compatible_surface, attribs);
+}
+
+scoped_refptr<gl::GLSurface> GLOzoneGLXQt::CreateViewGLSurface(
+        gfx::AcceleratedWidget window) {
+    return nullptr;
+}
+
+scoped_refptr<gl::GLSurface> GLOzoneGLXQt::CreateSurfacelessViewGLSurface(
+        gfx::AcceleratedWidget window) {
+    return nullptr;
+}
+
+scoped_refptr<gl::GLSurface> GLOzoneGLXQt::CreateOffscreenGLSurface(
+        const gfx::Size& size) {
+    scoped_refptr<gl::GLSurface> surface = new gl::GLSurfaceGLXQt(size);
+    if (surface->Initialize(gl::GLSurfaceFormat()))
+        return surface;
+    LOG(WARNING) << "Failed to create offscreen GL surface";
+    return nullptr;
+}
+
+bool GLOzoneGLXQt::InitializeExtensionSettingsOneOffPlatform()
+{
+    return gl::GLSurfaceGLXQt::InitializeExtensionSettingsOneOff();
+}
+
+}  // namespace ui
diff --git a/src/core/ozone/gl_ozone_glx_qt.h b/src/core/ozone/gl_ozone_glx_qt.h
new file mode 100644
index 000000000..ffbd60454
--- /dev/null
+++ b/src/core/ozone/gl_ozone_glx_qt.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtWebEngine module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef UI_OZONE_GLX_QT_H_
+#define UI_OZONE_GLX_QT_H
+
+#include "base/macros.h"
+#include "ui/gl/gl_implementation.h"
+#include "ui/ozone/public/gl_ozone.h"
+
+namespace ui {
+
+class GLOzoneGLXQt : public GLOzone {
+
+public:
+    GLOzoneGLXQt() {}
+    ~GLOzoneGLXQt() override {}
+
+    bool InitializeGLOneOffPlatform() override;
+    bool InitializeStaticGLBindings(gl::GLImplementation implementation) override;
+    void InitializeDebugGLBindings() override;
+    bool InitializeExtensionSettingsOneOffPlatform() override;
+    void ShutdownGL() override;
+    void SetDisabledExtensionsPlatform(
+        const std::string& disabled_extensions) override;
+    bool GetGLWindowSystemBindingInfo(
+            gl::GLWindowSystemBindingInfo* info) override;
+
+    scoped_refptr<gl::GLContext> CreateGLContext(
+            gl::GLShareGroup* share_group,
+            gl::GLSurface* compatible_surface,
+            const gl::GLContextAttribs& attribs) override;
+
+    scoped_refptr<gl::GLSurface> CreateViewGLSurface(
+            gfx::AcceleratedWidget window) override;
+
+    scoped_refptr<gl::GLSurface> CreateSurfacelessViewGLSurface(
+            gfx::AcceleratedWidget window) override;
+
+    scoped_refptr<gl::GLSurface> CreateOffscreenGLSurface(
+            const gfx::Size& size) override;
+
+private:
+    DISALLOW_COPY_AND_ASSIGN(GLOzoneGLXQt);
+};
+
+}  // namespace ui
+
+#endif  // UI_OZONE_GLX_QT_H
diff --git a/src/core/ozone/gl_surface_glx_qt.cpp b/src/core/ozone/gl_surface_glx_qt.cpp
index 51b0f58b0..32b85ff77 100644
--- a/src/core/ozone/gl_surface_glx_qt.cpp
+++ b/src/core/ozone/gl_surface_glx_qt.cpp
@@ -41,8 +41,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#if defined(USE_X11)
-
 #include "gl_context_qt.h"
 #include "ozone/gl_surface_glx_qt.h"
 #include "ui/gl/gl_bindings.h"
@@ -156,7 +154,7 @@ bool GLSurfaceGLXQt::InitializeExtensionSettingsOneOff()
 
     Display* display = static_cast<Display*>(g_display);
     GLSurfaceQt::g_extensions = glXQueryExtensionsString(display, 0);
-    g_driver_glx.InitializeExtensionBindings();
+    g_driver_glx.InitializeExtensionBindings(g_extensions);
     return true;
 }
 
@@ -210,4 +208,3 @@ void* GLSurfaceGLXQt::GetHandle()
 
 } //namespace gl
 
-#endif // defined(USE_X11)
diff --git a/src/core/ozone/ozone_platform_qt.cpp b/src/core/ozone/ozone_platform_qt.cpp
index 8bb5007ef..a13f33301 100644
--- a/src/core/ozone/ozone_platform_qt.cpp
+++ b/src/core/ozone/ozone_platform_qt.cpp
@@ -145,7 +145,6 @@ void OzonePlatformQt::InitializeGPU(const ui::OzonePlatform::InitParams &)
 
 } // namespace
 
-
 OzonePlatform* CreateOzonePlatformQt() { return new OzonePlatformQt; }
 
 gfx::ClientNativePixmapFactory* CreateClientNativePixmapFactoryQt()
diff --git a/src/core/ozone/surface_factory_qt.cpp b/src/core/ozone/surface_factory_qt.cpp
index f21e14c30..d2b2aab8a 100644
--- a/src/core/ozone/surface_factory_qt.cpp
+++ b/src/core/ozone/surface_factory_qt.cpp
@@ -37,6 +37,17 @@
 **
 ****************************************************************************/
 
+#include "surface_factory_qt.h"
+#include "qtwebenginecoreglobal_p.h"
+#include "gl_ozone_egl_qt.h"
+
+#if QT_CONFIG(webengine_system_x11)
+#include "gl_ozone_glx_qt.h"
+#endif
+
+#include "ui/gl/gl_surface.h"
+#include <QGuiApplication>
+
 #if defined(USE_OZONE)
 
 #include "ozone/gl_ozone_egl_qt.h"
@@ -44,16 +55,34 @@
 #include "ui/gl/gl_surface.h"
 namespace QtWebEngineCore {
 
+SurfaceFactoryQt::SurfaceFactoryQt()
+{
+    // Fixme: make better platform switch handling
+    QString platform = qApp->platformName();
+    if (platform == QLatin1String("xcb")) {
+        m_impls.push_back(gl::kGLImplementationDesktopGL);
+    } else {
+        m_impls.push_back(gl::kGLImplementationEGLGLES2);
+    }
+}
+
 std::vector<gl::GLImplementation> SurfaceFactoryQt::GetAllowedGLImplementations()
 {
-    std::vector<gl::GLImplementation> impls;
-    impls.push_back(gl::kGLImplementationEGLGLES2);
-    return impls;
+    return m_impls;
 }
 
 ui::GLOzone* SurfaceFactoryQt::GetGLOzone(gl::GLImplementation implementation)
 {
-    return new GLOzoneEGLQt();
+
+    QString platform = qApp->platformName();
+    if (platform == QLatin1String("xcb")) {
+#if QT_CONFIG(webengine_system_x11)
+        return new ui::GLOzoneGLXQt();
+#endif
+        return nullptr;
+    } else {
+        return new ui::GLOzoneEGLQt();
+    }
 }
 
 } // namespace QtWebEngineCore
diff --git a/src/core/ozone/surface_factory_qt.h b/src/core/ozone/surface_factory_qt.h
index b7991829c..0ac2eca68 100644
--- a/src/core/ozone/surface_factory_qt.h
+++ b/src/core/ozone/surface_factory_qt.h
@@ -48,8 +48,12 @@ namespace QtWebEngineCore {
 
 class SurfaceFactoryQt : public ui::SurfaceFactoryOzone
 {
+public:
+    SurfaceFactoryQt();
     std::vector<gl::GLImplementation> GetAllowedGLImplementations() override;
     ui::GLOzone* GetGLOzone(gl::GLImplementation implementation) override;
+private:
+    std::vector<gl::GLImplementation> m_impls;
 };
 
 } // namespace QtWebEngineCore