Chromium -> Mojo roll.

ui/gl/gl_implementation_win.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 <vector>
 
 #include "base/at_exit.h"
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/native_library.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
 #include "base/win/windows_version.h"
+// TODO(jmadill): Apply to all platforms eventually
+#include "ui/gl/angle_platform_impl.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context_stub_with_extensions.h"
 #include "ui/gl/gl_egl_api_implementation.h"
 #include "ui/gl/gl_gl_api_implementation.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_osmesa_api_implementation.h"
 #include "ui/gl/gl_surface_wgl.h"
 #include "ui/gl/gl_wgl_api_implementation.h"
 
 #if defined(ENABLE_SWIFTSHADER)
@@ skipping 61 matching lines @@
                                   unsigned long long id,
                                   int numArgs,
                                   const char** argNames,
                                   const unsigned char* argTypes,
                                   const unsigned long long* argValues,
                                   unsigned char flags);
 typedef void (__stdcall *SetTraceFunctionPointersFunc)(
     GetCategoryEnabledFlagFunc get_category_enabled_flag,
     AddTraceEventFunc add_trace_event_func);
 
+// TODO(jmadill): Apply to all platforms eventually
+base::LazyInstance<ANGLEPlatformImpl> g_angle_platform_impl =
+    LAZY_INSTANCE_INITIALIZER;
+
+ANGLEPlatformShutdownFunc g_angle_platform_shutdown = nullptr;
+
 }  // namespace
 
 void GetAllowedGLImplementations(std::vector<GLImplementation>* impls) {
   impls->push_back(kGLImplementationEGLGLES2);
   impls->push_back(kGLImplementationDesktopGL);
   impls->push_back(kGLImplementationOSMesaGL);
 }
 
 bool InitializeStaticGLBindings(GLImplementation implementation) {
   // Prevent reinitialization with a different implementation. Once the gpu
@@ skipping 87 matching lines @@
         return false;
       }
 
 #if defined(ENABLE_SWIFTSHADER)
       if (using_swift_shader) {
         SetupSoftwareRenderer(gles_library);
       }
 #endif
 
       if (!using_swift_shader) {
+        // TODO(jmadill): remove when platform impl supports tracing
         SetTraceFunctionPointersFunc set_trace_function_pointers =
             reinterpret_cast<SetTraceFunctionPointersFunc>(
                 base::GetFunctionPointerFromNativeLibrary(
                     gles_library, "SetTraceFunctionPointers"));
         if (set_trace_function_pointers) {
           set_trace_function_pointers(&AngleGetTraceCategoryEnabledFlag,
                                       &AngleAddTraceEvent);
         }
+
+        // Init ANGLE platform here, before we call GetPlatformDisplay().
+        // TODO(jmadill): Apply to all platforms eventually
+        ANGLEPlatformInitializeFunc angle_platform_init =
+            reinterpret_cast<ANGLEPlatformInitializeFunc>(
+                base::GetFunctionPointerFromNativeLibrary(
+                    gles_library,
+                    "ANGLEPlatformInitialize"));
+        if (angle_platform_init) {
+          angle_platform_init(&g_angle_platform_impl.Get());
+
+          g_angle_platform_shutdown =
+              reinterpret_cast<ANGLEPlatformShutdownFunc>(
+                  base::GetFunctionPointerFromNativeLibrary(
+                      gles_library,
+                      "ANGLEPlatformShutdown"));
+        }
       }
 
       GLGetProcAddressProc get_proc_address =
           reinterpret_cast<GLGetProcAddressProc>(
               base::GetFunctionPointerFromNativeLibrary(
                   egl_library, "eglGetProcAddress"));
       if (!get_proc_address) {
         LOG(ERROR) << "eglGetProcAddress not found.";
         base::UnloadNativeLibrary(egl_library);
         base::UnloadNativeLibrary(gles_library);
@@ skipping 116 matching lines @@
 }
 
 void InitializeDebugGLBindings() {
   InitializeDebugGLBindingsEGL();
   InitializeDebugGLBindingsGL();
   InitializeDebugGLBindingsOSMESA();
   InitializeDebugGLBindingsWGL();
 }
 
 void ClearGLBindings() {
+  // TODO(jmadill): Apply to all platforms eventually
+  if (g_angle_platform_shutdown) {
+    g_angle_platform_shutdown();
+  }
+
   ClearGLBindingsEGL();
   ClearGLBindingsGL();
   ClearGLBindingsOSMESA();
   ClearGLBindingsWGL();
   SetGLImplementation(kGLImplementationNone);
   UnloadGLNativeLibraries();
 }
 
 bool GetGLWindowSystemBindingInfo(GLWindowSystemBindingInfo* info) {
   switch (GetGLImplementation()) {
     case kGLImplementationDesktopGL:
       return GetGLWindowSystemBindingInfoWGL(info);
     case kGLImplementationEGLGLES2:
       return GetGLWindowSystemBindingInfoEGL(info);
     default:
       return false;
   }
 }
 
 }  // namespace gfx