Refactor context creation parameters into a struct.

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 108 matching lines @@
 const unsigned int MULTISWAP_FRAME_VSYNC_THRESHOLD = 60;
 #endif
 
 namespace {
 
 EGLDisplay g_display = EGL_NO_DISPLAY;
 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_use_direct_composition = false;
 
 EGLDisplay GetPlatformANGLEDisplay(EGLNativeDisplayType native_display,
                                    EGLenum platform_type,
                                    bool warpDevice) {
   std::vector<EGLint> display_attribs;
@@ skipping 332 matching lines @@
   InitializeDisplay(native_display);
   if (g_display == EGL_NO_DISPLAY)
     return false;
 
   // Must be called after InitializeDisplay().
   g_driver_egl.InitializeExtensionBindings();
 
   g_egl_extensions = eglQueryString(g_display, EGL_EXTENSIONS);
   g_egl_create_context_robustness_supported =
       HasEGLExtension("EGL_EXT_create_context_robustness");
+  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");
 
   // Need EGL_ANGLE_flexible_surface_compatibility to allow surfaces with and
   // without alpha to be bound to the same context.
   g_use_direct_composition =
@@ skipping 11 matching lines @@
 #else
   // Check if SurfacelessEGL is supported.
   g_egl_surfaceless_context_supported =
       HasEGLExtension("EGL_KHR_surfaceless_context");
   if (g_egl_surfaceless_context_supported) {
     // EGL_KHR_surfaceless_context is supported but ensure
     // GL_OES_surfaceless_context is also supported. We need a current context
     // to query for supported GL extensions.
     scoped_refptr<GLSurface> surface = new SurfacelessEGL(gfx::Size(1, 1));
     scoped_refptr<GLContext> context = InitializeGLContext(
-        new GLContextEGL(nullptr), surface.get(), PreferIntegratedGpu);
+        new GLContextEGL(nullptr), surface.get(), GLContextAttribs());
     if (!context->MakeCurrent(surface.get()))
       g_egl_surfaceless_context_supported = false;
 
     // Ensure context supports GL_OES_surfaceless_context.
     if (g_egl_surfaceless_context_supported) {
       g_egl_surfaceless_context_supported = context->HasExtension(
           "GL_OES_surfaceless_context");
       context->ReleaseCurrent(surface.get());
     }
   }
 #endif
   initialized_ = true;
 
   return true;
 }
 
 // static
 void GLSurfaceEGL::ResetForTesting() {
   if (g_display != EGL_NO_DISPLAY)
     eglTerminate(g_display);
   g_display = EGL_NO_DISPLAY;
 
   g_egl_extensions = nullptr;
   g_egl_create_context_robustness_supported = false;
+  g_egl_create_context_bind_generates_resource_supported = false;
+  g_egl_create_context_webgl_compatability_supported = false;
   g_egl_sync_control_supported = false;
   g_egl_window_fixed_size_supported = false;
   g_egl_surface_orientation_supported = false;
   g_use_direct_composition = false;
   g_egl_surfaceless_context_supported = false;
 
   initialized_ = false;
 }
 
 // static
@@ skipping 14 matching lines @@
 // static
 bool GLSurfaceEGL::HasEGLExtension(const char* name) {
   return ExtensionsContain(GetEGLExtensions(), name);
 }
 
 // static
 bool GLSurfaceEGL::IsCreateContextRobustnessSupported() {
   return g_egl_create_context_robustness_supported;
 }
 
+bool GLSurfaceEGL::IsCreateContextBindGeneratesResourceSupported() {
+  return g_egl_create_context_bind_generates_resource_supported;
+}
+
+bool GLSurfaceEGL::IsCreateContextWebGLCompatabilitySupported() {
+  return g_egl_create_context_webgl_compatability_supported;
+}
+
 // static
 bool GLSurfaceEGL::IsEGLSurfacelessContextSupported() {
   return g_egl_surfaceless_context_supported;
 }
 
 // static
 bool GLSurfaceEGL::IsDirectCompositionSupported() {
   return g_use_direct_composition;
 }
 
@@ skipping 619 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gl