Collect driver vendor in linux through glXGetClientString.

content/gpu/gpu_info_collector_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 "content/gpu/gpu_info_collector.h"
 
 #include <dlfcn.h>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 143 matching lines @@
         if (end == std::string::npos)
           return line.substr(begin);
         else
           return line.substr(begin, end - begin);
       }
     }
   }
   return "";
 }
 
+// Use glXGetClientString to get driver vendor.
+// Return "" on failing.
+std::string CollectDriverVendorGlx() {
+  // TODO(zmo): handle the EGL/GLES2 case.
+  if (gfx::GetGLImplementation() != gfx::kGLImplementationDesktopGL)
+    return "";
+  Display* display = XOpenDisplay(NULL);
+  if (display == NULL)
+    return "";
+  std::string vendor = glXGetClientString(display, GLX_VENDOR);
+  XCloseDisplay(display);
+  return vendor;
+}
+
+// Return 0 on unrecognized vendor.
+uint32 VendorStringToID(const std::string& vendor_string) {
+  if (StartsWithASCII(vendor_string, "NVIDIA", true))
+    return 0x10de;
+  if (StartsWithASCII(vendor_string, "ATI", true))
+    return 0x1002;
+  // TODO(zmo): find a way to identify Intel cards.
+  return 0;
+}
+
 }  // namespace anonymous
 
 namespace gpu_info_collector {
 
 bool CollectGraphicsInfo(GPUInfo* gpu_info) {
   DCHECK(gpu_info);
 
   // TODO(zmo): need to consider the case where we are running on top of
   // desktop GL and GL_ARB_robustness extension is available.
   gpu_info->can_lose_context =
@@ skipping 16 matching lines @@
       gpu_info->driver_version = ati_driver_version;
     }
   }
 
   return rt;
 }
 
 bool CollectVideoCardInfo(GPUInfo* gpu_info) {
   DCHECK(gpu_info);
 
+  std::string driver_vendor = CollectDriverVendorGlx();
+  if (!driver_vendor.empty()) {
+    gpu_info->driver_vendor = driver_vendor;
+    uint32 vendor_id = VendorStringToID(driver_vendor);
+    if (vendor_id != 0)
+      gpu_info->vendor_id = vendor_id;
+  }
+
   if (IsPciSupported() == false) {
     VLOG(1) << "PCI bus scanning is not supported";
     return false;
   }
 
   // TODO(zmo): be more flexible about library name.
   PciInterface* interface = InitializeLibPci("libpci.so.3");
   if (interface == NULL)
     interface = InitializeLibPci("libpci.so");
   if (interface == NULL) {
     VLOG(1) << "Failed to locate libpci";
     return false;
   }
 
   PciAccess* access = (interface->pci_alloc)();
   DCHECK(access != NULL);
   (interface->pci_init)(access);
   (interface->pci_scan_bus)(access);
   std::vector<PciDevice*> gpu_list;
   PciDevice* gpu_active = NULL;
   for (PciDevice* device = access->device_list;
        device != NULL; device = device->next) {
     (interface->pci_fill_info)(device, 33);  // Fill the IDs and class fields.
     // TODO(zmo): there might be other classes that qualify as display devices.
     if (device->device_class == 0x0300) {  // Device class is DISPLAY_VGA.
-      gpu_list.push_back(device);
+      if (gpu_info->vendor_id == 0 || gpu_info->vendor_id == device->vendor_id)
+        gpu_list.push_back(device);
     }
   }
   if (gpu_list.size() == 1) {
     gpu_active = gpu_list[0];
   } else {
     // If more than one graphics card are identified, find the one that matches
     // gl VENDOR and RENDERER info.
     std::string gl_vendor_string = gpu_info->gl_vendor;
     std::string gl_renderer_string = gpu_info->gl_renderer;
     const int buffer_size = 255;
@@ skipping 66 matching lines @@
     return false;
   if (pos != std::string::npos)
     driver_version = driver_version.substr(0, pos);
 
   gpu_info->driver_vendor = pieces[1];
   gpu_info->driver_version = driver_version;
   return true;
 }
 
 }  // namespace gpu_info_collector