linux: don't always print dlopen errors from LoadNativeLibrary

ui/gfx/gl/gl_implementation_linux.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 <vector>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/native_library.h"
 #include "base/path_service.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #include "ui/gfx/gl/gl_implementation.h"
 
 namespace gfx {
 namespace {
 
 // TODO(piman): it should be Desktop GL marshalling from double to float. Today
 // on native GLES, we do float->double->float.
 void GL_BINDING_CALL MarshalClearDepthToClearDepthf(GLclampd depth) {
   glClearDepthf(static_cast<GLclampf>(depth));
 }
 
 void GL_BINDING_CALL MarshalDepthRangeToDepthRangef(GLclampd z_near,
                                                     GLclampd z_far) {
   glDepthRangef(static_cast<GLclampf>(z_near), static_cast<GLclampf>(z_far));
 }
 
+// Load a library, printing an error message on failure.
+base::NativeLibrary LoadLibrary(const char* filename) {
+  std::string error;
+  base::NativeLibrary library = base::LoadNativeLibrary(FilePath(filename),
+                                                        &error);
+  if (!library) {
+    VLOG(1) << "Failed to load " << filename << ": " << error;
+    return NULL;
+  }
+  return library;
+}
+
 }  // namespace anonymous
 
 bool InitializeGLBindings(GLImplementation implementation) {
   // Prevent reinitialization with a different implementation. Once the gpu
   // unit tests have initialized with kGLImplementationMock, we don't want to
   // later switch to another GL implementation.
   if (GetGLImplementation() != kGLImplementationNone)
     return true;
 
   switch (implementation) {
     case kGLImplementationOSMesaGL: {
       FilePath module_path;
       if (!PathService::Get(base::DIR_MODULE, &module_path)) {
         LOG(ERROR) << "PathService::Get failed.";
         return false;
       }
 
-      base::NativeLibrary library = base::LoadNativeLibrary(
-          module_path.Append("libosmesa.so"));
-      if (!library) {
-        VLOG(1) << "libosmesa.so not found";
+      base::NativeLibrary library = LoadLibrary("libosmesa.so");
+      if (!library)
         return false;
-      }
 
       GLGetProcAddressProc get_proc_address =
           reinterpret_cast<GLGetProcAddressProc>(
               base::GetFunctionPointerFromNativeLibrary(
                   library, "OSMesaGetProcAddress"));
       if (!get_proc_address) {
         LOG(ERROR) << "OSMesaGetProcAddress not found.";
         base::UnloadNativeLibrary(library);
         return false;
       }
 
       SetGLGetProcAddressProc(get_proc_address);
       AddGLNativeLibrary(library);
       SetGLImplementation(kGLImplementationOSMesaGL);
 
       InitializeGLBindingsGL();
       InitializeGLBindingsOSMESA();
       break;
     }
     case kGLImplementationDesktopGL: {
-      base::NativeLibrary library = base::LoadNativeLibrary(
-          FilePath("libGL.so.1"));
-      if (!library) {
-        VLOG(1) << "libGL.so.1 not found.";
+      base::NativeLibrary library = LoadLibrary("libGL.so.1");
+      if (!library)
         return false;
-      }
 
       GLGetProcAddressProc get_proc_address =
           reinterpret_cast<GLGetProcAddressProc>(
               base::GetFunctionPointerFromNativeLibrary(
                   library, "glXGetProcAddress"));
       if (!get_proc_address) {
         LOG(ERROR) << "glxGetProcAddress not found.";
         base::UnloadNativeLibrary(library);
         return false;
       }
 
       SetGLGetProcAddressProc(get_proc_address);
       AddGLNativeLibrary(library);
       SetGLImplementation(kGLImplementationDesktopGL);
 
       InitializeGLBindingsGL();
       InitializeGLBindingsGLX();
       break;
     }
     case kGLImplementationEGLGLES2: {
-      base::NativeLibrary gles_library = base::LoadNativeLibrary(
-          FilePath("libGLESv2.so"));
-      if (!gles_library) {
-        VLOG(1) << "libGLESv2.so not found";
+      base::NativeLibrary gles_library = LoadLibrary("libGLESv2.so");
+      if (!gles_library)
         return false;
-      }
-
-      base::NativeLibrary egl_library = base::LoadNativeLibrary(
-          FilePath("libEGL.so"));
-      if (!egl_library) {
-        VLOG(1) << "libEGL.so not found";
-        base::UnloadNativeLibrary(gles_library);
+      base::NativeLibrary egl_library = LoadLibrary("libEGL.so");
+      if (!egl_library)
         return false;
-      }
 
       GLGetProcAddressProc get_proc_address =
           reinterpret_cast<GLGetProcAddressProc>(
               base::GetFunctionPointerFromNativeLibrary(
                   egl_library, "eglGetProcAddress"));
       if (!get_proc_address) {
         LOG(ERROR) << "eglGetProcAddress not found.";
         base::UnloadNativeLibrary(egl_library);
         base::UnloadNativeLibrary(gles_library);
         return false;
@@ skipping 28 matching lines @@
 }
 
 void InitializeDebugGLBindings() {
   InitializeDebugGLBindingsEGL();
   InitializeDebugGLBindingsGL();
   InitializeDebugGLBindingsGLX();
   InitializeDebugGLBindingsOSMESA();
 }
 
 }  // namespace gfx