gl: Move platform-specific EGL code into separate files

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.
 
 // This include must be here so that the includes provided transitively
 // by gl_surface_egl.h don't make it impossible to compile this code.
 #include "third_party/mesa/src/include/GL/osmesa.h"
 
 #include "ui/gl/gl_surface_egl.h"
 
 #if defined(OS_ANDROID)
 #include <android/native_window_jni.h>
 #include "base/android/sys_utils.h"
 #endif
 
-#include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/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_osmesa.h"
 #include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/scoped_make_current.h"
 #include "ui/gl/sync_control_vsync_provider.h"
 
 #if defined(USE_X11)
 extern "C" {
 #include <X11/Xlib.h>
 }
 #endif
 
 #if defined (USE_OZONE)
 #include "ui/gfx/ozone/surface_factory_ozone.h"
 #endif
 
-// From ANGLE's egl/eglext.h.
-#if !defined(EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE)
-#define EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE \
-    reinterpret_cast<EGLNativeDisplayType>(-2)
-#endif
 #if !defined(EGL_FIXED_SIZE_ANGLE)
 #define EGL_FIXED_SIZE_ANGLE 0x3201
 #endif
 
 using ui::GetLastEGLErrorString;
 
 namespace gfx {
 
 namespace {
 
@@ skipping 64 matching lines @@
 
 }  // namespace
 
 GLSurfaceEGL::GLSurfaceEGL() {}
 
 bool GLSurfaceEGL::InitializeOneOff() {
   static bool initialized = false;
   if (initialized)
     return true;
 
-#if defined(USE_X11)
-  g_native_display = base::MessagePumpForUI::GetDefaultXDisplay();
-#elif defined(OS_WIN)
-  g_native_display = EGL_DEFAULT_DISPLAY;
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableD3D11)) {
-    g_native_display = EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE;
-  }
-#elif defined(USE_OZONE)
-  gfx::SurfaceFactoryOzone* surface_factory =
-      gfx::SurfaceFactoryOzone::GetInstance();
-  if (surface_factory->InitializeHardware() !=
-      gfx::SurfaceFactoryOzone::INITIALIZED) {
-    LOG(ERROR) << "OZONE failed to initialize hardware";
-    return false;
-  }
-  g_native_display = surface_factory->GetNativeDisplay();
-#else
-  g_native_display = EGL_DEFAULT_DISPLAY;
-#endif
+  g_native_display = GetPlatformDefaultEGLNativeDisplay();
   g_display = eglGetDisplay(g_native_display);
   if (!g_display) {
     LOG(ERROR) << "eglGetDisplay failed with error " << GetLastEGLErrorString();
     return false;
   }
 
   if (!eglInitialize(g_display, NULL, NULL)) {
     LOG(ERROR) << "eglInitialize failed with error " << GetLastEGLErrorString();
     return false;
   }
@@ skipping 25 matching lines @@
   EGLint* choose_attributes = config_attribs_8888;
 
 #if defined(OS_ANDROID)
   if (base::android::SysUtils::IsLowEndDevice()) {
     choose_attributes = config_attribs_565;
   }
 #endif
 
 #if defined(USE_OZONE)
   const EGLint* config_attribs =
-      surface_factory->GetEGLSurfaceProperties(choose_attributes);
+      SurfaceFactoryOzone::GetInstance()->GetEGLSurfaceProperties(
+          choose_attributes);
 #else
   const EGLint* config_attribs = choose_attributes;
 #endif
 
   EGLint num_configs;
   EGLint config_size = 1;
   EGLConfig* config_data = &g_config;
   // Validate if there are any configs for given atrribs.
   if (!ValidateEglConfig(g_display,
                          config_attribs,
@@ skipping 115 matching lines @@
 }
 
 bool GLSurfaceEGL::HasEGLExtension(const char* name) {
   return ExtensionsContain(GetEGLExtensions(), name);
 }
 
 bool GLSurfaceEGL::IsCreateContextRobustnessSupported() {
   return g_egl_create_context_robustness_supported;
 }
 
+bool GLSurfaceEGL::IsEGLSurfacelessContextSupported() {
+  return g_egl_surfaceless_context_supported;
+}
+
 GLSurfaceEGL::~GLSurfaceEGL() {}
 
 NativeViewGLSurfaceEGL::NativeViewGLSurfaceEGL(EGLNativeWindowType window)
     : window_(window),
       surface_(NULL),
       supports_post_sub_buffer_(false),
       config_(NULL),
       size_(1, 1) {
 #if defined(OS_ANDROID)
   if (window)
@@ skipping 408 matching lines @@
   return EGL_NO_SURFACE;
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
-#if defined(ANDROID) || defined(USE_OZONE)
-
-// A thin subclass of |GLSurfaceOSMesa| that can be used in place
-// of a native hardware-provided surface when a native surface
-// provider is not available.
-class GLSurfaceOSMesaHeadless : public GLSurfaceOSMesa {
- public:
-  explicit GLSurfaceOSMesaHeadless();
-
-  virtual bool IsOffscreen() OVERRIDE;
-  virtual bool SwapBuffers() OVERRIDE;
-
- protected:
-  virtual ~GLSurfaceOSMesaHeadless();
-
- private:
-
-  DISALLOW_COPY_AND_ASSIGN(GLSurfaceOSMesaHeadless);
-};
-
-bool GLSurfaceOSMesaHeadless::IsOffscreen() { return false; }
-
-bool GLSurfaceOSMesaHeadless::SwapBuffers() { return true; }
-
-GLSurfaceOSMesaHeadless::GLSurfaceOSMesaHeadless()
-    : GLSurfaceOSMesa(OSMESA_BGRA, gfx::Size(1, 1)) {}
-
-GLSurfaceOSMesaHeadless::~GLSurfaceOSMesaHeadless() { Destroy(); }
-
-// static
-bool GLSurface::InitializeOneOffInternal() {
-  switch (GetGLImplementation()) {
-    case kGLImplementationEGLGLES2:
-      if (!GLSurfaceEGL::InitializeOneOff()) {
-        LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
-        return false;
-      }
-    default:
-      break;
-  }
-  return true;
-}
-
-// static
-scoped_refptr<GLSurface>
-GLSurface::CreateViewGLSurface(gfx::AcceleratedWidget window) {
-
-  if (GetGLImplementation() == kGLImplementationOSMesaGL) {
-    scoped_refptr<GLSurface> surface(new GLSurfaceOSMesaHeadless());
-    if (!surface->Initialize())
-      return NULL;
-    return surface;
-  }
-  DCHECK(GetGLImplementation() == kGLImplementationEGLGLES2);
-  if (window != kNullAcceleratedWidget) {
-    EGLNativeWindowType egl_window;
-    scoped_refptr<NativeViewGLSurfaceEGL> surface;
-    scoped_ptr<VSyncProvider> sync_provider;
-#if defined(USE_OZONE)
-    egl_window =
-        gfx::SurfaceFactoryOzone::GetInstance()->RealizeAcceleratedWidget(
-            window);
-    sync_provider =
-        gfx::SurfaceFactoryOzone::GetInstance()->CreateVSyncProvider(
-            egl_window);
-#else
-    egl_window = window;
-#endif
-    surface = new NativeViewGLSurfaceEGL(egl_window);
-    if(surface->Initialize(sync_provider.Pass()))
-      return surface;
-  } else {
-    scoped_refptr<GLSurface> surface = new GLSurfaceStub();
-    if (surface->Initialize())
-      return surface;
-  }
-  return NULL;
-}
-
-// static
-scoped_refptr<GLSurface>
-GLSurface::CreateOffscreenGLSurface(const gfx::Size& size) {
-  switch (GetGLImplementation()) {
-    case kGLImplementationOSMesaGL: {
-      scoped_refptr<GLSurface> surface(new GLSurfaceOSMesa(1, size));
-      if (!surface->Initialize())
-        return NULL;
-
-      return surface;
-    }
-    case kGLImplementationEGLGLES2: {
-      scoped_refptr<GLSurface> surface;
-      if (g_egl_surfaceless_context_supported &&
-         (size.width() == 0 && size.height() == 0)) {
-        surface = new SurfacelessEGL(size);
-      } else
-        surface = new PbufferGLSurfaceEGL(size);
-
-      if (!surface->Initialize())
-        return NULL;
-      return surface;
-    }
-    default:
-      NOTREACHED();
-      return NULL;
-  }
-}
-
-#endif
-
 }  // namespace gfx