Abstract OSMesa from the Layout tests

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"
@@ skipping 11 matching lines @@
 
   DCHECK_EQ(kGLImplementationNone, GetGLImplementation());
 
   std::vector<GLImplementation> allowed_impls = GetAllowedGLImplementations();
   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;
+  bool fallback_to_software_rendering = false;

[Ken Russell (switch to Gerrit), 2017/02/15 02:32:15]

Could you call this fallback_to_software_gl?

+  if (cmd->HasSwitch(switches::kOverrideUseSoftwareGLForTests)) {
+    impl = GetSoftwareGLImplementation();
   } else if (cmd->HasSwitch(switches::kUseGL)) {
     std::string requested_implementation_name =
         cmd->GetSwitchValueASCII(switches::kUseGL);
     if (requested_implementation_name == "any") {
-      fallback_to_osmesa = true;
+      fallback_to_software_rendering = true;
     } else if (requested_implementation_name ==
                kGLImplementationSwiftShaderName) {
       impl = kGLImplementationSwiftShaderGL;
     } else if (requested_implementation_name ==
                    kGLImplementationSwiftShaderForWebGLName ||
                requested_implementation_name == kGLImplementationANGLEName) {
       impl = kGLImplementationEGLGLES2;
     } else {
       impl = GetNamedGLImplementation(requested_implementation_name);
       if (!base::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);
+  return InitializeGLOneOffImplementation(impl, fallback_to_software_rendering,
+                                          gpu_service_logging,
+                                          disable_gl_drawing);
 }
 
 bool InitializeGLOneOffImplementation(GLImplementation impl,
-                                      bool fallback_to_osmesa,
+                                      bool fallback_to_software_rendering,
                                       bool gpu_service_logging,
                                       bool disable_gl_drawing) {
   bool initialized =
       InitializeStaticGLBindings(impl) && InitializeGLOneOffPlatform();
-  if (!initialized && fallback_to_osmesa) {
+  if (!initialized && fallback_to_software_rendering) {
     ShutdownGL();
-    initialized = InitializeStaticGLBindings(kGLImplementationOSMesaGL) &&
+    initialized = InitializeStaticGLBindings(GetSoftwareGLImplementation()) &&
                   InitializeGLOneOffPlatform();
   }
   if (!initialized)
     ShutdownGL();
 
   if (initialized) {
     DVLOG(1) << "Using " << GetGLImplementationName(GetGLImplementation())
              << " GL implementation.";
     if (gpu_service_logging)
       InitializeDebugGLBindings();
     if (disable_gl_drawing)
       InitializeNullDrawGLBindings();
   }
   return initialized;
 }
 
 void ShutdownGL() {
   ShutdownGLPlatform();
 
   SetGLImplementation(kGLImplementationNone);
   UnloadGLNativeLibraries();
 }
 
 scoped_refptr<GLSurface> CreateOffscreenGLSurface(const gfx::Size& size) {
   return CreateOffscreenGLSurfaceWithFormat(size, GLSurfaceFormat());
 }
 
 }  // namespace init
 }  // namespace gl