Identify the active GPU using GL strings in multiple GPU situation.

gpu/config/gpu_info_collector.cc

 // Copyright (c) 2012 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 "gpu/config/gpu_info_collector.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_version_info.h"
 
 namespace {
 
 scoped_refptr<gfx::GLSurface> InitializeGLSurface() {
@@ skipping 45 matching lines @@
     else
       sub_string = version_string.substr(begin);
     std::vector<std::string> pieces = base::SplitString(
         sub_string, ".", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (pieces.size() >= 2)
       return pieces[0] + "." + pieces[1];
   }
   return std::string();
 }
 
+// Return the array index of the found name, or return -1.
+int StringContainsName(
+    const std::string& str, const std::string* names, size_t num_names) {
+  std::vector<std::string> tokens = base::SplitString(
+      str, " .,()-_", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  for (size_t ii = 0; ii < tokens.size(); ++ii) {
+    for (size_t name_index = 0; name_index < num_names; ++name_index) {
+      if (tokens[ii] == names[name_index])
+        return name_index;
+    }
+  }
+  return -1;
+}
+
 }  // namespace anonymous
 
 namespace gpu {
 
 CollectInfoResult CollectGraphicsInfoGL(GPUInfo* gpu_info) {
   TRACE_EVENT0("startup", "gpu_info_collector::CollectGraphicsInfoGL");
   DCHECK_NE(gfx::GetGLImplementation(), gfx::kGLImplementationNone);
 
   scoped_refptr<gfx::GLSurface> surface(InitializeGLSurface());
   if (!surface.get()) {
@@ skipping 51 matching lines @@
   }
 
   // TODO(kbr): remove once the destruction of a current context automatically
   // clears the current context.
   context->ReleaseCurrent(surface.get());
 
   std::string glsl_version = GetVersionFromString(glsl_version_string);
   gpu_info->pixel_shader_version = glsl_version;
   gpu_info->vertex_shader_version = glsl_version;
 
+  IdentifyActiveGPU(gpu_info);
   return CollectDriverInfoGL(gpu_info);
 }
 
 void MergeGPUInfoGL(GPUInfo* basic_gpu_info,
                     const GPUInfo& context_gpu_info) {
   DCHECK(basic_gpu_info);
+  // Copy over GPUs because which one is active could change.
+  basic_gpu_info->gpu = context_gpu_info.gpu;
+  basic_gpu_info->secondary_gpus = context_gpu_info.secondary_gpus;
+
   basic_gpu_info->gl_renderer = context_gpu_info.gl_renderer;
   basic_gpu_info->gl_vendor = context_gpu_info.gl_vendor;
   basic_gpu_info->gl_version = context_gpu_info.gl_version;
   basic_gpu_info->gl_extensions = context_gpu_info.gl_extensions;
   basic_gpu_info->pixel_shader_version =
       context_gpu_info.pixel_shader_version;
   basic_gpu_info->vertex_shader_version =
       context_gpu_info.vertex_shader_version;
   basic_gpu_info->max_msaa_samples =
       context_gpu_info.max_msaa_samples;
@@ skipping 15 matching lines @@
   basic_gpu_info->context_info_state = context_gpu_info.context_info_state;
   basic_gpu_info->initialization_time = context_gpu_info.initialization_time;
   basic_gpu_info->video_decode_accelerator_supported_profiles =
       context_gpu_info.video_decode_accelerator_supported_profiles;
   basic_gpu_info->video_encode_accelerator_supported_profiles =
       context_gpu_info.video_encode_accelerator_supported_profiles;
   basic_gpu_info->jpeg_decode_accelerator_supported =
       context_gpu_info.jpeg_decode_accelerator_supported;
 }
 
+void IdentifyActiveGPU(GPUInfo* gpu_info) {
+  const std::string kNVidiaName = "nvidia";
+  const std::string kIntelName = "intel";
+  const std::string kAMDName = "amd";
+  const std::string kATIName = "ati";
+  const std::string kVendorNames[] = {
+      kNVidiaName, kIntelName, kAMDName, kATIName};
+
+  const uint32 kNVidiaID = 0x10de;
+  const uint32 kIntelID = 0x8086;
+  const uint32 kAMDID = 0x1002;
+  const uint32 kATIID = 0x1002;
+  const uint32 kVendorIDs[] = {
+      kNVidiaID, kIntelID, kAMDID, kATIID};
+
+  DCHECK(gpu_info);
+  if (gpu_info->secondary_gpus.size() == 0)
+    return;
+
+  uint32 active_vendor_id = 0;
+  if (!gpu_info->gl_vendor.empty()) {
+    std::string gl_vendor_lower = base::ToLowerASCII(gpu_info->gl_vendor);
+    int index = StringContainsName(
+        gl_vendor_lower, kVendorNames, arraysize(kVendorNames));
+    if (index >= 0) {
+      active_vendor_id = kVendorIDs[index];
+    }
+  }
+  if (active_vendor_id == 0 && !gpu_info->gl_renderer.empty()) {
+    std::string gl_renderer_lower = base::ToLowerASCII(gpu_info->gl_renderer);
+    int index = StringContainsName(
+        gl_renderer_lower, kVendorNames, arraysize(kVendorNames));
+    if (index >= 0) {
+      active_vendor_id = kVendorIDs[index];
+    }
+  }
+  if (active_vendor_id == 0) {
+    // We fail to identify the GPU vendor through GL_VENDOR/GL_RENDERER.
+    return;
+  }
+  gpu_info->gpu.active = false;
+  for (size_t ii = 0; ii < gpu_info->secondary_gpus.size(); ++ii)
+    gpu_info->secondary_gpus[ii].active = false;
+
+  // TODO(zmo): if two GPUs are from the same vendor, this code will always
+  // set the first GPU as active, which could be wrong.
+  if (active_vendor_id == gpu_info->gpu.vendor_id) {
+    gpu_info->gpu.active = true;
+    return;
+  }
+  for (size_t ii = 0; ii < gpu_info->secondary_gpus.size(); ++ii) {
+    if (active_vendor_id == gpu_info->secondary_gpus[ii].vendor_id) {
+      gpu_info->secondary_gpus[ii].active = true;
+      return;
+    }
+  }
+}
+
 }  // namespace gpu