Enable creation of offscreen contexts which own their backing surface.

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"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 116 matching lines @@
 EGLNativeDisplayType g_native_display = EGL_DEFAULT_DISPLAY;
 
 const char* g_egl_extensions = nullptr;
 bool g_egl_create_context_robustness_supported = false;
 bool g_egl_create_context_bind_generates_resource_supported = false;
 bool g_egl_create_context_webgl_compatability_supported = false;
 bool g_egl_sync_control_supported = false;
 bool g_egl_window_fixed_size_supported = false;
 bool g_egl_surfaceless_context_supported = false;
 bool g_egl_surface_orientation_supported = false;
+bool g_egl_context_priority_supported = false;
 bool g_use_direct_composition = false;
 
 base::LazyInstance<ANGLEPlatformImpl> g_angle_platform_impl =
     LAZY_INSTANCE_INITIALIZER;
 ANGLEPlatformShutdownFunc g_angle_platform_shutdown = nullptr;
 
 EGLDisplay GetPlatformANGLEDisplay(EGLNativeDisplayType native_display,
                                    EGLenum platform_type,
                                    bool warpDevice) {
   std::vector<EGLint> display_attribs;
@@ skipping 88 matching lines @@
   }
   if (*num_configs == 0) {
     return false;
   }
   return true;
 }
 
 EGLConfig ChooseConfig(GLSurfaceFormat format) {
   // Choose an EGL configuration.
   // On X this is only used for PBuffer surfaces.
+
   std::vector<EGLint> renderable_types;
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableES3GLContext)) {
     renderable_types.push_back(EGL_OPENGL_ES3_BIT);
   }
   renderable_types.push_back(EGL_OPENGL_ES2_BIT);
 
   EGLint buffer_size = format.GetBufferSize();
   EGLint alpha_size = 8;
   bool want_rgb565 = buffer_size == 16;
+  EGLint depth_size = format.GetDepthBits();
+  EGLint stencil_size = format.GetStencilBits();
+  EGLint samples = format.GetSamples();
 
 #if defined(USE_X11) && !defined(OS_CHROMEOS)
   // If we're using ANGLE_NULL, we may not have a display, in which case we
   // can't use XVisualManager.
   if (g_native_display) {
     ui::XVisualManager::GetInstance()->ChooseVisualForWindow(
         true, nullptr, &buffer_size, nullptr, nullptr);
     alpha_size = buffer_size == 32 ? 8 : 0;
   }
 #endif
 
   EGLint surface_type = (format.IsSurfaceless()
                             ? EGL_DONT_CARE
                             : EGL_WINDOW_BIT | EGL_PBUFFER_BIT);
 
   for (auto renderable_type : renderable_types) {
     EGLint config_attribs_8888[] = {EGL_BUFFER_SIZE,
                                     buffer_size,
                                     EGL_ALPHA_SIZE,
                                     alpha_size,
                                     EGL_BLUE_SIZE,
                                     8,
                                     EGL_GREEN_SIZE,
                                     8,
                                     EGL_RED_SIZE,
                                     8,
+                                    EGL_SAMPLES,
+                                    samples,
+                                    EGL_DEPTH_SIZE,
+                                    depth_size,
+                                    EGL_STENCIL_SIZE,
+                                    stencil_size,
                                     EGL_RENDERABLE_TYPE,
                                     renderable_type,
                                     EGL_SURFACE_TYPE,
                                     surface_type,
                                     EGL_NONE};
 
     EGLint config_attribs_565[] = {EGL_BUFFER_SIZE,
                                    16,
                                    EGL_BLUE_SIZE,
                                    5,
                                    EGL_GREEN_SIZE,
                                    6,
                                    EGL_RED_SIZE,
                                    5,
+                                   EGL_SAMPLES,
+                                   samples,
+                                   EGL_DEPTH_SIZE,
+                                   depth_size,
+                                   EGL_STENCIL_SIZE,
+                                   stencil_size,
                                    EGL_RENDERABLE_TYPE,
                                    renderable_type,
                                    EGL_SURFACE_TYPE,
                                    surface_type,
                                    EGL_NONE};
 
     EGLint* choose_attributes = config_attribs_8888;
     if (want_rgb565) {
       choose_attributes = config_attribs_565;
     }
@@ skipping 193 matching lines @@
   g_egl_create_context_bind_generates_resource_supported =
       HasEGLExtension("EGL_CHROMIUM_create_context_bind_generates_resource");
   g_egl_create_context_webgl_compatability_supported =
       HasEGLExtension("EGL_ANGLE_create_context_webgl_compatibility");
   g_egl_sync_control_supported =
       HasEGLExtension("EGL_CHROMIUM_sync_control");
   g_egl_window_fixed_size_supported =
       HasEGLExtension("EGL_ANGLE_window_fixed_size");
   g_egl_surface_orientation_supported =
       HasEGLExtension("EGL_ANGLE_surface_orientation");
+  // TODO(klausw): According to
+  // https://source.android.com/compatibility/android-cdd.html
+  // the EGL_IMG_context_priority extension is mandatory for
+  // Virtual Reality High Performance support, but it's not
+  // showing in the list of reported EGL extensions?
+  g_egl_context_priority_supported =
+      HasEGLExtension("EGL_IMG_context_priority");
 
   // Need EGL_ANGLE_flexible_surface_compatibility to allow surfaces with and
   // without alpha to be bound to the same context.
   g_use_direct_composition =
       HasEGLExtension("EGL_ANGLE_direct_composition") &&
       HasEGLExtension("EGL_ANGLE_flexible_surface_compatibility") &&
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableDirectComposition);
 
   // TODO(oetuaho@nvidia.com): Surfaceless is disabled on Android as a temporary
@@ skipping 84 matching lines @@
 bool GLSurfaceEGL::IsCreateContextWebGLCompatabilitySupported() {
   return g_egl_create_context_webgl_compatability_supported;
 }
 
 // static
 bool GLSurfaceEGL::IsEGLSurfacelessContextSupported() {
   return g_egl_surfaceless_context_supported;
 }
 
 // static
+bool GLSurfaceEGL::IsEGLContextPrioritySupported() {
+  return g_egl_context_priority_supported;
+}
+
+// static
 bool GLSurfaceEGL::IsDirectCompositionSupported() {
   return g_use_direct_composition;
 }
 
 GLSurfaceEGL::~GLSurfaceEGL() {}
 
 // InitializeDisplay is necessary because the static binding code
 // needs a full Display init before it can query the Display extensions.
 // static
 EGLDisplay GLSurfaceEGL::InitializeDisplay(
@@ skipping 619 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gl