Add a factory and defines for native Linux surfaces.

ui/gl/gl_surface_egl.cc

 // 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 "ui/gl/gl_surface_egl.h"
 
 #if defined(OS_ANDROID)
 #include <android/native_window_jni.h>
 #endif
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "build/build_config.h"
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_context.h"
+#include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_surface_stub.h"
 
 #if defined(USE_X11)
 extern "C" {
 #include <X11/Xlib.h>
 }
 #endif
 
+#if defined (USE_OZONE)
+#include "ui/base/ozone/surface_factory_ozone.h"
+#endif
+
 using ui::GetLastEGLErrorString;
 
 namespace gfx {
 
 namespace {
 
 EGLConfig g_config;
 EGLDisplay g_display;
 EGLNativeDisplayType g_native_display;
 EGLConfig g_software_config;
@@ skipping 42 matching lines @@
 
 }  // namespace
 
 GLSurfaceEGL::GLSurfaceEGL() : software_(false) {}
 
 bool GLSurfaceEGL::InitializeOneOff() {
   static bool initialized = false;
   if (initialized)
     return true;
 
+#if defined (USE_OZONE)
+  ui::SurfaceFactoryOzone::GetInstance()->InitializeHardware();
+#endif
+
 #if defined(USE_X11)
   g_native_display = base::MessagePumpForUI::GetDefaultXDisplay();
 #else
   g_native_display = EGL_DEFAULT_DISPLAY;
 #endif
   g_display = eglGetDisplay(g_native_display);
   if (!g_display) {
     LOG(ERROR) << "eglGetDisplay failed with error " << GetLastEGLErrorString();
     return false;
   }
@@ skipping 43 matching lines @@
   }
 
   g_egl_extensions = eglQueryString(g_display, EGL_EXTENSIONS);
   g_egl_create_context_robustness_supported =
       HasEGLExtension("EGL_EXT_create_context_robustness");
   g_egl_sync_control_supported =
       HasEGLExtension("EGL_CHROMIUM_sync_control");
 
   initialized = true;
 
-#if defined(USE_X11) || defined(OS_ANDROID)
+#if defined(USE_X11) || defined(OS_ANDROID) \
+    || defined(USE_OZONE)
   return true;
 #else
   g_software_native_display = EGL_SOFTWARE_DISPLAY_ANGLE;
 #endif
   g_software_display = eglGetDisplay(g_software_native_display);
   if (!g_software_display) {
     return true;
   }
 
   if (!eglInitialize(g_software_display, NULL, NULL)) {
@@ skipping 63 matching lines @@
       supports_post_sub_buffer_(false),
       config_(NULL) {
   software_ = software;
 #if defined(OS_ANDROID)
   if (window)
     ANativeWindow_acquire(window);
 #endif
 }
 
 bool NativeViewGLSurfaceEGL::Initialize() {
+  return Initialize(NULL);
+}
+
+bool NativeViewGLSurfaceEGL::Initialize(VSyncProvider* sync_provider) {
   DCHECK(!surface_);
 
   if (window_ == kNullAcceleratedWidget) {
     LOG(ERROR) << "Trying to create surface without window.";
     return false;
   }
 
   if (!GetDisplay()) {
     LOG(ERROR) << "Trying to create surface with invalid display.";
     return false;
@@ skipping 20 matching lines @@
     return false;
   }
 
   EGLint surfaceVal;
   EGLBoolean retVal = eglQuerySurface(GetDisplay(),
                                       surface_,
                                       EGL_POST_SUB_BUFFER_SUPPORTED_NV,
                                       &surfaceVal);
   supports_post_sub_buffer_ = (surfaceVal && retVal) == EGL_TRUE;
 
-  if (g_egl_sync_control_supported)
+  if (sync_provider)
+    vsync_provider_.reset(sync_provider);
+  else if (g_egl_sync_control_supported)
     vsync_provider_.reset(new EGLSyncControlVSyncProvider(surface_));
-
   return true;
 }
 
 void NativeViewGLSurfaceEGL::Destroy() {
   if (surface_) {
     if (!eglDestroySurface(GetDisplay(), surface_)) {
       LOG(ERROR) << "eglDestroySurface failed with error "
                  << GetLastEGLErrorString();
     }
     surface_ = NULL;
@@ skipping 292 matching lines @@
   }
 
   return handle;
 #endif
 }
 
 PbufferGLSurfaceEGL::~PbufferGLSurfaceEGL() {
   Destroy();
 }
 
+#if defined(ANDROID) || defined(USE_OZONE)
+
+// static
+bool GLSurface::InitializeOneOffInternal() {
+  DCHECK(GetGLImplementation() == kGLImplementationEGLGLES2);
+
+  if (!GLSurfaceEGL::InitializeOneOff()) {
+    LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
+    return false;
+  }
+  return true;
+}
+
+// static
+scoped_refptr<GLSurface>
+GLSurface::CreateViewGLSurface(bool software, gfx::AcceleratedWidget window) {
+  if (software)
+    return NULL;
+
+  DCHECK(GetGLImplementation() == kGLImplementationEGLGLES2);
+  if (window) {
+    scoped_refptr<NativeViewGLSurfaceEGL> surface;
+    VSyncProvider* sync_provider = NULL;
+#if defined(USE_OZONE)
+    window = ui::SurfaceFactoryOzone::GetInstance()->RealizeAcceleratedWidget(
+        window));
+    sync_provider =
+        ui::SurfaceFactoryOzone::GetInstance()->GetVSyncProvider(window);
+#endif
+    surface = new NativeViewGLSurfaceEGL(false, window);
+    if(surface->Initialize(sync_provider))
+      return surface;
+  } else {
+    scoped_refptr<GLSurface> surface = new GLSurfaceStub();
+    if (surface->Initialize())
+      return surface;
+  }
+  return NULL;
+}
+
+// static
+scoped_refptr<GLSurface>
+GLSurface::CreateOffscreenGLSurface(bool software, const gfx::Size& size) {
+  if (software)
+    return NULL;
+
+  switch (GetGLImplementation()) {
+    case kGLImplementationEGLGLES2: {
+      scoped_refptr<PbufferGLSurfaceEGL> surface(
+          new PbufferGLSurfaceEGL(false, size));
+      if (!surface->Initialize())
+        return NULL;
+      return surface;
+    }
+    default:
+      NOTREACHED();
+      return NULL;
+  }
+}
+
+#endif
+
 }  // namespace gfx