Move GL one-off initialization code.

ui/gl/init/gl_factory.cc

 // Copyright 2016 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/init/gl_factory.h"
 
+#include <string>
+#include <vector>
+
+#include "base/command_line.h"
+#include "base/logging.h"
+#include "base/trace_event/trace_event.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/gl_surface.h"
+#include "ui/gl/init/gl_initializer.h"
 
 namespace gl {
 namespace init {
 
-// TODO(kylechar): This file should be replaced with a platform specific
-// version for X11, Ozone, Windows, Mac and Android. The implementation of each
-// factory function should be moved into that file and the original static
-// methods should be removed from GLSurface and GLContext. This file can then
-// be deleted.
+bool InitializeGLOneOff() {
+  TRACE_EVENT0("gpu,startup", "gl::init::InitializeOneOff");
 
-bool InitializeGLOneOff() {
-  return GLSurface::InitializeOneOff();
+  DCHECK_EQ(kGLImplementationNone, GetGLImplementation());
+
+  std::vector<GLImplementation> allowed_impls;
+  GetAllowedGLImplementations(&allowed_impls);
+  DCHECK(!allowed_impls.empty());
+
+  base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
+
+  // The default implementation is always the first one in list.
+  GLImplementation impl = allowed_impls[0];
+  bool fallback_to_osmesa = false;
+  if (cmd->HasSwitch(switches::kOverrideUseGLWithOSMesaForTests)) {
+    impl = kGLImplementationOSMesaGL;
+  } else if (cmd->HasSwitch(switches::kUseGL)) {
+    std::string requested_implementation_name =
+        cmd->GetSwitchValueASCII(switches::kUseGL);
+    if (requested_implementation_name == "any") {
+      fallback_to_osmesa = true;
+    } else if (requested_implementation_name ==
+                   kGLImplementationSwiftShaderName ||
+               requested_implementation_name == kGLImplementationANGLEName) {
+      impl = kGLImplementationEGLGLES2;
+    } else {
+      impl = GetNamedGLImplementation(requested_implementation_name);
+      if (!ContainsValue(allowed_impls, impl)) {
+        LOG(ERROR) << "Requested GL implementation is not available.";
+        return false;
+      }
+    }
+  }
+
+  bool gpu_service_logging = cmd->HasSwitch(switches::kEnableGPUServiceLogging);
+  bool disable_gl_drawing = cmd->HasSwitch(switches::kDisableGLDrawingForTests);
+
+  return InitializeGLOneOffImplementation(
+      impl, fallback_to_osmesa, gpu_service_logging, disable_gl_drawing);
 }
 
+bool InitializeGLOneOffImplementation(GLImplementation impl,
+                                      bool fallback_to_osmesa,
+                                      bool gpu_service_logging,
+                                      bool disable_gl_drawing) {
+  bool initialized =
+      InitializeStaticGLBindings(impl) && InitializeGLOneOffPlatform();
+  if (!initialized && fallback_to_osmesa) {
+    ClearGLBindings();
+    initialized = InitializeStaticGLBindings(kGLImplementationOSMesaGL) &&
+                  InitializeGLOneOffPlatform();
+  }
+  if (!initialized)
+    ClearGLBindings();
+
+  if (initialized) {
+    DVLOG(1) << "Using " << GetGLImplementationName(GetGLImplementation())
+             << " GL implementation.";
+    if (gpu_service_logging)
+      InitializeDebugGLBindings();
+    if (disable_gl_drawing)
+      InitializeNullDrawGLBindings();
+  }
+  return initialized;
+}
+
+// TODO(kylechar): The functions below should be replaced with a platform
+// specific version for X11, Ozone, Windows, Mac and Android. The implementation
+// of each function should be moved into a platform specific file and the
+// original static functions should be removed from GLSurface and GLContext.
+
 scoped_refptr<GLContext> CreateGLContext(GLShareGroup* share_group,
                                          GLSurface* compatible_surface,
                                          GpuPreference gpu_preference) {
   return GLContext::CreateGLContext(share_group, compatible_surface,
                                     gpu_preference);
 }
 
 scoped_refptr<GLSurface> CreateViewGLSurface(gfx::AcceleratedWidget window) {
   return GLSurface::CreateViewGLSurface(window);
 }
 
 #if defined(USE_OZONE)
 scoped_refptr<GLSurface> CreateSurfacelessViewGLSurface(
     gfx::AcceleratedWidget window) {
   return GLSurface::CreateSurfacelessViewGLSurface(window);
 }
 #endif  // defined(USE_OZONE)
 
 scoped_refptr<GLSurface> CreateOffscreenGLSurface(const gfx::Size& size) {
   return GLSurface::CreateOffscreenGLSurface(size);
 }
 
 }  // namespace init
 }  // namespace gl