Add bits to indicate which parts of GPUInfo are collected.

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 353 matching lines @@
 // This function has a real implementation for official builds that can
 // be found in src/third_party/amd.
 void GetAMDVideocardInfo(GPUInfo* gpu_info);
 #else
 void GetAMDVideocardInfo(GPUInfo* gpu_info) {
   DCHECK(gpu_info);
   return;
 }
 #endif
 
-bool CollectDriverInfoD3D(const std::wstring& device_id,
-                          GPUInfo* gpu_info) {
+CollectInfoResult CollectDriverInfoD3D(const std::wstring& device_id,
+                                       GPUInfo* gpu_info) {
   TRACE_EVENT0("gpu", "CollectDriverInfoD3D");
 
   // create device info for the display device
   HDEVINFO device_info = SetupDiGetClassDevsW(
       NULL, device_id.c_str(), NULL,
       DIGCF_PRESENT | DIGCF_PROFILE | DIGCF_ALLCLASSES);
   if (device_info == INVALID_HANDLE_VALUE) {
     LOG(ERROR) << "Creating device info failed";
-    return false;
+    return kCollectInfoNonFatalResult;
   }
 
   DWORD index = 0;
   bool found = false;
   SP_DEVINFO_DATA device_info_data;
   device_info_data.cbSize = sizeof(device_info_data);
   while (SetupDiEnumDeviceInfo(device_info, index++, &device_info_data)) {
     WCHAR value[255];
     if (SetupDiGetDeviceRegistryPropertyW(device_info,
                                         &device_info_data,
@@ skipping 51 matching lines @@
         gpu_info->driver_vendor = driver_vendor;
         gpu_info->driver_version = driver_version;
         gpu_info->driver_date = driver_date;
         found = true;
         RegCloseKey(key);
         break;
       }
     }
   }
   SetupDiDestroyDeviceInfoList(device_info);
-  return found;
+  return found ? kCollectInfoSuccess ? kCollectInfoNonFatalFailure;

[piman, 2014/09/03 00:50:55]

typo?

[Zhenyao Mo, 2014/09/03 01:31:23]

Done.

 }
 
 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;
+      gpu_info->context_info_state = kCollectInfoNonFatalFailure;
       return kCollectInfoNonFatalFailure;
     }
   }
 
   CollectInfoResult result = CollectGraphicsInfoGL(gpu_info);
-  if (result != kCollectInfoSuccess)
+  if (result != kCollectInfoSuccess) {
+    gpu_info->context_info_state = result;
     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 23 matching lines @@
     // Google, Inc. (adapter LUID: 0123456789ABCDEF)
     // The LUID is optional and identifies the GPU adapter ANGLE is using.
     const char* egl_vendor = eglQueryString(
         gfx::GLSurfaceEGL::GetHardwareDisplay(),
         EGL_VENDOR);
     RE2::PartialMatch(egl_vendor,
                       " \\(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;
+    // couple of seconds.
   } else {
-    gpu_info->finalized = true;
+    gpu_info->dx_diagnostics_info_state = kCollectInfoNonFatalFailure;
   }
 
+  gpu_info->context_info_state = kCollectInfoSuccess;
   return kCollectInfoSuccess;
 }
 
-GpuIDResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
+CollectInfoResult 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);
   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) {
     int vendor = 0, device = 0;
     std::wstring vendor_string = id.substr(8, 4);
     std::wstring device_string = id.substr(17, 4);
     base::HexStringToInt(base::UTF16ToASCII(vendor_string), &vendor);
     base::HexStringToInt(base::UTF16ToASCII(device_string), &device);
     *vendor_id = vendor;
     *device_id = device;
     if (*vendor_id != 0 && *device_id != 0)
-      return kGpuIDSuccess;
+      return kCollectInfoSuccess;
   }
-  return kGpuIDFailure;
+  return kCollectInfoNonFatalFailure;
 }
 
 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.
@@ skipping 22 matching lines @@
   DISPLAY_DEVICE dd;
   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)
+  if (id.length() <= 20) {
+    gpu_info->basic_info_state = kCollectInfoNonFatalFailure;
     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(base::UTF16ToASCII(vendor_id_string), &vendor_id);
   base::HexStringToInt(base::UTF16ToASCII(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))
+  if (!CollectDriverInfoD3D(id, gpu_info)) {
+    gpu_info->basic_info_state = kCollectInfoNonFatalFailure;
     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));
     }
   }
 
+  gpu_info->basic_info_state = kCollectInfoSuccess;
   return kCollectInfoSuccess;
 }
 
 CollectInfoResult CollectDriverInfoGL(GPUInfo* gpu_info) {
   TRACE_EVENT0("gpu", "CollectDriverInfoGL");
 
   if (!gpu_info->driver_version.empty())
     return kCollectInfoSuccess;
 
   bool parsed = RE2::PartialMatch(
       gpu_info->gl_version, "([\\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