ui/gl: Initialize the ANGLE Platform on all configurations

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>
 #include <memory>
 #include <vector>
 
 #include "base/command_line.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "ui/gfx/geometry/rect.h"
+#include "ui/gl/angle_platform_impl.h"
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_context_egl.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/scoped_make_current.h"
 
 #if defined(USE_X11) && !defined(OS_CHROMEOS)
@@ skipping 91 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_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;
 
+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;
 
   display_attribs.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE);
   display_attribs.push_back(platform_type);
 
   if (warpDevice) {
     display_attribs.push_back(EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE);
@@ skipping 375 matching lines @@
       context->ReleaseCurrent(surface.get());
     }
   }
 #endif
   initialized_ = true;
 
   return true;
 }
 
 // static
-void GLSurfaceEGL::ResetForTesting() {
+void GLSurfaceEGL::ShutdownOneOff() {
+  if (g_angle_platform_shutdown) {
+    g_angle_platform_shutdown();
+  }
+
   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_sync_control_supported = false;
   g_egl_window_fixed_size_supported = false;
   g_egl_surface_orientation_supported = false;
   g_use_direct_composition = false;
@@ skipping 43 matching lines @@
 // needs a full Display init before it can query the Display extensions.
 // static
 EGLDisplay GLSurfaceEGL::InitializeDisplay(
     EGLNativeDisplayType native_display) {
   if (g_display != EGL_NO_DISPLAY) {
     return g_display;
   }
 
   g_native_display = native_display;
 
+  // Init ANGLE platform here, before we call GetPlatformDisplay().
+  ANGLEPlatformInitializeFunc angle_platform_init =
+      reinterpret_cast<ANGLEPlatformInitializeFunc>(
+          eglGetProcAddress("ANGLEPlatformInitialize"));
+  if (angle_platform_init) {
+    angle_platform_init(&g_angle_platform_impl.Get());
+
+    g_angle_platform_shutdown = reinterpret_cast<ANGLEPlatformShutdownFunc>(
+        eglGetProcAddress("ANGLEPlatformShutdown"));
+  }
+
   // If EGL_EXT_client_extensions not supported this call to eglQueryString
   // will return NULL.
   const char* client_extensions =
       eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
 
   bool supports_angle_d3d = false;
   bool supports_angle_opengl = false;
   bool supports_angle_null = false;
   // Check for availability of ANGLE extensions.
   if (client_extensions &&
@@ skipping 596 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gl