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

6 files changed, 47 insertions, 29 deletions

diff --git a/app/gfx/gl/gl_context_linux.cc b/app/gfx/gl/gl_context_linux.cc
index 0f28a1d..5fa77ce 100644
--- a/app/gfx/gl/gl_context_linux.cc
+++ b/app/gfx/gl/gl_context_linux.cc
@@ -188,8 +188,8 @@ bool GLContext::InitializeOneOff() {
     return true;
 
   static const GLImplementation kAllowedGLImplementations[] = {
-    kGLImplementationEGLGLES2,
     kGLImplementationDesktopGL,
+    kGLImplementationEGLGLES2,
     kGLImplementationOSMesaGL
   };
 
diff --git a/app/gfx/gl/gl_implementation.cc b/app/gfx/gl/gl_implementation.cc
index fccfb09..30ff0e3 100644
--- a/app/gfx/gl/gl_implementation.cc
+++ b/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) {
diff --git a/app/gfx/gl/gl_implementation.h b/app/gfx/gl/gl_implementation.h
index 2131c19..b8f43f1 100644
--- a/app/gfx/gl/gl_implementation.h
+++ b/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
diff --git a/app/gfx/gl/gl_implementation_linux.cc b/app/gfx/gl/gl_implementation_linux.cc
index 8ac29a3..913429b 100644
--- a/app/gfx/gl/gl_implementation_linux.cc
+++ b/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;
       }
diff --git a/app/gfx/gl/gl_implementation_mac.cc b/app/gfx/gl/gl_implementation_mac.cc
index 0a1d5a5..33f9ea8 100644
--- a/app/gfx/gl/gl_implementation_mac.cc
+++ b/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;
       }
 
diff --git a/app/gfx/gl/gl_implementation_win.cc b/app/gfx/gl/gl_implementation_win.cc
index c3869b1..4ee01c5 100644
--- a/app/gfx/gl/gl_implementation_win.cc
+++ b/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;
       }