Ozone integration.

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
 
@@ skipping 12 matching lines @@
 #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/ozone/public/surface_factory_ozone.h"
+#include "ui/ozone/public/ozone_platform.h" // nogncheck
+#include "ui/ozone/public/surface_factory_ozone.h" // nogncheck
 #endif
 
 #if !defined(EGL_FIXED_SIZE_ANGLE)
 #define EGL_FIXED_SIZE_ANGLE 0x3201
 #endif
 
 #if !defined(EGL_OPENGL_ES3_BIT)
 #define EGL_OPENGL_ES3_BIT 0x00000040
 #endif
 
@@ skipping 91 matching lines @@
                             &win_attribs)) {
     return nullptr;
   }
 #endif
 
   EGLint renderable_type = EGL_OPENGL_ES2_BIT;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableUnsafeES3APIs)) {
     renderable_type = EGL_OPENGL_ES3_BIT;
   }
-  EGLint config_attribs[] = {
+  EGLint kConfigAttribs[] = {
     EGL_BUFFER_SIZE, configuration.alpha_bits +
                      configuration.red_bits +
                      configuration.green_bits +
                      configuration.blue_bits,
     EGL_ALPHA_SIZE, configuration.alpha_bits,
     EGL_BLUE_SIZE, configuration.blue_bits,
     EGL_GREEN_SIZE, configuration.green_bits,
     EGL_RED_SIZE, configuration.red_bits,
     EGL_DEPTH_SIZE, configuration.depth_bits,
     EGL_STENCIL_SIZE, configuration.stencil_bits,
     EGL_RENDERABLE_TYPE, renderable_type,
     EGL_SURFACE_TYPE, (allow_window_bit ?
                         (EGL_WINDOW_BIT | EGL_PBUFFER_BIT) :
                         EGL_PBUFFER_BIT),
     EGL_NONE
   };
 
 #if defined(USE_OZONE)
-  config_attribs =
-      ui::SurfaceFactoryOzone::GetInstance()->GetEGLSurfaceProperties(
-          config_attribs);
+  const EGLint* config_attribs = ui::OzonePlatform::GetInstance()
+    ->GetSurfaceFactoryOzone()
+    ->GetEGLSurfaceProperties(kConfigAttribs);
 #elif defined(USE_X11)
+  EGLint* config_attribs = kConfigAttribs;
   // Try matching the window depth with an alpha channel,
   // because we're worried the destination alpha width could
   // constrain blending precision.
   const int kBufferSizeOffset = 1;
   const int kAlphaSizeOffset = 3;
   config_attribs[kBufferSizeOffset] = win_attribs.depth;
+#else
+  const EGLint* config_attribs = kConfigAttribs;
 #endif
 
   EGLint num_configs;
   if (!eglChooseConfig(g_display,
                        config_attribs,
                        NULL,
                        0,
                        &num_configs)) {
     LOG(ERROR) << "eglChooseConfig failed with error "
                << GetLastEGLErrorString();
@@ skipping 255 matching lines @@
     DCHECK(window_);
     config_ = GetEGLConfig(window_, this->get_surface_configuration(), true);
   }
   return config_;
 }
 
 bool NativeViewGLSurfaceEGL::IsOffscreen() {
   return false;
 }
 
-bool NativeViewGLSurfaceEGL::SwapBuffers() {
+gfx::SwapResult NativeViewGLSurfaceEGL::SwapBuffers() {
   TRACE_EVENT2("gpu", "NativeViewGLSurfaceEGL:RealSwapBuffers",
       "width", GetSize().width(),
       "height", GetSize().height());
 
   if (!eglSwapBuffers(GetDisplay(), surface_)) {
     DVLOG(1) << "eglSwapBuffers failed with error "
              << GetLastEGLErrorString();
-    return false;
+    return gfx::SwapResult::SWAP_FAILED;
   }
 
-  return true;
+  return gfx::SwapResult::SWAP_ACK;
 }
 
 gfx::Size NativeViewGLSurfaceEGL::GetSize() {
   EGLint width;
   EGLint height;
   if (!eglQuerySurface(GetDisplay(), surface_, EGL_WIDTH, &width) ||
       !eglQuerySurface(GetDisplay(), surface_, EGL_HEIGHT, &height)) {
     NOTREACHED() << "eglQuerySurface failed with error "
                  << GetLastEGLErrorString();
     return gfx::Size();
@@ skipping 38 matching lines @@
 }
 
 EGLSurface NativeViewGLSurfaceEGL::GetHandle() {
   return surface_;
 }
 
 bool NativeViewGLSurfaceEGL::SupportsPostSubBuffer() {
   return supports_post_sub_buffer_;
 }
 
-bool NativeViewGLSurfaceEGL::PostSubBuffer(
+gfx::SwapResult NativeViewGLSurfaceEGL::PostSubBuffer(
     int x, int y, int width, int height) {
   DCHECK(supports_post_sub_buffer_);
   if (!eglPostSubBufferNV(GetDisplay(), surface_, x, y, width, height)) {
     DVLOG(1) << "eglPostSubBufferNV failed with error "
              << GetLastEGLErrorString();
-    return false;
+    return gfx::SwapResult::SWAP_FAILED;
   }
-  return true;
+  return gfx::SwapResult::SWAP_ACK;
 }
 
 VSyncProvider* NativeViewGLSurfaceEGL::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 
 void NativeViewGLSurfaceEGL::OnSetSwapInterval(int interval) {
   swap_interval_ = interval;
 }
 
@@ skipping 69 matching lines @@
                            this->get_surface_configuration(),
                            false);
   }
   return config_;
 }
 
 bool PbufferGLSurfaceEGL::IsOffscreen() {
   return true;
 }
 
-bool PbufferGLSurfaceEGL::SwapBuffers() {
+gfx::SwapResult PbufferGLSurfaceEGL::SwapBuffers() {
   NOTREACHED() << "Attempted to call SwapBuffers on a PbufferGLSurfaceEGL.";
-  return false;
+  return gfx::SwapResult::SWAP_FAILED;
 }
 
 gfx::Size PbufferGLSurfaceEGL::GetSize() {
   return size_;
 }
 
 bool PbufferGLSurfaceEGL::Resize(const gfx::Size& size) {
   if (size == size_)
     return true;
 
@@ skipping 65 matching lines @@
 }
 
 bool SurfacelessEGL::IsOffscreen() {
   return true;
 }
 
 bool SurfacelessEGL::IsSurfaceless() const {
   return true;
 }
 
-bool SurfacelessEGL::SwapBuffers() {
+gfx::SwapResult SurfacelessEGL::SwapBuffers() {
   LOG(ERROR) << "Attempted to call SwapBuffers with SurfacelessEGL.";
-  return false;
+  return gfx::SwapResult::SWAP_FAILED;
 }
 
 gfx::Size SurfacelessEGL::GetSize() {
   return size_;
 }
 
 bool SurfacelessEGL::Resize(const gfx::Size& size) {
   size_ = size;
   return true;
 }
 
 EGLSurface SurfacelessEGL::GetHandle() {
   return EGL_NO_SURFACE;
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gfx