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

ui/gl/gl_implementation_ozone.cc

Index: ui/gl/gl_implementation_ozone.cc
diff --git a/ui/gl/gl_implementation_ozone.cc b/ui/gl/gl_implementation_ozone.cc
index 2564c1a5b49e16ec20a7c926e658c8ac2e92c98c..67812bb8ceb16ab4a02c74bc13611a61d93a491b 100644
--- a/ui/gl/gl_implementation_ozone.cc
+++ b/ui/gl/gl_implementation_ozone.cc
@@ -2,19 +2,74 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "ui/gl/gl_implementation.h"
-
+#include "base/bind.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_implementation_osmesa.h"
 #include "ui/gl/gl_osmesa_api_implementation.h"
+#include "ui/ozone/public/ozone_platform.h"
+#include "ui/ozone/public/surface_factory_ozone.h"
 
 namespace gl {
+
+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));
+}
+
+}  // namespace
 
 void GetAllowedGLImplementations(std::vector<GLImplementation>* impls) {
   impls->push_back(kGLImplementationEGLGLES2);
   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());
+  ui::OzonePlatform::InitializeForGPU();
+
+  switch (implementation) {
+    case kGLImplementationOSMesaGL:
+      return InitializeStaticGLBindingsOSMesaGL();
+    case kGLImplementationEGLGLES2:
+      if (!ui::OzonePlatform::GetInstance()
+               ->GetSurfaceFactoryOzone()
+               ->LoadEGLGLES2Bindings(base::Bind(&AddGLNativeLibrary),
+                                      base::Bind(&SetGLGetProcAddressProc)))
+        return false;
+      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;
+      break;
+    case kGLImplementationMockGL: {
+      SetGLImplementation(kGLImplementationMockGL);
+      InitializeStaticGLBindingsGL();
+      break;
+    }
+    default:
+      NOTIMPLEMENTED()
+          << "Unsupported GL type for Ozone surface implementation";
+      return false;
+  }
+
+  return true;
 }
 
 bool InitializeDynamicGLBindings(GLImplementation implementation,
@@ -41,6 +96,20 @@
   return true;
 }
 
+void InitializeDebugGLBindings() {
+  InitializeDebugGLBindingsEGL();
+  InitializeDebugGLBindingsGL();
+  InitializeDebugGLBindingsOSMESA();
+}
+
+void ClearGLBindings() {
+  ClearGLBindingsEGL();
+  ClearGLBindingsGL();
+  ClearGLBindingsOSMESA();
+  SetGLImplementation(kGLImplementationNone);
+  UnloadGLNativeLibraries();
+}
+
 bool GetGLWindowSystemBindingInfo(GLWindowSystemBindingInfo* info) {
   switch (GetGLImplementation()) {
     case kGLImplementationEGLGLES2: