Make gpu black list work again on Linux

content/browser/gpu/gpu_data_manager_impl_private.cc

 // Copyright (c) 2013 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/browser/gpu/gpu_data_manager_impl_private.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
@@ skipping 459 matching lines @@
       !gpu_info_.gl_version.empty())
     return;
 
   gpu::GPUInfo gpu_info = gpu_info_;
 
   gpu_info.gl_vendor = gl_vendor;
   gpu_info.gl_renderer = gl_renderer;
   gpu_info.gl_version = gl_version;
 
   gpu::IdentifyActiveGPU(&gpu_info);
-  gpu::CollectDriverInfoGL(&gpu_info);
+
+  // Give a chance to IsEssentialGpuInfoAvailable() to return true. Useful
+  // to prevent launching the gpu process from SystemInfoHandler::GetInfo
+  // from DevToolsHttpHandler when running python browser tests.
+  gpu_info.context_info_state = gpu::CollectDriverInfoGL(&gpu_info);

[Zhenyao Mo, 2016/02/01 20:25:39]

Sorry that I didn't realize this in the first place.

This is actually very wrong. It will cause IsCompleteGpuInfoAvailable() to
return true, and therefore, it prevents us from collect full GPU info.

 
   UpdateGpuInfo(gpu_info);
   UpdateGpuSwitchingManager(gpu_info);
   UpdatePreliminaryBlacklistedFeatures();
 }
 
 void GpuDataManagerImplPrivate::GetGLStrings(std::string* gl_vendor,
                                              std::string* gl_renderer,
                                              std::string* gl_version) {
   DCHECK(gl_vendor && gl_renderer && gl_version);
@@ skipping 25 matching lines @@
     gpu_info.gpu.vendor_id = 0xffff;
     gpu_info.gpu.device_id = 0xffff;
 
     // Also declare the driver_vendor to be osmesa to be able to specify
     // exceptions based on driver_vendor==osmesa for some blacklist rules.
     gpu_info.driver_vendor = gfx::kGLImplementationOSMesaName;
   } else {
     TRACE_EVENT0("startup",
       "GpuDataManagerImpl::Initialize:CollectBasicGraphicsInfo");
     gpu::CollectBasicGraphicsInfo(&gpu_info);
+
+    if (command_line->HasSwitch(switches::kGpuTestingVendorId)) {

[Zhenyao Mo, 2016/02/01 20:19:36]

It should always be the case that we either specify both vendor/device or we
specify either.  So can you change the code to that? Also, you need to clear
gpu_info.secondary_gpus to avoid unexpected testing behavior.

+      base::HexStringToUInt(
+          command_line->GetSwitchValueASCII(switches::kGpuTestingVendorId),
+          &gpu_info.gpu.vendor_id);
+      gpu_info.gpu.active = true;
+    }
+
+    if (command_line->HasSwitch(switches::kGpuTestingDeviceId)) {
+      base::HexStringToUInt(
+          command_line->GetSwitchValueASCII(switches::kGpuTestingDeviceId),
+          &gpu_info.gpu.device_id);
+      gpu_info.gpu.active = true;
+    }
   }
 #if defined(ARCH_CPU_X86_FAMILY)
   if (!gpu_info.gpu.vendor_id || !gpu_info.gpu.device_id) {
     gpu_info.context_info_state = gpu::kCollectInfoNonFatalFailure;
 #if defined(OS_WIN)
     gpu_info.dx_diagnostics_info_state = gpu::kCollectInfoNonFatalFailure;
 #endif  // OS_WIN
   }
 #endif  // ARCH_CPU_X86_FAMILY
 
@@ skipping 13 matching lines @@
   if (command_line->HasSwitch(switches::kSingleProcess) ||
       command_line->HasSwitch(switches::kInProcessGPU)) {
     command_line->AppendSwitch(switches::kDisableGpuWatchdog);
     AppendGpuCommandLine(command_line);
   }
 }
 
 void GpuDataManagerImplPrivate::UpdateGpuInfoHelper() {
   GetContentClient()->SetGpuInfo(gpu_info_);
 
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
+
+  std::string os_version;
+  if (command_line->HasSwitch(switches::kGpuTestingOsVersion))
+    os_version =
+        command_line->GetSwitchValueASCII(switches::kGpuTestingOsVersion);
+
   if (gpu_blacklist_) {
     std::set<int> features = gpu_blacklist_->MakeDecision(
-        gpu::GpuControlList::kOsAny, std::string(), gpu_info_);
+        gpu::GpuControlList::kOsAny, os_version, gpu_info_);
     if (update_histograms_)
       UpdateStats(gpu_info_, gpu_blacklist_.get(), features);
 
     UpdateBlacklistedFeatures(features);
   }
   if (gpu_driver_bug_list_) {
     gpu_driver_bugs_ = gpu_driver_bug_list_->MakeDecision(
-        gpu::GpuControlList::kOsAny, std::string(), gpu_info_);
+        gpu::GpuControlList::kOsAny, os_version, gpu_info_);
 
     std::set<std::string> disabled_ext_set;
 
     // Merge disabled extensions from the command line with gpu driver bug list.
-    const base::CommandLine* command_line =
-        base::CommandLine::ForCurrentProcess();
     if (command_line) {
       const std::vector<std::string>& disabled_command_line_exts =
           base::SplitString(
               command_line->GetSwitchValueASCII(switches::kDisableGLExtensions),
               ", ;", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
       disabled_ext_set.insert(disabled_command_line_exts.begin(),
                               disabled_command_line_exts.end());
     }
     const std::vector<std::string>& disabled_driver_bug_exts =
         gpu_driver_bug_list_->GetDisabledExtensions();
@@ skipping 607 matching lines @@
   gpu_info_.context_info_state = gpu::kCollectInfoFatalFailure;
 #if defined(OS_WIN)
   gpu_info_.dx_diagnostics_info_state = gpu::kCollectInfoFatalFailure;
 #endif
   complete_gpu_info_already_requested_ = true;
   // Some observers might be waiting.
   NotifyGpuInfoUpdate();
 }
 
 }  // namespace content