Relanding r71472.

Use GL rather than EGL by default on linux. 

Debug Chromium builds display an error if they don't find EGL, even if GLX is available. This prompts people to install the EGL packages, even though that probably isn't their issue. 

Also, it looks like EGL, even if available, has some issues. 

If GLX isn't available, it still falls back to EGL. 

--use-gl=desktop should not be required to force use of GLX on boxes that also have EGL installed. 

Changed LOG(ERROR) to VLOG(1) if a shared library fails to load since this is not necessarily an error. Report an error only if no GL implementation can be initialized. Log which GL implementation was selected. 

TEST=launch chrome with various combinations of --use-gl switch and check the log output is correct. 
BUG=none 


Review URL: http://codereview.chromium.org/6325005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@71508 0039d316-1c4b-4281-b951-d872f2087c98

app/gfx/gl/gl_context_linux.cc

@@ -188,8 +188,8 @@ bool GLContext::InitializeOneOff() {
     return true;
 
   static const GLImplementation kAllowedGLImplementations[] = {
-    kGLImplementationEGLGLES2,
     kGLImplementationDesktopGL,
+    kGLImplementationEGLGLES2,
     kGLImplementationOSMesaGL
   };
 

app/gfx/gl/gl_implementation.cc

@@ -21,6 +21,16 @@ const char kGLImplementationMockName[]    = "mock";
 
 namespace {
 
+const struct {
+  const char* name;
+  GLImplementation implementation;
+} kGLImplementationNamePairs[] = {
+  { kGLImplementationDesktopName, kGLImplementationDesktopGL },
+  { kGLImplementationOSMesaName, kGLImplementationOSMesaGL },
+  { kGLImplementationEGLName, kGLImplementationEGLGLES2 },
+  { kGLImplementationMockName, kGLImplementationMockGL }
+};
+
 typedef std::vector<base::NativeLibrary> LibraryArray;
 
 GLImplementation g_gl_implementation = kGLImplementationNone;
@@ -40,24 +50,23 @@ void CleanupNativeLibraries(void* unused) {
 }
 
 GLImplementation GetNamedGLImplementation(const std::string& name) {
-  static const struct {
-    const char* name;
-    GLImplementation implemention;
-  } name_pairs[] = {
-    { kGLImplementationDesktopName, kGLImplementationDesktopGL },
-    { kGLImplementationOSMesaName, kGLImplementationOSMesaGL },
-    { kGLImplementationEGLName, kGLImplementationEGLGLES2 },
-    { kGLImplementationMockName, kGLImplementationMockGL }
-  };
-
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(name_pairs); ++i) {
-    if (name == name_pairs[i].name)
-      return name_pairs[i].implemention;
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kGLImplementationNamePairs); ++i) {
+    if (name == kGLImplementationNamePairs[i].name)
+      return kGLImplementationNamePairs[i].implementation;
   }
 
   return kGLImplementationNone;
 }
 
+const char* GetGLImplementationName(GLImplementation implementation) {
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kGLImplementationNamePairs); ++i) {
+    if (implementation == kGLImplementationNamePairs[i].implementation)
+      return kGLImplementationNamePairs[i].name;
+  }
+
+  return "unknown";
+}
+
 bool InitializeBestGLBindings(
     const GLImplementation* allowed_implementations_begin,
     const GLImplementation* allowed_implementations_end) {
@@ -69,23 +78,29 @@ bool InitializeBestGLBindings(
     if (std::find(allowed_implementations_begin,
                   allowed_implementations_end,
                   requested_implementation) == allowed_implementations_end) {
-      LOG(ERROR) << "Requested GL implementation is not allowed.";
+      LOG(ERROR) << "Requested GL implementation is not available.";
       return false;
     }
 
-    if (InitializeGLBindings(requested_implementation))
-      return true;
+    InitializeGLBindings(requested_implementation);
   } else {
     for (const GLImplementation* p = allowed_implementations_begin;
          p < allowed_implementations_end;
          ++p) {
       if (InitializeGLBindings(*p))
-        return true;
+        break;
     }
   }
 
-  LOG(ERROR) << "Could not initialize GL.";
-  return false;
+  if (GetGLImplementation() == kGLImplementationNone) {
+    LOG(ERROR) << "Could not initialize GL.";
+    return false;
+  } else {
+    LOG(INFO) << "Using "
+              << GetGLImplementationName(GetGLImplementation())
+              << " GL implementation.";
+    return true;
+  }
 }
 
 void SetGLImplementation(GLImplementation implementation) {

app/gfx/gl/gl_implementation.h

@@ -49,6 +49,9 @@ GLImplementation GetGLImplementation();
 // Get the GL implementation with a given name.
 GLImplementation GetNamedGLImplementation(const std::wstring& name);
 
+// Get the name of a GL implementation.
+const char* GetGLImplementationName(GLImplementation implementation);
+
 // Initialize the preferred GL binding from the given list. The preferred GL
 // bindings depend on command line switches passed by the user and which GL
 // implementations are available and working on the system

app/gfx/gl/gl_implementation_linux.cc

@@ -47,7 +47,7 @@ bool InitializeGLBindings(GLImplementation implementation) {
       base::NativeLibrary library = base::LoadNativeLibrary(
           module_path.Append("libosmesa.so"));
       if (!library) {
-        DVLOG(1) << "libosmesa.so not found";
+        VLOG(1) << "libosmesa.so not found";
         return false;
       }
 
@@ -56,7 +56,7 @@ bool InitializeGLBindings(GLImplementation implementation) {
               base::GetFunctionPointerFromNativeLibrary(
                   library, "OSMesaGetProcAddress"));
       if (!get_proc_address) {
-        DLOG(ERROR) << "OSMesaGetProcAddress not found.";
+        LOG(ERROR) << "OSMesaGetProcAddress not found.";
         base::UnloadNativeLibrary(library);
         return false;
       }
@@ -73,7 +73,7 @@ bool InitializeGLBindings(GLImplementation implementation) {
       base::NativeLibrary library = base::LoadNativeLibrary(
           FilePath("libGL.so.1"));
       if (!library) {
-        LOG(ERROR) << "libGL.so.1 not found.";
+        VLOG(1) << "libGL.so.1 not found.";
         return false;
       }
 
@@ -99,14 +99,14 @@ bool InitializeGLBindings(GLImplementation implementation) {
       base::NativeLibrary gles_library = base::LoadNativeLibrary(
           FilePath("libGLESv2.so"));
       if (!gles_library) {
-        DLOG(ERROR) << "libGLESv2.so not found";
+        VLOG(1) << "libGLESv2.so not found";
         return false;
       }
 
       base::NativeLibrary egl_library = base::LoadNativeLibrary(
           FilePath("libEGL.so"));
       if (!egl_library) {
-        DLOG(ERROR) << "libEGL.so not found";
+        VLOG(1) << "libEGL.so not found";
         base::UnloadNativeLibrary(gles_library);
         return false;
       }

app/gfx/gl/gl_implementation_mac.cc

@@ -35,7 +35,7 @@ bool InitializeGLBindings(GLImplementation implementation) {
       base::NativeLibrary library = base::LoadNativeLibrary(
           module_path.Append("osmesa.so"));
       if (!library) {
-        DVLOG(1) << "osmesa.so not found";
+        VLOG(1) << "osmesa.so not found";
         return false;
       }
 

app/gfx/gl/gl_implementation_win.cc

@@ -45,7 +45,7 @@ bool InitializeGLBindings(GLImplementation implementation) {
       base::NativeLibrary library = base::LoadNativeLibrary(
           module_path.Append(L"osmesa.dll"));
       if (!library) {
-        DVLOG(1) << "osmesa.dll not found";
+        VLOG(1) << "osmesa.dll not found";
         return false;
       }
 
@@ -78,7 +78,7 @@ bool InitializeGLBindings(GLImplementation implementation) {
       base::NativeLibrary gles_library = base::LoadNativeLibrary(
           module_path.Append(L"libglesv2.dll"));
       if (!gles_library) {
-        LOG(ERROR) << "libglesv2.dll not found";
+        VLOG(1) << "libglesv2.dll not found";
         return false;
       }
 
@@ -87,7 +87,7 @@ bool InitializeGLBindings(GLImplementation implementation) {
       base::NativeLibrary egl_library = base::LoadNativeLibrary(
           module_path.Append(L"libegl.dll"));
       if (!egl_library) {
-        LOG(ERROR) << "libegl.dll not found.";
+        VLOG(1) << "libegl.dll not found.";
         base::UnloadNativeLibrary(gles_library);
         return false;
       }