Do not lose secondary gpus and make sure to have an active gpu on multiple gpu configurations

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 <stddef.h>
 #include <stdint.h>
 
 #include <string>
 #include <vector>
 
+#include "base/command_line.h"
 #include "base/logging.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 "gpu/config/gpu_switches.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() {
   scoped_refptr<gfx::GLSurface> surface(
@@ skipping 80 matching lines @@
   }
 
   scoped_refptr<gfx::GLContext> context(InitializeGLContext(surface.get()));
   if (!context.get()) {
     LOG(ERROR) << "Could not create context for info collection.";
     return kCollectInfoFatalFailure;
   }
 
   gpu_info->gl_renderer = GetGLString(GL_RENDERER);
   gpu_info->gl_vendor = GetGLString(GL_VENDOR);
+  gpu_info->gl_version = GetGLString(GL_VERSION);
+
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kGpuTestingGLVendor)) {
+    gpu_info->gl_vendor =
+        command_line->GetSwitchValueASCII(switches::kGpuTestingGLVendor);
+  }
+  if (command_line->HasSwitch(switches::kGpuTestingGLRenderer)) {
+    gpu_info->gl_renderer =
+        command_line->GetSwitchValueASCII(switches::kGpuTestingGLRenderer);
+  }
+  if (command_line->HasSwitch(switches::kGpuTestingGLVersion)) {
+    gpu_info->gl_version =
+        command_line->GetSwitchValueASCII(switches::kGpuTestingGLVersion);
+  }
+
   gpu_info->gl_extensions = gfx::GetGLExtensionsFromCurrentContext();
-  gpu_info->gl_version = GetGLString(GL_VERSION);
   std::string glsl_version_string = GetGLString(GL_SHADING_LANGUAGE_VERSION);
 
   gfx::GLVersionInfo gl_info(gpu_info->gl_version.c_str(),
                              gpu_info->gl_renderer.c_str(),
                              gpu_info->gl_extensions.c_str());
   GLint max_samples = 0;
   if (gl_info.IsAtLeastGL(3, 0) || gl_info.IsAtLeastGLES(3, 0) ||
       gpu_info->gl_extensions.find("GL_ANGLE_framebuffer_multisample") !=
           std::string::npos ||
       gpu_info->gl_extensions.find("GL_APPLE_framebuffer_multisample") !=
@@ skipping 75 matching lines @@
   basic_gpu_info->video_decode_accelerator_capabilities =
       context_gpu_info.video_decode_accelerator_capabilities;
   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 kNouveauName = "nouveau";
   const std::string kIntelName = "intel";
   const std::string kAMDName = "amd";
   const std::string kATIName = "ati";
-  const std::string kVendorNames[] = {
-      kNVidiaName, kIntelName, kAMDName, kATIName};
+  const std::string kRadeonName = "radeon";

[Zhenyao Mo, 2016/04/19 21:05:27]

Really?  We have drivers with "Radeon" as vendor string?

[Julien Isorce Samsung, 2016/04/20 17:19:21]

You are right it is wrong, I double checked in Mesa source code and for the open
source radeon driver we cannot rely on the vendor name since it will be either
"X.Org" or "X.Org R300 Project". But we can rely on the renderer string which
would contain either ATI or AMD so existing code is fine for AMD hardware. But
"nouveau" still required.
(see
https://cgit.freedesktop.org/mesa/mesa/tree/src/gallium/drivers/radeon/r600_p...)
So I'll remove kRadeonName.

+  const std::string kVendorNames[] = {kNVidiaName, kNouveauName, kIntelName,
+                                      kAMDName,    kATIName,     kRadeonName};
 
   const uint32_t kNVidiaID = 0x10de;
   const uint32_t kIntelID = 0x8086;
   const uint32_t kAMDID = 0x1002;
   const uint32_t kATIID = 0x1002;
-  const uint32_t kVendorIDs[] = {kNVidiaID, kIntelID, kAMDID, kATIID};
+  const uint32_t kVendorIDs[] = {kNVidiaID, kNVidiaID, kIntelID,
+                                 kAMDID,    kATIID,    kAMDID};
 
   DCHECK(gpu_info);
   if (gpu_info->secondary_gpus.size() == 0)
     return;
 
   uint32_t 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));
@@ skipping 26 matching lines @@
   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