Split GLSurfaceQt

Move GLSurfaceGLXQt and GLSurfaceEGLQt to own
implementation files,so they can be reused easly
by ozone backends.

Change-Id: Ie403a941424343e13775866772bed709d7cbff6a
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

7 files changed, 725 insertions, 506 deletions

diff --git a/src/core/core_chromium.pri b/src/core/core_chromium.pri
index d33aa9677..bec272c79 100644
--- a/src/core/core_chromium.pri
+++ b/src/core/core_chromium.pri
@@ -81,6 +81,8 @@ SOURCES = \
         net/url_request_qrc_job_qt.cpp \
         net/webui_controller_factory_qt.cpp \
         ozone/gl_ozone_qt.cpp \
+        ozone/gl_surface_egl_qt.cpp \
+        ozone/gl_surface_glx_qt.cpp \
         ozone/ozone_platform_qt.cpp \
         ozone/platform_window_qt.cpp \
         ozone/surface_factory_qt.cpp \
@@ -164,6 +166,8 @@ HEADERS = \
         net/url_request_qrc_job_qt.h \
         net/webui_controller_factory_qt.h \
         ozone/gl_ozone_qt.h \
+        ozone/gl_surface_egl_qt.h \
+        ozone/gl_surface_glx_qt.h \
         ozone/ozone_platform_qt.h \
         ozone/platform_window_qt.h \
         ozone/surface_factory_qt.h \
diff --git a/src/core/gl_surface_qt.cpp b/src/core/gl_surface_qt.cpp
index 31d5e030f..54f220f8d 100644
--- a/src/core/gl_surface_qt.cpp
+++ b/src/core/gl_surface_qt.cpp
@@ -49,285 +49,43 @@
 #include "gl_context_qt.h"
 #include "qtwebenginecoreglobal_p.h"
 #include "web_engine_context.h"
+#include "ozone/gl_surface_egl_qt.h"
 
 #include "base/logging.h"
 #include "gpu/ipc/service/image_transport_surface.h"
-#include "ui/gl/egl_util.h"
+#include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
-#include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/init/gl_initializer.h"
 #include "ui/gl/init/gl_factory.h"
 
-#if defined(USE_X11)
-#include "ui/gl/gl_surface_glx.h"
-
-extern "C" {
-#include <X11/Xlib.h>
-}
-#endif
-
 #if defined(OS_WIN)
 #include "ui/gl/gl_surface_wgl.h"
 #include "ui/gl/gl_context_wgl.h"
 #include "ui/gl/vsync_provider_win.h"
 #endif
 
-// From ANGLE's egl/eglext.h.
-#ifndef EGL_ANGLE_surface_d3d_texture_2d_share_handle
-#define EGL_ANGLE_surface_d3d_texture_2d_share_handle 1
-#define EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE 0x3200
+#if defined(USE_X11)
+#include "ozone/gl_surface_glx_qt.h"
 #endif
 
-using ui::GetLastEGLErrorString;
+#include "ozone/gl_surface_egl_qt.h"
 
 namespace gl {
 
 namespace {
-
-void* g_config;
-void* g_display;
-
-const char* g_extensions = NULL;
-
-bool g_egl_surfaceless_context_supported = false;
-
 bool g_initializedEGL = false;
-
-}  // namespace
-
-
-class GLSurfaceQtEGL: public GLSurfaceQt {
-public:
-    explicit GLSurfaceQtEGL(const gfx::Size& size);
-
-    static bool InitializeOneOff();
-    static bool InitializeExtensionSettingsOneOff();
-
-    bool Initialize(GLSurfaceFormat format) override;
-    void Destroy() override;
-    void* GetHandle() override;
-    bool Resize(const gfx::Size& size, float scale_factor, ColorSpace color_space, bool has_alpha) override;
-
-protected:
-    ~GLSurfaceQtEGL();
-
-private:
-    EGLSurface m_surfaceBuffer;
-    static bool s_initialized;
-    DISALLOW_COPY_AND_ASSIGN(GLSurfaceQtEGL);
-};
-
-bool GLSurfaceQtEGL::s_initialized = false;
-
-// The following comment is cited from chromium/ui/gl/gl_surface_egl.cc:
-// SurfacelessEGL is used as Offscreen surface when platform supports
-// KHR_surfaceless_context and GL_OES_surfaceless_context. This would avoid the
-// need to create a dummy EGLsurface in case we render to client API targets.
-class GLSurfacelessQtEGL : public GLSurfaceQt {
-public:
-    explicit GLSurfacelessQtEGL(const gfx::Size& size);
-
- public:
-    bool Initialize(GLSurfaceFormat format) override;
-    void Destroy() override;
-    bool IsSurfaceless() const override;
-    bool Resize(const gfx::Size& size, float scale_factor, ColorSpace color_space, bool has_alpha) override;
-    EGLSurface GetHandle() override;
-    void* GetShareHandle() override;
-
-private:
-    DISALLOW_COPY_AND_ASSIGN(GLSurfacelessQtEGL);
-};
-
-GLSurfaceQt::~GLSurfaceQt()
-{
-}
-
-GLSurfaceQtEGL::~GLSurfaceQtEGL()
-{
-    Destroy();
-}
-
-#if defined(USE_X11)
-class GLSurfaceQtGLX: public GLSurfaceQt {
-public:
-    explicit GLSurfaceQtGLX(const gfx::Size& size);
-
-    static bool InitializeOneOff();
-    static bool InitializeExtensionSettingsOneOff();
-
-    bool Initialize(GLSurfaceFormat format) override;
-    void Destroy() override;
-    void* GetHandle() override;
-
-protected:
-    ~GLSurfaceQtGLX();
-
-private:
-    static bool s_initialized;
-    XID m_surfaceBuffer;
-    DISALLOW_COPY_AND_ASSIGN(GLSurfaceQtGLX);
-};
-
-GLSurfaceQtGLX::~GLSurfaceQtGLX()
-{
-    Destroy();
-}
-
-
-bool GLSurfaceQtGLX::s_initialized = false;
-
-void GLSurfaceGLX::ShutdownOneOff()
-{
-}
-
-bool GLSurfaceGLX::IsCreateContextSupported()
-{
-    return ExtensionsContain(g_extensions, "GLX_ARB_create_context");
-}
-
-bool GLSurfaceGLX::IsCreateContextRobustnessSupported()
-{
-    return false; // ExtensionsContain(g_extensions, "GLX_ARB_create_context_robustness");
-}
-
-bool GLSurfaceGLX::IsEXTSwapControlSupported()
-{
-    return HasGLXExtension("GLX_EXT_swap_control");
 }
 
-bool GLSurfaceGLX::IsMESASwapControlSupported()
-{
-    return HasGLXExtension("GLX_MESA_swap_control");
-}
-
-bool GLSurfaceGLX::IsCreateContextProfileSupported()
-{
-    return false; // ExtensionsContain(g_extensions, "GLX_ARB_create_context_profile");
-}
-
-bool GLSurfaceGLX::IsCreateContextES2ProfileSupported()
-{
-    return ExtensionsContain(g_extensions, "GLX_ARB_create_context_es2_profile");
-}
-
-bool GLSurfaceGLX::IsOMLSyncControlSupported()
-{
-    return false; // ExtensionsContain(g_extensions, "GLX_OML_sync_control");
-}
-
-bool GLSurfaceQtGLX::InitializeExtensionSettingsOneOff()
-{
-    if (!s_initialized)
-        return false;
-
-    Display* display = static_cast<Display*>(g_display);
-    g_extensions = glXQueryExtensionsString(display, 0);
-    g_driver_glx.InitializeExtensionBindings();
-
-    return true;
-}
+void* GLSurfaceQt::g_display = NULL;
+void* GLSurfaceQt::g_config = NULL;
+const char* GLSurfaceQt::g_extensions = NULL;
 
-bool GLSurfaceGLX::InitializeExtensionSettingsOneOff()
-{
-    return GLSurfaceQtGLX::InitializeExtensionSettingsOneOff();
-}
-
-bool GLSurfaceGLX::HasGLXExtension(const char *name)
-{
-    return ExtensionsContain(g_extensions, name);
-}
-
-bool GLSurfaceGLX::IsTextureFromPixmapSupported()
-{
-    return ExtensionsContain(g_extensions, "GLX_EXT_texture_from_pixmap");
-}
-
-const char* GLSurfaceGLX::GetGLXExtensions()
-{
-    return g_extensions;
-}
-
-bool GLSurfaceQtGLX::InitializeOneOff()
-{
-    if (s_initialized)
-        return true;
-
-    XInitThreads();
-
-    g_display = GLContextHelper::getXDisplay();
-    if (!g_display) {
-        LOG(ERROR) << "GLContextHelper::getXDisplay() failed.";
-        return false;
-    }
-
-    g_config = GLContextHelper::getXConfig();
-    if (!g_config) {
-        LOG(ERROR) << "GLContextHelper::getXConfig() failed.";
-        return false;
-    }
-
-    Display* display = static_cast<Display*>(g_display);
-    int major, minor;
-    if (!glXQueryVersion(display, &major, &minor)) {
-        LOG(ERROR) << "glxQueryVersion failed.";
-        return false;
-    }
-
-    if (major == 1 && minor < 3) {
-        LOG(ERROR) << "GLX 1.3 or later is required.";
-        return false;
-    }
-
-    s_initialized = true;
-    return true;
-}
-
-bool GLSurfaceQtGLX::Initialize(GLSurfaceFormat format)
-{
-    Q_ASSERT(!m_surfaceBuffer);
-
-    Display* display = static_cast<Display*>(g_display);
-    const int pbuffer_attributes[] = {
-        GLX_PBUFFER_WIDTH, m_size.width(),
-        GLX_PBUFFER_HEIGHT, m_size.height(),
-        GLX_LARGEST_PBUFFER, x11::False,
-        GLX_PRESERVED_CONTENTS, x11::False,
-        GLX_NONE
-    };
-
-    m_surfaceBuffer = glXCreatePbuffer(display, static_cast<GLXFBConfig>(g_config), pbuffer_attributes);
-    m_format = format;
-
-    if (!m_surfaceBuffer) {
-        Destroy();
-        LOG(ERROR) << "glXCreatePbuffer failed.";
-        return false;
-    }
-    return true;
-}
-
-void GLSurfaceQtGLX::Destroy()
-{
-    if (m_surfaceBuffer) {
-        glXDestroyPbuffer(static_cast<Display*>(g_display), m_surfaceBuffer);
-        m_surfaceBuffer = 0;
-    }
-}
-
-GLSurfaceQtGLX::GLSurfaceQtGLX(const gfx::Size& size)
-    : GLSurfaceQt(size),
-      m_surfaceBuffer(0)
-{
-}
-
-void* GLSurfaceQtGLX::GetHandle()
+GLSurfaceQt::~GLSurfaceQt()
 {
-    return reinterpret_cast<void*>(m_surfaceBuffer);
 }
 
-#elif defined(OS_WIN)
+#if defined(OS_WIN)
 
 class GLSurfaceQtWGL: public GLSurfaceQt {
 public:
@@ -399,128 +157,6 @@ GLSurfaceQt::GLSurfaceQt()
 {
 }
 
-bool GLSurfaceQtEGL::InitializeOneOff()
-{
-    if (s_initialized)
-        return true;
-
-    g_display = GLContextHelper::getEGLDisplay();
-    if (!g_display) {
-        LOG(ERROR) << "GLContextHelper::getEGLDisplay() failed.";
-        return false;
-    }
-
-    g_config = GLContextHelper::getEGLConfig();
-    if (!g_config) {
-        LOG(ERROR) << "GLContextHelper::getEGLConfig() failed.";
-        return false;
-    }
-
-    if (!eglInitialize(g_display, NULL, NULL)) {
-        LOG(ERROR) << "eglInitialize failed with error " << GetLastEGLErrorString();
-        return false;
-    }
-
-    s_initialized = true;
-    return true;
-}
-
-EGLDisplay GLSurfaceEGL::GetHardwareDisplay()
-{
-    return static_cast<EGLDisplay>(g_display);
-}
-
-bool GLSurfaceEGL::IsCreateContextRobustnessSupported()
-{
-    return false;
-}
-
-bool GLSurfaceEGL::IsCreateContextBindGeneratesResourceSupported()
-{
-    return false;
-}
-
-bool GLSurfaceEGL::IsCreateContextWebGLCompatabilitySupported()
-{
-    return false;
-}
-
-bool GLSurfaceEGL::IsEGLContextPrioritySupported()
-{
-    return false;
-}
-
-bool GLSurfaceEGL::IsRobustResourceInitSupported()
-{
-    return false;
-}
-
-bool GLSurfaceEGL::IsDisplayTextureShareGroupSupported()
-{
-    return false;
-}
-
-bool GLSurfaceEGL::IsCreateContextClientArraysSupported()
-{
-    return false;
-}
-
-void GLSurfaceEGL::ShutdownOneOff()
-{
-}
-
-bool GLSurfaceQtEGL::InitializeExtensionSettingsOneOff()
-{
-    if (!s_initialized)
-        return false;
-
-    g_extensions = eglQueryString(g_display, EGL_EXTENSIONS);
-    g_egl_surfaceless_context_supported = ExtensionsContain(g_extensions, "EGL_KHR_surfaceless_context");
-    if (g_egl_surfaceless_context_supported) {
-        scoped_refptr<GLSurface> surface = new GLSurfacelessQtEGL(gfx::Size(1, 1));
-        gl::GLContextAttribs attribs;
-        scoped_refptr<GLContext> context = init::CreateGLContext(
-            NULL, surface.get(), attribs);
-
-        if (!context->MakeCurrent(surface.get()))
-            g_egl_surfaceless_context_supported = false;
-
-        // Ensure context supports GL_OES_surfaceless_context.
-        if (g_egl_surfaceless_context_supported) {
-            g_egl_surfaceless_context_supported = context->HasExtension(
-                "GL_OES_surfaceless_context");
-            context->ReleaseCurrent(surface.get());
-        }
-    }
-
-    return true;
-}
-
-bool GLSurfaceEGL::InitializeExtensionSettingsOneOff()
-{
-    return GLSurfaceQtEGL::InitializeExtensionSettingsOneOff();
-}
-
-const char* GLSurfaceEGL::GetEGLExtensions()
-{
-    return g_extensions;
-}
-
-bool GLSurfaceEGL::HasEGLExtension(const char* name)
-{
-    return ExtensionsContain(GetEGLExtensions(), name);
-}
-
-bool GLSurfaceEGL::InitializeOneOff(EGLNativeDisplayType /*native_display*/)
-{
-    return GLSurfaceQtEGL::InitializeOneOff();
-}
-
-bool GLSurfaceEGL::IsAndroidNativeFenceSyncSupported()
-{
-    return false;
-}
-
 GLSurfaceQt::GLSurfaceQt(const gfx::Size& size)
     : m_size(size)
 {
@@ -535,52 +171,6 @@ bool GLSurfaceQt::HasEGLExtension(const char* name)
     return ExtensionsContain(g_extensions, name);
 }
 
-GLSurfaceQtEGL::GLSurfaceQtEGL(const gfx::Size& size)
-    : GLSurfaceQt(size),
-      m_surfaceBuffer(0)
-{
-}
-
-bool GLSurfaceQtEGL::Initialize(GLSurfaceFormat format)
-{
-    Q_ASSERT(!m_surfaceBuffer);
-    m_format = format;
-
-    EGLDisplay display = g_display;
-    if (!display) {
-        LOG(ERROR) << "Trying to create surface with invalid display.";
-        return false;
-    }
-
-    const EGLint pbuffer_attributes[] = {
-        EGL_WIDTH, m_size.width(),
-        EGL_HEIGHT, m_size.height(),
-        EGL_LARGEST_PBUFFER, EGL_FALSE,
-        EGL_NONE
-    };
-
-    m_surfaceBuffer = eglCreatePbufferSurface(display,
-                                        g_config,
-                                        pbuffer_attributes);
-    if (!m_surfaceBuffer) {
-        LOG(ERROR) << "eglCreatePbufferSurface failed with error " << GetLastEGLErrorString();
-        Destroy();
-        return false;
-    }
-
-    return true;
-}
-
-void GLSurfaceQtEGL::Destroy()
-{
-    if (m_surfaceBuffer) {
-        if (!eglDestroySurface(g_display, m_surfaceBuffer))
-            LOG(ERROR) << "eglDestroySurface failed with error " << GetLastEGLErrorString();
-
-        m_surfaceBuffer = 0;
-    }
-}
-
 bool GLSurfaceQt::IsOffscreen()
 {
     return true;
@@ -598,43 +188,11 @@ gfx::Size GLSurfaceQt::GetSize()
     return m_size;
 }
 
-
 GLSurfaceFormat GLSurfaceQt::GetFormat()
 {
     return m_format;
 }
 
-
-bool GLSurfaceQtEGL::Resize(const gfx::Size& size, float scale_factor, ColorSpace /*color_space*/, bool has_alpha)
-{
-    if (size == m_size)
-        return true;
-
-    GLContext *currentContext = GLContext::GetCurrent();
-    bool wasCurrent = currentContext && currentContext->IsCurrent(this);
-    if (wasCurrent)
-        currentContext->ReleaseCurrent(this);
-
-    Destroy();
-
-    m_size = size;
-
-    if (!Initialize(GetFormat())) {
-        LOG(ERROR) << "Failed to resize pbuffer.";
-        return false;
-    }
-
-    if (wasCurrent)
-        return currentContext->MakeCurrent(this);
-
-    return true;
-}
-
-void* GLSurfaceQtEGL::GetHandle()
-{
-    return reinterpret_cast<void*>(m_surfaceBuffer);
-}
-
 void* GLSurfaceQt::GetDisplay()
 {
     return g_display;
@@ -645,42 +203,6 @@ void* GLSurfaceQt::GetConfig()
     return g_config;
 }
 
-GLSurfacelessQtEGL::GLSurfacelessQtEGL(const gfx::Size& size)
-    : GLSurfaceQt(size)
-{
-}
-
-bool GLSurfacelessQtEGL::Initialize(GLSurfaceFormat format)
-{
-    m_format = format;
-    return true;
-}
-
-void GLSurfacelessQtEGL::Destroy()
-{
-}
-
-bool GLSurfacelessQtEGL::IsSurfaceless() const
-{
-    return true;
-}
-
-bool GLSurfacelessQtEGL::Resize(const gfx::Size& size, float scale_factor, ColorSpace color_space, bool has_alpha)
-{
-    m_size = size;
-    return true;
-}
-
-EGLSurface GLSurfacelessQtEGL::GetHandle()
-{
-    return EGL_NO_SURFACE;
-}
-
-void* GLSurfacelessQtEGL::GetShareHandle()
-{
-    return NULL;
-}
-
 namespace init {
 
 bool InitializeGLOneOffPlatform()
@@ -693,17 +215,17 @@ bool InitializeGLOneOffPlatform()
         return false;
 
     if (GetGLImplementation() == kGLImplementationEGLGLES2)
-        return GLSurfaceQtEGL::InitializeOneOff();
+        return GLSurfaceEGLQt::InitializeOneOff();
 
     if (GetGLImplementation() == kGLImplementationDesktopGL) {
 #if defined(OS_WIN)
         return GLSurfaceQtWGL::InitializeOneOff();
 #elif defined(USE_X11)
-        if (GLSurfaceQtGLX::InitializeOneOff())
+        if (GLSurfaceGLXQt::InitializeOneOff())
             return true;
 #endif
         // Fallback to trying EGL with desktop GL.
-        if (GLSurfaceQtEGL::InitializeOneOff()) {
+        if (GLSurfaceEGLQt::InitializeOneOff()) {
             g_initializedEGL = true;
             return true;
         }
@@ -731,7 +253,7 @@ CreateOffscreenGLSurfaceWithFormat(const gfx::Size& size, GLSurfaceFormat format
         break;
 #elif defined(USE_X11)
         if (!g_initializedEGL) {
-            surface = new GLSurfaceQtGLX(size);
+            surface = new GLSurfaceGLXQt(size);
             if (surface->Initialize(format))
                 return surface;
         }
@@ -739,14 +261,14 @@ CreateOffscreenGLSurfaceWithFormat(const gfx::Size& size, GLSurfaceFormat format
 #endif
     }
     case kGLImplementationEGLGLES2: {
-        surface = new GLSurfaceQtEGL(size);
+        surface = new GLSurfaceEGLQt(size);
         if (surface->Initialize(format))
             return surface;
 
         // Surfaceless context will be used ONLY if pseudo surfaceless context
         // is not available since some implementations of surfaceless context
         // have problems. (e.g. QTBUG-57290)
-        if (g_egl_surfaceless_context_supported) {
+        if (GLSurfaceEGLQt::g_egl_surfaceless_context_supported) {
             surface = new GLSurfacelessQtEGL(size);
             if (surface->Initialize(format))
                 return surface;
@@ -770,18 +292,6 @@ CreateViewGLSurface(gfx::AcceleratedWidget window)
 }
 
 } // namespace init
-
-std::string DriverEGL::GetPlatformExtensions()
-{
-    EGLDisplay display = GLContextHelper::getEGLDisplay();
-    if (display == EGL_NO_DISPLAY)
-        return "";
-
-    DCHECK(g_driver_egl.fn.eglQueryStringFn);
-    const char* str = g_driver_egl.fn.eglQueryStringFn(display, EGL_EXTENSIONS);
-    return str ? std::string(str) : "";
-}
-
 }  // namespace gl
 
 namespace gpu {
diff --git a/src/core/gl_surface_qt.h b/src/core/gl_surface_qt.h
index ceb8cbba3..514527df9 100644
--- a/src/core/gl_surface_qt.h
+++ b/src/core/gl_surface_qt.h
@@ -68,6 +68,11 @@ protected:
     gfx::Size m_size;
     GLSurfaceFormat m_format;
 
+public:
+    static void* g_config;
+    static void* g_display;
+    static const char* g_extensions;
+
 private:
     DISALLOW_COPY_AND_ASSIGN(GLSurfaceQt);
 };
diff --git a/src/core/ozone/gl_surface_egl_qt.cpp b/src/core/ozone/gl_surface_egl_qt.cpp
new file mode 100644
index 000000000..0f21b8dfe
--- /dev/null
+++ b/src/core/ozone/gl_surface_egl_qt.cpp
@@ -0,0 +1,318 @@
+/****************************************************************************
+**
+** 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 (c) 2012 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_context_qt.h"
+#include "ozone/gl_surface_egl_qt.h"
+
+#if !defined(OS_MACOSX)
+#include "ui/gl/gl_surface_egl.h"
+#include "ui/gl/egl_util.h"
+#include "ui/gl/init/gl_factory.h"
+
+// From ANGLE's egl/eglext.h.
+#ifndef EGL_ANGLE_surface_d3d_texture_2d_share_handle
+#define EGL_ANGLE_surface_d3d_texture_2d_share_handle 1
+#define EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE 0x3200
+#endif
+
+using ui::GetLastEGLErrorString;
+
+namespace gl{
+
+bool GLSurfaceEGLQt::g_egl_surfaceless_context_supported = false;
+bool GLSurfaceEGLQt::s_initialized = false;
+
+GLSurfaceEGLQt::~GLSurfaceEGLQt()
+{
+    Destroy();
+}
+
+bool GLSurfaceEGLQt::InitializeOneOff()
+{
+    if (s_initialized)
+        return true;
+
+    g_display = GLContextHelper::getEGLDisplay();
+    if (!g_display) {
+        LOG(ERROR) << "GLContextHelper::getEGLDisplay() failed.";
+        return false;
+    }
+
+    g_config = GLContextHelper::getEGLConfig();
+    if (!g_config) {
+        LOG(ERROR) << "GLContextHelper::getEGLConfig() failed.";
+        return false;
+    }
+
+    if (!eglInitialize(g_display, NULL, NULL)) {
+        LOG(ERROR) << "eglInitialize failed with error " << GetLastEGLErrorString();
+        return false;
+    }
+
+    s_initialized = true;
+    return true;
+}
+
+bool GLSurfaceEGLQt::InitializeExtensionSettingsOneOff()
+{
+    if (!s_initialized)
+        return false;
+
+    g_extensions = eglQueryString(g_display, EGL_EXTENSIONS);
+    g_egl_surfaceless_context_supported = ExtensionsContain(g_extensions, "EGL_KHR_surfaceless_context");
+    if (g_egl_surfaceless_context_supported) {
+        scoped_refptr<GLSurface> surface = new GLSurfacelessQtEGL(gfx::Size(1, 1));
+        gl::GLContextAttribs attribs;
+        scoped_refptr<GLContext> context = init::CreateGLContext(
+            NULL, surface.get(), attribs);
+
+        if (!context->MakeCurrent(surface.get()))
+            g_egl_surfaceless_context_supported = false;
+
+        // Ensure context supports GL_OES_surfaceless_context.
+        if (g_egl_surfaceless_context_supported) {
+            g_egl_surfaceless_context_supported = context->HasExtension(
+                "GL_OES_surfaceless_context");
+            context->ReleaseCurrent(surface.get());
+        }
+    }
+
+    return true;
+}
+
+bool GLSurfaceEGL::InitializeExtensionSettingsOneOff()
+{
+    return GLSurfaceEGLQt::InitializeExtensionSettingsOneOff();
+}
+
+EGLDisplay GLSurfaceEGL::GetHardwareDisplay()
+{
+    return static_cast<EGLDisplay>(GLSurfaceQt::g_display);
+}
+
+bool GLSurfaceEGL::IsCreateContextRobustnessSupported()
+{
+    return false;
+}
+
+bool GLSurfaceEGL::IsCreateContextBindGeneratesResourceSupported()
+{
+    return false;
+}
+
+bool GLSurfaceEGL::IsCreateContextWebGLCompatabilitySupported()
+{
+    return false;
+}
+
+bool GLSurfaceEGL::IsEGLContextPrioritySupported()
+{
+    return false;
+}
+
+bool GLSurfaceEGL::IsRobustResourceInitSupported()
+{
+    return false;
+}
+
+bool GLSurfaceEGL::IsDisplayTextureShareGroupSupported()
+{
+    return false;
+}
+
+bool GLSurfaceEGL::IsCreateContextClientArraysSupported()
+{
+    return false;
+}
+
+void GLSurfaceEGL::ShutdownOneOff()
+{
+}
+
+const char* GLSurfaceEGL::GetEGLExtensions()
+{
+    return GLSurfaceQt::g_extensions;
+}
+
+bool GLSurfaceEGL::HasEGLExtension(const char* name)
+{
+    return ExtensionsContain(GetEGLExtensions(), name);
+}
+
+bool GLSurfaceEGL::InitializeOneOff(EGLNativeDisplayType /*native_display*/)
+{
+    return GLSurfaceEGLQt::InitializeOneOff();
+}
+
+bool GLSurfaceEGL::IsAndroidNativeFenceSyncSupported()
+{
+     return false;
+}
+
+GLSurfaceEGLQt::GLSurfaceEGLQt(const gfx::Size& size)
+    : GLSurfaceQt(size),
+      m_surfaceBuffer(0)
+{
+}
+
+bool GLSurfaceEGLQt::Initialize(GLSurfaceFormat format)
+{
+    Q_ASSERT(!m_surfaceBuffer);
+    m_format = format;
+
+    EGLDisplay display = g_display;
+    if (!display) {
+        LOG(ERROR) << "Trying to create surface with invalid display.";
+        return false;
+    }
+
+    const EGLint pbuffer_attributes[] = {
+        EGL_WIDTH, m_size.width(),
+        EGL_HEIGHT, m_size.height(),
+        EGL_LARGEST_PBUFFER, EGL_FALSE,
+        EGL_NONE
+    };
+
+    m_surfaceBuffer = eglCreatePbufferSurface(display,
+                                        g_config,
+                                        pbuffer_attributes);
+    if (!m_surfaceBuffer) {
+        LOG(ERROR) << "eglCreatePbufferSurface failed with error " << GetLastEGLErrorString();
+        Destroy();
+        return false;
+    }
+
+    return true;
+}
+
+void GLSurfaceEGLQt::Destroy()
+{
+    if (m_surfaceBuffer) {
+        if (!eglDestroySurface(g_display, m_surfaceBuffer))
+            LOG(ERROR) << "eglDestroySurface failed with error " << GetLastEGLErrorString();
+
+        m_surfaceBuffer = 0;
+    }
+}
+
+bool GLSurfaceEGLQt::Resize(const gfx::Size& size, float scale_factor,
+                             ColorSpace color_space, bool has_alpha)
+{
+    if (size == m_size)
+        return true;
+
+    GLContext *currentContext = GLContext::GetCurrent();
+    bool wasCurrent = currentContext && currentContext->IsCurrent(this);
+    if (wasCurrent)
+        currentContext->ReleaseCurrent(this);
+
+    Destroy();
+
+    m_size = size;
+
+    if (!Initialize(GetFormat())) {
+        LOG(ERROR) << "Failed to resize pbuffer.";
+        return false;
+    }
+
+    if (wasCurrent)
+        return currentContext->MakeCurrent(this);
+
+    return true;
+}
+
+void* GLSurfaceEGLQt::GetHandle()
+{
+    return reinterpret_cast<void*>(m_surfaceBuffer);
+}
+
+GLSurfacelessQtEGL::GLSurfacelessQtEGL(const gfx::Size& size)
+    : GLSurfaceQt(size)
+{
+}
+
+bool GLSurfacelessQtEGL::Initialize(GLSurfaceFormat format)
+{
+    m_format = format;
+    return true;
+}
+
+void GLSurfacelessQtEGL::Destroy()
+{
+}
+
+bool GLSurfacelessQtEGL::IsSurfaceless() const
+{
+    return true;
+}
+
+bool GLSurfacelessQtEGL::Resize(const gfx::Size& size, float scale_factor,
+                                ColorSpace color_space,  bool has_alpha)
+{
+    m_size = size;
+    return true;
+}
+
+EGLSurface GLSurfacelessQtEGL::GetHandle()
+{
+    return EGL_NO_SURFACE;
+}
+
+void* GLSurfacelessQtEGL::GetShareHandle()
+{
+    return NULL;
+}
+
+std::string DriverEGL::GetPlatformExtensions()
+{
+    EGLDisplay display = GLContextHelper::getEGLDisplay();
+    if (display == EGL_NO_DISPLAY)
+        return "";
+
+    DCHECK(g_driver_egl.fn.eglQueryStringFn);
+    const char* str = g_driver_egl.fn.eglQueryStringFn(display, EGL_EXTENSIONS);
+    return str ? std::string(str) : "";
+}
+
+}  // namespace gl
+#endif // !defined(OS_MACOSX)
diff --git a/src/core/ozone/gl_surface_egl_qt.h b/src/core/ozone/gl_surface_egl_qt.h
new file mode 100644
index 000000000..ecc2327b3
--- /dev/null
+++ b/src/core/ozone/gl_surface_egl_qt.h
@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** 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 GL_SURFACE_EGL_QT_H_
+#define GL_SURFACE_EGL_QT_H_
+
+#include "gl_surface_qt.h"
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+
+namespace gl {
+
+class GLSurfaceEGLQt: public GLSurfaceQt {
+public:
+    explicit GLSurfaceEGLQt(const gfx::Size& size);
+
+    static bool InitializeOneOff();
+    static bool InitializeExtensionSettingsOneOff();
+
+    bool Initialize(GLSurfaceFormat format) override;
+    void Destroy() override;
+    void* GetHandle() override;
+    bool Resize(const gfx::Size& size, float scale_factor,
+                ColorSpace color_space, bool has_alpha) override;
+
+protected:
+    ~GLSurfaceEGLQt();
+
+public:
+   static bool g_egl_surfaceless_context_supported;
+
+private:
+   EGLSurface m_surfaceBuffer;
+   static bool s_initialized;
+   DISALLOW_COPY_AND_ASSIGN(GLSurfaceEGLQt);
+};
+
+// The following comment is cited from chromium/ui/gl/gl_surface_egl.cc:
+// SurfacelessEGL is used as Offscreen surface when platform supports
+// KHR_surfaceless_context and GL_OES_surfaceless_context. This would avoid the
+// need to create a dummy EGLsurface in case we render to client API targets.
+
+class GLSurfacelessQtEGL : public GLSurfaceQt {
+public:
+    explicit GLSurfacelessQtEGL(const gfx::Size& size);
+
+public:
+    bool Initialize(GLSurfaceFormat format) override;
+    void Destroy() override;
+    bool IsSurfaceless() const override;
+    bool Resize(const gfx::Size& size, float scale_factor,
+                ColorSpace color_space, bool has_alpha) override;
+    EGLSurface GetHandle() override;
+    void* GetShareHandle() override;
+
+private:
+    DISALLOW_COPY_AND_ASSIGN(GLSurfacelessQtEGL);
+};
+}
+
+#endif
diff --git a/src/core/ozone/gl_surface_glx_qt.cpp b/src/core/ozone/gl_surface_glx_qt.cpp
new file mode 100644
index 000000000..51b0f58b0
--- /dev/null
+++ b/src/core/ozone/gl_surface_glx_qt.cpp
@@ -0,0 +1,213 @@
+/****************************************************************************
+**
+** 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 (c) 2012 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.
+
+#if defined(USE_X11)
+
+#include "gl_context_qt.h"
+#include "ozone/gl_surface_glx_qt.h"
+#include "ui/gl/gl_bindings.h"
+#include "ui/gl/gl_surface_glx.h"
+#include <GL/glx.h>
+#include <GL/glxext.h>
+
+namespace gl {
+
+bool GLSurfaceGLXQt::s_initialized = false;
+
+GLSurfaceGLXQt::~GLSurfaceGLXQt()
+{
+    Destroy();
+}
+
+void GLSurfaceGLX::ShutdownOneOff()
+{
+}
+
+bool GLSurfaceGLX::IsCreateContextSupported()
+{
+    return ExtensionsContain(GLSurfaceQt::g_extensions, "GLX_ARB_create_context");
+}
+
+bool GLSurfaceGLX::IsCreateContextRobustnessSupported()
+{
+    return false; // ExtensionsContain(g_extensions, "GLX_ARB_create_context_robustness");
+}
+
+bool GLSurfaceGLX::IsEXTSwapControlSupported()
+{
+    return HasGLXExtension("GLX_EXT_swap_control");
+}
+
+bool GLSurfaceGLX::IsMESASwapControlSupported()
+{
+    return HasGLXExtension("GLX_MESA_swap_control");
+}
+
+bool GLSurfaceGLX::IsCreateContextProfileSupported()
+{
+    return false; // ExtensionsContain(g_extensions, "GLX_ARB_create_context_profile");
+}
+
+bool GLSurfaceGLX::IsCreateContextES2ProfileSupported()
+{
+    return ExtensionsContain(GLSurfaceQt::g_extensions, "GLX_ARB_create_context_es2_profile");
+}
+
+bool GLSurfaceGLX::IsOMLSyncControlSupported()
+{
+    return false; // ExtensionsContain(g_extensions, "GLX_OML_sync_control");
+}
+
+bool GLSurfaceGLX::HasGLXExtension(const char *name)
+{
+    return ExtensionsContain(GLSurfaceQt::g_extensions, name);
+}
+
+bool GLSurfaceGLX::IsTextureFromPixmapSupported()
+{
+    return ExtensionsContain(GLSurfaceQt::g_extensions, "GLX_EXT_texture_from_pixmap");
+}
+
+const char* GLSurfaceGLX::GetGLXExtensions()
+{
+    return GLSurfaceQt::g_extensions;
+}
+
+bool GLSurfaceGLXQt::InitializeOneOff()
+{
+    if (s_initialized)
+        return true;
+
+    XInitThreads();
+
+    g_display = GLContextHelper::getXDisplay();
+    if (!g_display) {
+        LOG(ERROR) << "GLContextHelper::getXDisplay() failed.";
+        return false;
+    }
+
+    g_config = GLContextHelper::getXConfig();
+    if (!g_config) {
+        LOG(ERROR) << "GLContextHelper::getXConfig() failed.";
+        return false;
+    }
+
+    Display* display = static_cast<Display*>(g_display);
+    int major, minor;
+    if (!glXQueryVersion(display, &major, &minor)) {
+        LOG(ERROR) << "glxQueryVersion failed.";
+        return false;
+    }
+
+    if (major == 1 && minor < 3) {
+        LOG(ERROR) << "GLX 1.3 or later is required.";
+        return false;
+    }
+
+    s_initialized = true;
+    return true;
+}
+
+
+bool GLSurfaceGLXQt::InitializeExtensionSettingsOneOff()
+{
+    if (!s_initialized)
+        return false;
+
+    Display* display = static_cast<Display*>(g_display);
+    GLSurfaceQt::g_extensions = glXQueryExtensionsString(display, 0);
+    g_driver_glx.InitializeExtensionBindings();
+    return true;
+}
+
+bool GLSurfaceGLX::InitializeExtensionSettingsOneOff()
+{
+    return GLSurfaceGLXQt::InitializeExtensionSettingsOneOff();
+}
+
+bool GLSurfaceGLXQt::Initialize(GLSurfaceFormat format)
+{
+    Q_ASSERT(!m_surfaceBuffer);
+
+    Display* display = static_cast<Display*>(g_display);
+    const int pbuffer_attributes[] = {
+        GLX_PBUFFER_WIDTH, m_size.width(),
+        GLX_PBUFFER_HEIGHT, m_size.height(),
+        GLX_LARGEST_PBUFFER, x11::False,
+        GLX_PRESERVED_CONTENTS, x11::False,
+        GLX_NONE
+    };
+
+    m_surfaceBuffer = glXCreatePbuffer(display, static_cast<GLXFBConfig>(g_config), pbuffer_attributes);
+    m_format = format;
+
+    if (!m_surfaceBuffer) {
+        Destroy();
+        LOG(ERROR) << "glXCreatePbuffer failed.";
+        return false;
+    }
+    return true;
+}
+
+void GLSurfaceGLXQt::Destroy()
+{
+    if (m_surfaceBuffer) {
+        glXDestroyPbuffer(static_cast<Display*>(g_display), m_surfaceBuffer);
+        m_surfaceBuffer = 0;
+    }
+}
+
+GLSurfaceGLXQt::GLSurfaceGLXQt(const gfx::Size& size)
+    : GLSurfaceQt(size),
+      m_surfaceBuffer(0)
+{
+}
+
+void* GLSurfaceGLXQt::GetHandle()
+{
+    return reinterpret_cast<void*>(m_surfaceBuffer);
+}
+
+} //namespace gl
+
+#endif // defined(USE_X11)
diff --git a/src/core/ozone/gl_surface_glx_qt.h b/src/core/ozone/gl_surface_glx_qt.h
new file mode 100644
index 000000000..3a465f448
--- /dev/null
+++ b/src/core/ozone/gl_surface_glx_qt.h
@@ -0,0 +1,72 @@
+/****************************************************************************
+**
+** 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 GL_SURFACE_GLX_QT_H_
+#define GL_SURFACE_GLX_QT_H_
+
+#include "gl_surface_qt.h"
+
+extern "C" {
+#include <X11/Xlib.h>
+}
+
+namespace gl {
+
+class GLSurfaceGLXQt: public GLSurfaceQt {
+public:
+    explicit GLSurfaceGLXQt(const gfx::Size& size);
+
+    static bool InitializeOneOff();
+    static bool InitializeExtensionSettingsOneOff();
+
+    bool Initialize(GLSurfaceFormat format) override;
+    void Destroy() override;
+    void* GetHandle() override;
+
+protected:
+    ~GLSurfaceGLXQt();
+
+private:
+    static bool s_initialized;
+    XID m_surfaceBuffer;
+    DISALLOW_COPY_AND_ASSIGN(GLSurfaceGLXQt);
+};
+
+}
+#endif