Update the native_viewport interface to allow specification of the surface configuration, currently…

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 29 matching lines @@
 #if !defined(EGL_OPENGL_ES3_BIT)
 #define EGL_OPENGL_ES3_BIT 0x00000040
 #endif
 
 using ui::GetLastEGLErrorString;
 
 namespace gfx {
 
 namespace {
 
-EGLConfig g_config;
 EGLDisplay g_display;
 EGLNativeDisplayType g_native_display_type;
 
 // In the Cast environment, we need to destroy the EGLNativeDisplayType and
 // EGLDisplay returned by the GPU platform when we switch to an external app
 // which will temporarily own all screen and GPU resources.
 // Even though Chromium is still in the background.
 // As such, it must be reinitialized each time we come back to the foreground.
 bool g_initialized = false;
 int g_num_surfaces = 0;
@@ skipping 43 matching lines @@
 
 void DeinitializeEgl() {
   if (g_initialized) {
     g_initialized = false;
     eglTerminate(g_display);
   }
 }
 
 }  // namespace
 
-GLSurfaceEGL::GLSurfaceEGL() {
+GLSurfaceEGL::GLSurfaceEGL(SurfaceConfiguration requested_configuration)
+    : GLSurface(requested_configuration) {
   ++g_num_surfaces;
   if (!g_initialized) {
     bool result = GLSurfaceEGL::InitializeOneOff();
     DCHECK(result);
     DCHECK(g_initialized);
   }
 }
 
-bool GLSurfaceEGL::InitializeOneOff() {
-  if (g_initialized)
-    return true;
-
-  g_native_display_type = GetPlatformDefaultEGLNativeDisplay();
-
-  g_display = eglGetDisplay(g_native_display_type);
-
-  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;
-  }
-
+void* GetEGLConfig(SurfaceConfiguration configuration, bool allow_window_bit) {
   // Choose an EGL configuration.
   // On X this is only used for PBuffer surfaces.
+  EGLConfig config = {0};
+
+#if defined(USE_X11)
+  XWindowAttributes win_attribs;
+  if (!XGetWindowAttributes(GetNativeDisplay(), window_, &win_attribs)) {
+    return NULL;
+  }
+#endif
+
   EGLint renderable_type = EGL_OPENGL_ES2_BIT;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableUnsafeES3APIs)) {
     renderable_type = EGL_OPENGL_ES3_BIT;
   }
   const EGLint kConfigAttribs[] = {
-    EGL_BUFFER_SIZE, 32,
-    EGL_ALPHA_SIZE, 8,
-    EGL_BLUE_SIZE, 8,
-    EGL_GREEN_SIZE, 8,
-    EGL_RED_SIZE, 8,
+    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, EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
+    EGL_SURFACE_TYPE, (allow_window_bit ?
+                        (EGL_WINDOW_BIT | EGL_PBUFFER_BIT) :
+                        EGL_PBUFFER_BIT),
     EGL_NONE
   };
 
+#if defined(USE_X11)
+  // 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;
+#endif
+
 #if defined(USE_OZONE)
   const EGLint* config_attribs =
       ui::SurfaceFactoryOzone::GetInstance()->GetEGLSurfaceProperties(
           kConfigAttribs);
 #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();
-    return false;
-  }
-
-  if (num_configs == 0) {
-    LOG(ERROR) << "No suitable EGL configs found.";
-    return false;
+    return NULL;
   }
 
   if (!eglChooseConfig(g_display,
                        config_attribs,
-                       &g_config,
+                       &config,
                        1,
                        &num_configs)) {
     LOG(ERROR) << "eglChooseConfig failed with error "
                << GetLastEGLErrorString();
+    return NULL;
+  }
+
+#if defined(USE_X11)
+  if (num_configs) {
+    EGLint config_depth;
+    if (!eglGetConfigAttrib(g_display,
+                            config,
+                            EGL_BUFFER_SIZE,
+                            &config_depth)) {
+      LOG(ERROR) << "eglGetConfigAttrib failed with error "
+                 << GetLastEGLErrorString();
+      return NULL;
+    }
+
+    if (config_depth == win_attribs.depth) {
+      return config;
+    }
+  }
+
+  // Try without an alpha channel.
+  config_attribs[kAlphaSizeOffset] = 0;
+  if (!eglChooseConfig(g_display,
+                       config_attribs,
+                       &config,
+                       1,
+                       &num_configs)) {
+    LOG(ERROR) << "eglChooseConfig failed with error "
+               << GetLastEGLErrorString();
+    return NULL;
+  }
+#endif
+
+  if (num_configs == 0) {
+    LOG(ERROR) << "No suitable EGL configs found.";
+    return NULL;
+  }
+
+  return config;
+}
+
+bool GLSurfaceEGL::InitializeOneOff() {
+  if (g_initialized)
+    return true;
+
+  g_native_display_type = GetPlatformDefaultEGLNativeDisplay();
+
+  g_display = eglGetDisplay(g_native_display_type);
+
+  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;
+  }
+
   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");
   g_egl_window_fixed_size_supported =
       HasEGLExtension("EGL_ANGLE_window_fixed_size");
 
   // We always succeed beyond this point so set g_initialized here to avoid
   // infinite recursion through CreateGLContext and GetDisplay
@@ skipping 82 matching lines @@
 }
 
 GLSurfaceEGL::~GLSurfaceEGL() {
   DCHECK_GT(g_num_surfaces, 0) << "Bad surface count";
   if (--g_num_surfaces == 0 && g_terminate_pending) {
     DeinitializeEgl();
     g_terminate_pending = false;
   }
 }
 
-NativeViewGLSurfaceEGL::NativeViewGLSurfaceEGL(EGLNativeWindowType window)
-    : window_(window),
+NativeViewGLSurfaceEGL::NativeViewGLSurfaceEGL(
+    EGLNativeWindowType window,
+    SurfaceConfiguration requested_configuration)
+    : GLSurfaceEGL(requested_configuration),
+      window_(window),
       surface_(NULL),
       supports_post_sub_buffer_(false),
       config_(NULL),
       size_(1, 1),
       swap_interval_(1) {
 #if defined(OS_ANDROID)
   if (window)
     ANativeWindow_acquire(window);
 #endif
 }
@@ skipping 57 matching lines @@
   if (surface_) {
     if (!eglDestroySurface(GetDisplay(), surface_)) {
       LOG(ERROR) << "eglDestroySurface failed with error "
                  << GetLastEGLErrorString();
     }
     surface_ = NULL;
   }
 }
 
 EGLConfig NativeViewGLSurfaceEGL::GetConfig() {
-#if !defined(USE_X11)
-  return g_config;
-#else
   if (!config_) {
-    // Get a config compatible with the window
     DCHECK(window_);
-    XWindowAttributes win_attribs;
-    if (!XGetWindowAttributes(GetNativeDisplay(), window_, &win_attribs)) {
-      return NULL;
-    }
-
-    // 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;
-    EGLint config_attribs[] = {
-      EGL_BUFFER_SIZE, ~0,
-      EGL_ALPHA_SIZE, 8,
-      EGL_BLUE_SIZE, 8,
-      EGL_GREEN_SIZE, 8,
-      EGL_RED_SIZE, 8,
-      EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
-      EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
-      EGL_NONE
-    };
-    config_attribs[kBufferSizeOffset] = win_attribs.depth;
-
-    EGLint num_configs;
-    if (!eglChooseConfig(g_display,
-                         config_attribs,
-                         &config_,
-                         1,
-                         &num_configs)) {
-      LOG(ERROR) << "eglChooseConfig failed with error "
-                 << GetLastEGLErrorString();
-      return NULL;
-    }
-
-    if (num_configs) {
-      EGLint config_depth;
-      if (!eglGetConfigAttrib(g_display,
-                              config_,
-                              EGL_BUFFER_SIZE,
-                              &config_depth)) {
-        LOG(ERROR) << "eglGetConfigAttrib failed with error "
-                   << GetLastEGLErrorString();
-        return NULL;
-      }
-
-      if (config_depth == win_attribs.depth) {
-        return config_;
-      }
-    }
-
-    // Try without an alpha channel.
-    config_attribs[kAlphaSizeOffset] = 0;
-    if (!eglChooseConfig(g_display,
-                         config_attribs,
-                         &config_,
-                         1,
-                         &num_configs)) {
-      LOG(ERROR) << "eglChooseConfig failed with error "
-                 << GetLastEGLErrorString();
-      return NULL;
-    }
-
-    if (num_configs == 0) {
-      LOG(ERROR) << "No suitable EGL configs found.";
-      return NULL;
-    }
+    config_ = GetEGLConfig(this->GetSurfaceConfiguration(), true);
   }
   return config_;
-#endif
 }
 
 bool NativeViewGLSurfaceEGL::IsOffscreen() {
   return false;
 }
 
 bool NativeViewGLSurfaceEGL::SwapBuffers() {
   TRACE_EVENT2("gpu", "NativeViewGLSurfaceEGL:RealSwapBuffers",
       "width", GetSize().width(),
       "height", GetSize().height());
@@ skipping 83 matching lines @@
 }
 
 NativeViewGLSurfaceEGL::~NativeViewGLSurfaceEGL() {
   Destroy();
 #if defined(OS_ANDROID)
   if (window_)
     ANativeWindow_release(window_);
 #endif
 }
 
-PbufferGLSurfaceEGL::PbufferGLSurfaceEGL(const gfx::Size& size)
-    : size_(size),
-      surface_(NULL) {
+PbufferGLSurfaceEGL::PbufferGLSurfaceEGL(
+    const gfx::Size& size,
+    SurfaceConfiguration requested_configuration)
+    : GLSurfaceEGL(requested_configuration),
+      size_(size),
+      surface_(NULL),
+      config_(NULL) {
   // Some implementations of Pbuffer do not support having a 0 size. For such
   // cases use a (1, 1) surface.
   if (size_.GetArea() == 0)
     size_.SetSize(1, 1);
 }
 
 bool PbufferGLSurfaceEGL::Initialize() {
   EGLSurface old_surface = surface_;
 
   EGLDisplay display = GetDisplay();
@@ skipping 32 matching lines @@
   if (surface_) {
     if (!eglDestroySurface(GetDisplay(), surface_)) {
       LOG(ERROR) << "eglDestroySurface failed with error "
                  << GetLastEGLErrorString();
     }
     surface_ = NULL;
   }
 }
 
 EGLConfig PbufferGLSurfaceEGL::GetConfig() {
-  return g_config;
+  if (!config_) {
+    config_ = GetEGLConfig(this->GetSurfaceConfiguration(), false);
+  }
+  return config_;
 }
 
 bool PbufferGLSurfaceEGL::IsOffscreen() {
   return true;
 }
 
 bool PbufferGLSurfaceEGL::SwapBuffers() {
   NOTREACHED() << "Attempted to call SwapBuffers on a PbufferGLSurfaceEGL.";
   return false;
 }
@@ skipping 49 matching lines @@
   }
 
   return handle;
 #endif
 }
 
 PbufferGLSurfaceEGL::~PbufferGLSurfaceEGL() {
   Destroy();
 }
 
-SurfacelessEGL::SurfacelessEGL(const gfx::Size& size)
-    : size_(size) {
+SurfacelessEGL::SurfacelessEGL(const gfx::Size& size,
+                               SurfaceConfiguration requested_configuration)
+    : GLSurfaceEGL(requested_configuration), size_(size) {
 }
 
 bool SurfacelessEGL::Initialize() {
   return true;
 }
 
 void SurfacelessEGL::Destroy() {
 }
 
 EGLConfig SurfacelessEGL::GetConfig() {
-  return g_config;
+  return NULL;
 }
 
 bool SurfacelessEGL::IsOffscreen() {
   return true;
 }
 
 bool SurfacelessEGL::IsSurfaceless() const {
   return true;
 }
 
@@ skipping 16 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gfx