Move static GL binding initialization to //ui/gl/init.

ui/gl/init/gl_initializer_android.cc

Index: ui/gl/init/gl_initializer_android.cc
diff --git a/ui/gl/init/gl_initializer_android.cc b/ui/gl/init/gl_initializer_android.cc
index 7d7a88e38b58fcdfd0dbfa481739b320c51cb060..afca9f59d163b5688cdd3ecb2c2cfbc6af1cd4ed 100644
--- a/ui/gl/init/gl_initializer_android.cc
+++ b/ui/gl/init/gl_initializer_android.cc
@@ -4,13 +4,71 @@
 
 #include "ui/gl/init/gl_initializer.h"
 
+#include "base/base_paths.h"
+#include "base/command_line.h"
+#include "base/files/file_path.h"
 #include "base/logging.h"
-#include "ui/gl/gl_implementation.h"
+#include "base/native_library.h"
+#include "ui/gl/gl_bindings.h"
+#include "ui/gl/gl_egl_api_implementation.h"
+#include "ui/gl/gl_gl_api_implementation.h"
+#include "ui/gl/gl_implementation_osmesa.h"
+#include "ui/gl/gl_osmesa_api_implementation.h"
 #include "ui/gl/gl_surface_egl.h"
 
 namespace gl {
 namespace init {
 
+namespace {
+
+void GL_BINDING_CALL MarshalClearDepthToClearDepthf(GLclampd depth) {
+  glClearDepthf(static_cast<GLclampf>(depth));
+}
+
+void GL_BINDING_CALL MarshalDepthRangeToDepthRangef(GLclampd z_near,
+                                                    GLclampd z_far) {
+  glDepthRangef(static_cast<GLclampf>(z_near), static_cast<GLclampf>(z_far));
+}
+
+bool InitializeStaticEGLInternal() {
+  base::NativeLibrary gles_library = LoadLibraryAndPrintError("libGLESv2.so");
+  if (!gles_library)
+    return false;
+  base::NativeLibrary egl_library = LoadLibraryAndPrintError("libEGL.so");
+  if (!egl_library) {
+    base::UnloadNativeLibrary(gles_library);
+    return false;
+  }
+
+  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);
+    return false;
+  }
+
+  SetGLGetProcAddressProc(get_proc_address);
+  AddGLNativeLibrary(egl_library);
+  AddGLNativeLibrary(gles_library);
+  SetGLImplementation(kGLImplementationEGLGLES2);
+
+  InitializeStaticGLBindingsGL();
+  InitializeStaticGLBindingsEGL();
+
+  // These two functions take single precision float rather than double
+  // precision float parameters in GLES.
+  ::gl::g_driver_gl.fn.glClearDepthFn = MarshalClearDepthToClearDepthf;
+  ::gl::g_driver_gl.fn.glDepthRangeFn = MarshalDepthRangeToDepthRangef;

[piman, 2016/06/24 19:13:21]

nit: all the EGL platforms have to do this, and they do it identically. Could we
move this to InitializeStaticGLBindingsEGL?

[kylechar, 2016/06/27 13:35:22]

Good idea, done.

+
+  return true;
+}
+
+}  // namespace
+
 bool InitializeGLOneOffPlatform() {
   switch (GetGLImplementation()) {
     case kGLImplementationEGLGLES2:
@@ -24,5 +82,39 @@ bool InitializeGLOneOffPlatform() {
   }
 }
 
+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());
+
+  switch (implementation) {
+    case kGLImplementationEGLGLES2:
+      return InitializeStaticEGLInternal();
+    case kGLImplementationOSMesaGL:
+      return InitializeStaticGLBindingsOSMesaGL();
+    case kGLImplementationMockGL:
+      SetGLImplementation(kGLImplementationMockGL);
+      InitializeStaticGLBindingsGL();
+      return true;
+    default:
+      NOTREACHED();
+  }
+
+  return false;
+}
+
+void InitializeDebugGLBindings() {
+  InitializeDebugGLBindingsEGL();
+  InitializeDebugGLBindingsGL();
+  InitializeDebugGLBindingsOSMESA();
+}
+
+void ClearGLBindingsPlatform() {
+  ClearGLBindingsEGL();
+  ClearGLBindingsGL();
+  ClearGLBindingsOSMESA();
+}
+
 }  // namespace init
 }  // namespace gl