Blacklist GLX indirect rendering

gpu/config/gpu_info_collector_win.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"
 
 // This has to be included before windows.h.
 #include "third_party/re2/re2/re2.h"
 
 #include <windows.h>
@@ skipping 431 matching lines @@
         found = true;
         RegCloseKey(key);
         break;
       }
     }
   }
   SetupDiDestroyDeviceInfoList(device_info);
   return found;
 }
 
-bool CollectContextGraphicsInfo(GPUInfo* gpu_info) {
+CollectInfoResult CollectContextGraphicsInfo(GPUInfo* gpu_info) {
   TRACE_EVENT0("gpu", "CollectGraphicsInfo");
 
   DCHECK(gpu_info);
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kUseGL)) {
     std::string requested_implementation_name =
         CommandLine::ForCurrentProcess()->GetSwitchValueASCII(switches::kUseGL);
     if (requested_implementation_name == "swiftshader") {
       gpu_info->software_rendering = true;
-      return false;
+      return kCollectInfoNonFatalFailure;
     }
   }
 
-  if (!CollectGraphicsInfoGL(gpu_info))
-    return false;
+  CollectInfoResult result = CollectGraphicsInfoGL(gpu_info);
+  if (result != kCollectInfoSuccess)
+    return result;
 
   // ANGLE's renderer strings are of the form:
   // ANGLE (<adapter_identifier> Direct3D<version> vs_x_x ps_x_x)
   std::string direct3d_version;
   int vertex_shader_major_version = 0;
   int vertex_shader_minor_version = 0;
   int pixel_shader_major_version = 0;
   int pixel_shader_minor_version = 0;
   gpu_info->adapter_luid = 0;
   if (RE2::FullMatch(gpu_info->gl_renderer,
@@ skipping 29 matching lines @@
                       " \\(adapter LUID: ([0-9A-Fa-f]{16})\\)",
                       RE2::Hex(&gpu_info->adapter_luid));
 
     // DirectX diagnostics are collected asynchronously because it takes a
     // couple of seconds. Do not mark gpu_info as complete until that is done.
     gpu_info->finalized = false;
   } else {
     gpu_info->finalized = true;
   }
 
-  return true;
+  return kCollectInfoSuccess;
 }
 
 GpuIDResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
   DCHECK(vendor_id && device_id);
   *vendor_id = 0;
   *device_id = 0;
 
   // Taken from http://developer.nvidia.com/object/device_ids.html
   DISPLAY_DEVICE dd;
   dd.cb = sizeof(DISPLAY_DEVICE);
@@ skipping 11 matching lines @@
     std::wstring device_string = id.substr(17, 4);
     base::HexStringToInt(WideToASCII(vendor_string), &vendor);
     base::HexStringToInt(WideToASCII(device_string), &device);
     *vendor_id = vendor;
     *device_id = device;
     return kGpuIDSuccess;
   }
   return kGpuIDFailure;
 }
 
-bool CollectBasicGraphicsInfo(GPUInfo* gpu_info) {
+CollectInfoResult CollectBasicGraphicsInfo(GPUInfo* gpu_info) {
   TRACE_EVENT0("gpu", "CollectPreliminaryGraphicsInfo");
 
   DCHECK(gpu_info);
 
   gpu_info->performance_stats = RetrieveGpuPerformanceStatsWithHistograms();
 
   // nvd3d9wrap.dll is loaded into all processes when Optimus is enabled.
   HMODULE nvd3d9wrap = GetModuleHandleW(L"nvd3d9wrap.dll");
   gpu_info->optimus = nvd3d9wrap != NULL;
 
@@ skipping 20 matching lines @@
   dd.cb = sizeof(DISPLAY_DEVICE);
   std::wstring id;
   for (int i = 0; EnumDisplayDevices(NULL, i, &dd, 0); ++i) {
     if (dd.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) {
       id = dd.DeviceID;
       break;
     }
   }
 
   if (id.length() <= 20)
-    return false;
+    return kCollectInfoNonFatalFailure;
 
   int vendor_id = 0, device_id = 0;
   base::string16 vendor_id_string = id.substr(8, 4);
   base::string16 device_id_string = id.substr(17, 4);
   base::HexStringToInt(WideToASCII(vendor_id_string), &vendor_id);
   base::HexStringToInt(WideToASCII(device_id_string), &device_id);
   gpu_info->gpu.vendor_id = vendor_id;
   gpu_info->gpu.device_id = device_id;
   // TODO(zmo): we only need to call CollectDriverInfoD3D() if we use ANGLE.
   if (!CollectDriverInfoD3D(id, gpu_info))
-    return false;
+    return kCollectInfoNonFatalFailure;
 
   // Collect basic information about supported D3D11 features. Delay for 45
   // seconds so as not to regress performance tests.
   if (D3D11ShouldWork(*gpu_info)) {
     // This is on a field trial so we can turn it off easily if it blows up
     // again in stable channel.
     scoped_refptr<base::FieldTrial> trial(
         base::FieldTrialList::FactoryGetFieldTrial(
             "D3D11Experiment", 100, "Disabled", 2015, 7, 8,
             base::FieldTrial::SESSION_RANDOMIZED, NULL));
     const int enabled_group =
         trial->AppendGroup("Enabled", 0);
 
     if (trial->group() == enabled_group) {
       base::MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&CollectD3D11Support),
           base::TimeDelta::FromSeconds(45));
     }
   }
 
-  return true;
+  return kCollectInfoSuccess;
 }
 
-bool CollectDriverInfoGL(GPUInfo* gpu_info) {
+CollectInfoResult CollectDriverInfoGL(GPUInfo* gpu_info) {
   TRACE_EVENT0("gpu", "CollectDriverInfoGL");
 
   if (!gpu_info->driver_version.empty())
-    return true;
+    return kCollectInfoSuccess;
 
   std::string gl_version_string = gpu_info->gl_version_string;
 
-  return RE2::PartialMatch(gl_version_string,
-                           "([\\d\\.]+)$",
-                           &gpu_info->driver_version);
+  bool parsed = RE2::PartialMatch(
+      gl_version_string, "([\\d\\.]+)$", &gpu_info->driver_version);
+  return parsed ? kCollectInfoSuccess : kCollectInfoNonFatalFailure;
 }
 
 void MergeGPUInfo(GPUInfo* basic_gpu_info,
                   const GPUInfo& context_gpu_info) {
   DCHECK(basic_gpu_info);
 
   if (context_gpu_info.software_rendering) {
     basic_gpu_info->software_rendering = true;
     return;
   }
 
   MergeGPUInfoGL(basic_gpu_info, context_gpu_info);
 
   basic_gpu_info->dx_diagnostics = context_gpu_info.dx_diagnostics;
 }
 
 }  // namespace gpu