Collect driver vendor in linux through glXGetClientString.

content/gpu/gpu_info_collector_linux.cc

Index: content/gpu/gpu_info_collector_linux.cc
===================================================================
--- content/gpu/gpu_info_collector_linux.cc	(revision 80377)
+++ content/gpu/gpu_info_collector_linux.cc	(working copy)
@@ -161,6 +161,29 @@
   return "";
 }
 
+// Use glXGetClientString to get driver vendor.
+// Return "" on failing.
+std::string CollectDriverVendorGlx() {
+  if (gfx::GetGLImplementation() == gfx::kGLImplementationNone)
+    return "";
+  Display* display = XOpenDisplay(NULL);
+  if (display == NULL)
+    return "";
+  const char* vendor = glXGetClientString(display, GLX_VENDOR);

[piman, 2011/04/06 22:10:00]

I suspect you'll want to copy that into the std::string before you close the
display. Since it doesn't have an explicit lifetime, I assume the string is
owned by the driver, and could be released when you call XCloseDisplay.
Other thing: this code only works with glx which may not be present or
functional (e.g. on ARM devices, we use egl instead). Also, it needs to
explicitly link to libGL which may not exist (e.g. on ARM). You need to use the
GL implementation system instead, which dynamically loads the correct library
instead.

[zmo, 2011/04/06 23:14:34]

Got it.  Will fix.
This is through the GL implementation system.  Only I am not sure what happens
if glx does not exist.  Should I test if the function pointer is null or not?

[piman, 2011/04/06 23:18:01]

Ah, ok, that should be fine then
you probably only want to run this if the GL implementation is GLX. then the
function pointer ought to be there.

+  XCloseDisplay(display);
+  return std::string(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.

[piman, 2011/04/06 22:10:00]

The problem is that the client vendor string for Intel GPUs and other opensource
drivers (e.g. nouveau) is going to say Mesa and SGI. To differentiate, you'll
need the OpenGL renderer string that will say for Intel something like "Mesa DRI
Intel(R) IGD GEM 20100330"

[zmo, 2011/04/06 23:14:34]

This is trying to collect vendor without creating a context.  So GL Renderer
string won't be available.  At the moment I am not sure if there will be a way
to identify Intel GPU solely through glx vendor.

+  return 0;
+}
+
 }  // namespace anonymous
 
 namespace gpu_info_collector {
@@ -197,6 +220,14 @@
 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;
@@ -222,7 +253,8 @@
     (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) {