Add ANGLE Platform implementation.

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;
+
 }  // 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
   // unit tests have initialized with kGLImplementationMock, we don't want to
   // later switch to another GL implementation.
   DCHECK_EQ(kGLImplementationNone, GetGLImplementation());
 
+  // Init ANGLE platform here, before we call GetPlatformDisplay().
+  // TODO(jmadill): Apply to all platforms eventually
+  base::NativeLibrary libGLESv2_module = base::LoadNativeLibrary(
+      base::FilePath(L"libGLESv2.dll"),
+      nullptr);
+
+  if (libGLESv2_module) {
+    ANGLEPlatformInitializeFunc initFunc =
+        reinterpret_cast<ANGLEPlatformInitializeFunc>(
+            base::GetFunctionPointerFromNativeLibrary(
+                libGLESv2_module,
+                "ANGLEPlatformInitialize"));
+    if (initFunc) {
+      initFunc(&g_angle_platform_impl.Get());
+    }
+  }

[piman, 2015/03/18 19:27:07]

I think we'd only want to do this in the kGLImplementationEGLGLES2 path. Also,
we already load the DLL there (l. 207), so should all this move to l.213?

[Jamie Madill, 2015/03/18 21:01:50]

Done.

+
   // Allow the main thread or another to initialize these bindings
   // after instituting restrictions on I/O. Going forward they will
   // likely be used in the browser process on most platforms. The
   // one-time initialization cost is small, between 2 and 5 ms.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   switch (implementation) {
     case kGLImplementationOSMesaGL: {
       base::FilePath module_path;
       if (!PathService::Get(base::DIR_MODULE, &module_path)) {
@@ skipping 217 matching lines @@
 }
 
 void InitializeDebugGLBindings() {
   InitializeDebugGLBindingsEGL();
   InitializeDebugGLBindingsGL();
   InitializeDebugGLBindingsOSMESA();
   InitializeDebugGLBindingsWGL();
 }
 
 void ClearGLBindings() {
+  // TODO(jmadill): Apply to all platforms eventually
+  base::NativeLibrary libGLESv2_module = base::LoadNativeLibrary(
+      base::FilePath(L"libGLESv2.dll"),
+      nullptr);
+
+  if (libGLESv2_module) {
+    ANGLEPlatformShutdownFunc shutdownFunc =

[piman, 2015/03/18 19:27:07]

We could just lookup this function at the same time we lookup the init one, just
keeping it in a global? That way we don't have to LoadNativeLibrary again.

[Jamie Madill, 2015/03/18 21:01:50]

Done.

+        reinterpret_cast<ANGLEPlatformShutdownFunc>(
+            base::GetFunctionPointerFromNativeLibrary(
+                libGLESv2_module,
+                "ANGLEPlatformShutdown"));
+    if (shutdownFunc) {
+      shutdownFunc();
+    }
+  }
+
   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