Ensure GL initialization only happens once, and provide common init path

ui/gl/gl_surface.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 "ui/gl/gl_surface.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/threading/thread_local.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_switches.h"
 
 namespace gfx {
 
 namespace {
 base::LazyInstance<base::ThreadLocalPointer<GLSurface> >::Leaky
     current_surface_ = LAZY_INSTANCE_INITIALIZER;
 }  // namespace
 
 // static
 bool GLSurface::InitializeOneOff() {
-  static bool initialized = false;
-  if (initialized)
-    return true;
+  DCHECK_EQ(kGLImplementationNone, GetGLImplementation());
 
   TRACE_EVENT0("gpu", "GLSurface::InitializeOneOff");
 
   std::vector<GLImplementation> allowed_impls;
   GetAllowedGLImplementations(&allowed_impls);
   DCHECK(!allowed_impls.empty());
 
   // The default implementation is always the first one in list.
   GLImplementation impl = allowed_impls[0];
   bool fallback_to_osmesa = false;
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kUseGL)) {
     std::string requested_implementation_name =
         CommandLine::ForCurrentProcess()->GetSwitchValueASCII(switches::kUseGL);
     if (requested_implementation_name == "any") {
       fallback_to_osmesa = true;
     } else if (requested_implementation_name == "swiftshader") {
       impl = kGLImplementationEGLGLES2;
+    } else if (requested_implementation_name == kGLImplementationMockName) {
+      impl = kGLImplementationMockGL;
     } else {
       impl = GetNamedGLImplementation(requested_implementation_name);
       if (std::find(allowed_impls.begin(),
                     allowed_impls.end(),
                     impl) == allowed_impls.end()) {
         LOG(ERROR) << "Requested GL implementation is not available.";
         return false;
       }
     }
   }
 
-  initialized = InitializeStaticGLBindings(impl) && InitializeOneOffInternal();
+  bool initialized =
+      InitializeStaticGLBindings(impl) && InitializeOneOffInternal();
   if (!initialized && fallback_to_osmesa) {
     ClearGLBindings();
     initialized = InitializeStaticGLBindings(kGLImplementationOSMesaGL) &&
                   InitializeOneOffInternal();
   }
+  if (!initialized)
+    ClearGLBindings();
 
   if (initialized) {
     DVLOG(1) << "Using "
              << GetGLImplementationName(GetGLImplementation())
              << " GL implementation.";
     if (CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kEnableGPUServiceLogging))
       InitializeDebugGLBindings();
     if (CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kDisableGLDrawingForTests))
       InitializeNullDrawGLBindings();
   }
   return initialized;
 }
 
+// static
+void GLSurface::InitializeOneOffForTests() {
+  CommandLine* cmd = CommandLine::ForCurrentProcess();
+
+  bool use_osmesa = true;
+
+#if defined(OS_ANDROID)
+  // On Android we always use hardware GL.
+  use_osmesa = false;
+#endif
+
+  if (use_osmesa) {
+    if (cmd->HasSwitch(switches::kUseGL)) {
+      DCHECK(cmd->GetSwitchValueASCII(switches::kUseGL) ==

[piman, 2014/01/24 19:22:23]

nit: maybe CHECK with an error message, so that naughty users that try to pass
--use-gl get a warning?

[danakj, 2014/01/24 20:17:23]

kk

+             kGLImplementationOSMesaName);
+    } else {
+      cmd->AppendSwitchASCII(switches::kUseGL, kGLImplementationOSMesaName);
+    }
+  } else {
+    DCHECK(!cmd->HasSwitch(switches::kUseGL));
+  }
+
+  // TODO(danakj): Unit tests do not produce pixel output by default.
+  // cmd->AppendSwitch(switches::kDisableGLDrawingForTests);
+
+  CHECK(InitializeOneOff());
+}
+
+// static
+void GLSurface::InitializeOneOffWithMockBindingsForTests() {
+  CommandLine* cmd = CommandLine::ForCurrentProcess();
+  if (cmd->HasSwitch(switches::kUseGL)) {
+    DCHECK(cmd->GetSwitchValueASCII(switches::kUseGL) ==
+           kGLImplementationMockName);
+  } else {
+    cmd->AppendSwitchASCII(switches::kUseGL, kGLImplementationMockName);
+  }
+
+  // This method may be called multiple times in the same process to set up
+  // mock bindings in different ways.
+  ClearGLBindings();
+
+  CHECK(InitializeOneOff());
+}
+
+// static
+void GLSurface::InitializeDynamicMockBindingsForTests(GLContext* context) {
+  CHECK(InitializeDynamicGLBindings(kGLImplementationMockGL, context));
+}
+
 GLSurface::GLSurface() {}
 
 bool GLSurface::Initialize() {
   return true;
 }
 
 bool GLSurface::Resize(const gfx::Size& size) {
   NOTIMPLEMENTED();
   return false;
 }
@@ skipping 168 matching lines @@
   return surface_->GetFormat();
 }
 
 VSyncProvider* GLSurfaceAdapter::GetVSyncProvider() {
   return surface_->GetVSyncProvider();
 }
 
 GLSurfaceAdapter::~GLSurfaceAdapter() {}
 
 }  // namespace gfx