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() {
+  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 {
 
 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