Implement --use-gl=any

ui/gfx/gl/gl_implementation.cc

 // Copyright (c) 2011 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/gfx/gl/gl_implementation.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 
 namespace gfx {
 
 namespace {
 
 const struct {
   const char* name;
   GLImplementation implementation;
 } kGLImplementationNamePairs[] = {
   { kGLImplementationDesktopName, kGLImplementationDesktopGL },
   { kGLImplementationOSMesaName, kGLImplementationOSMesaGL },
   { kGLImplementationEGLName, kGLImplementationEGLGLES2 },
-  { kGLImplementationMockName, kGLImplementationMockGL }
+  { kGLImplementationMockName, kGLImplementationMockGL },
+  { kGLImplementationAnyName, kGLImplementationAny }
 };
 
 typedef std::vector<base::NativeLibrary> LibraryArray;
 
 GLImplementation g_gl_implementation = kGLImplementationNone;
 LibraryArray* g_libraries;
 GLGetProcAddressProc g_get_proc_address;
 
 void CleanupNativeLibraries(void* unused) {
   if (g_libraries) {
@@ skipping 22 matching lines @@
       return kGLImplementationNamePairs[i].name;
   }
 
   return "unknown";
 }
 
 bool InitializeRequestedGLBindings(
     const GLImplementation* allowed_implementations_begin,
     const GLImplementation* allowed_implementations_end,
     GLImplementation default_implementation) {
+  bool fallback_to_osmesa = false;
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kUseGL)) {
     std::string requested_implementation_name =
         CommandLine::ForCurrentProcess()->GetSwitchValueASCII(switches::kUseGL);
     GLImplementation requested_implementation =
         GetNamedGLImplementation(requested_implementation_name);
+    if (requested_implementation == kGLImplementationAny) {

[alokp, 2011/09/27 15:55:48]

I do not think "use-gl=any" means fallback to osmesa. It means keep going
through the list until you find an implementation that would work. It may be
osmesa in most cases.

[Zhenyao Mo, 2011/09/27 17:17:31]

Go through the list means on Windows we will try DesktopGL next, which is bad,
because DesktopGL is not managed by Blacklist and not tested anywhere.  Falling
back to osmesa is the safe thing to do.

[alokp, 2011/09/27 17:22:25]

If DesktopGL is not supported on windows, it should not be in the list.

[Zhenyao Mo, 2011/09/27 17:36:22]

Currently we have only one list: allowed bindings.  We can't remove Desktop GL
from that list, because we do wanna compare DesktopGL with ANGLE for debug and
performance comparisons.

For each platform, only the default binding and osmesa are tested.  That's why I
think we should only try these two to be on the safe side.

+      requested_implementation = default_implementation;
+      fallback_to_osmesa = true;
+    }
     if (std::find(allowed_implementations_begin,
                   allowed_implementations_end,
                   requested_implementation) == allowed_implementations_end) {
       LOG(ERROR) << "Requested GL implementation is not available.";
       return false;
     }
 
     InitializeGLBindings(requested_implementation);
   } else {
     InitializeGLBindings(default_implementation);
   }
 
+  if (GetGLImplementation() == kGLImplementationNone && fallback_to_osmesa)
+    InitializeGLBindings(kGLImplementationOSMesaGL);
+
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableGPUServiceLogging)) {
     InitializeDebugGLBindings();
   }
 
   if (GetGLImplementation() == kGLImplementationNone) {
     LOG(ERROR) << "Could not initialize GL.";
     return false;
   } else {
     LOG(INFO) << "Using "
@@ skipping 47 matching lines @@
   if (g_get_proc_address) {
     void* proc = g_get_proc_address(name);
     if (proc)
       return proc;
   }
 
   return NULL;
 }
 
 }  // namespace gfx