Add bits to indicate which parts of GPUInfo are collected.

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/debug/trace_event.h"
@@ skipping 208 matching lines @@
   CGGetActiveDisplayList(0, NULL, &displayCount);
   if (displayCount != manager->GetDisplayCount()) {
     manager->SetDisplayCount(displayCount);
     display_changed = true;
   }
 
   // Gpu change.
   bool gpu_changed = false;
   if (flags & kCGDisplayAddFlag) {
     uint32 vendor_id, device_id;
-    if (gpu::CollectGpuID(&vendor_id, &device_id) == gpu::kGpuIDSuccess) {
+    if (gpu::CollectGpuID(&vendor_id, &device_id) == gpu::kCollectInfoSuccess) {
       gpu_changed = manager->UpdateActiveGpu(vendor_id, device_id);
     }
   }
 
   if (display_changed || gpu_changed)
     manager->HandleGpuSwitch();
 }
 #endif  // OS_MACOSX
 
 // Block all domains' use of 3D APIs for this many milliseconds if
@@ skipping 116 matching lines @@
       *reason = "All GPU features are blacklisted.";
     }
     return false;
 #endif
   }
 
   return true;
 }
 
 void GpuDataManagerImplPrivate::RequestCompleteGpuInfoIfNeeded() {
-  if (complete_gpu_info_already_requested_ || gpu_info_.finalized)
+  if (complete_gpu_info_already_requested_ || IsCompleteGpuInfoAvailable())
     return;
   complete_gpu_info_already_requested_ = true;
 
   GpuProcessHost::SendOnIO(
 #if defined(OS_WIN)
       GpuProcessHost::GPU_PROCESS_KIND_UNSANDBOXED,
 #else
       GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
 #endif
       CAUSE_FOR_GPU_LAUNCH_GPUDATAMANAGER_REQUESTCOMPLETEGPUINFOIFNEEDED,
       new GpuMsg_CollectGraphicsInfo());
 }
 
+bool GpuDataManagerImplPrivate::IsEssentialGpuInfoAvailable() const {
+  if (gpu_info_.basic_info_state == gpu::kCollectInfoNone ||
+      gpu_info_.context_info_state == gpu::kCollectInfoNone)

[Evan Stade, 2014/09/03 21:47:58]

nit: curlies

[Zhenyao Mo, 2014/09/03 21:56:10]

Done.

+    return false;
+  return true;
+}
+
 bool GpuDataManagerImplPrivate::IsCompleteGpuInfoAvailable() const {

[Evan Stade, 2014/09/03 21:47:58]

 {
#if defined(OS_WIN)
  ...
#endif
  return IsEssentialGpuInfoAvailable();
}

[Zhenyao Mo, 2014/09/03 21:56:10]

Done.

-  return gpu_info_.finalized;
+  if (!IsEssentialGpuInfoAvailable())
+    return false;
+#if defined(OS_WIN)
+  if (gpu_info_.dx_diagnostics_info_state == gpu::kCollectInfoNone)
+    return false;
+#endif
+  return true;
 }
 
 void GpuDataManagerImplPrivate::RequestVideoMemoryUsageStatsUpdate() const {
   GpuProcessHost::SendOnIO(
       GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
       CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH,
       new GpuMsg_GetVideoMemoryUsageStats());
 }
 
 bool GpuDataManagerImplPrivate::ShouldUseSwiftShader() const {
@@ skipping 104 matching lines @@
 
     // 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 defined(ARCH_CPU_X86_FAMILY)
-  if (!gpu_info.gpu.vendor_id || !gpu_info.gpu.device_id)
-    gpu_info.finalized = true;
-#endif
+  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
 
   std::string gpu_blacklist_string;
   std::string gpu_driver_bug_list_string;
   if (!command_line->HasSwitch(switches::kIgnoreGpuBlacklist) &&
       !command_line->HasSwitch(switches::kUseGpuInTests)) {
     gpu_blacklist_string = gpu::kSoftwareRenderingListJson;
   }
   if (!command_line->HasSwitch(switches::kDisableGpuDriverBugWorkarounds)) {
     gpu_driver_bug_list_string = gpu::kGpuDriverBugListJson;
   }
@@ skipping 23 matching lines @@
   // We have to update GpuFeatureType before notify all the observers.
   NotifyGpuInfoUpdate();
 }
 
 void GpuDataManagerImplPrivate::UpdateGpuInfo(const gpu::GPUInfo& gpu_info) {
   // No further update of gpu_info if falling back to SwiftShader.
   if (use_swiftshader_)
     return;
 
   gpu::MergeGPUInfo(&gpu_info_, gpu_info);
-  complete_gpu_info_already_requested_ =
-      complete_gpu_info_already_requested_ || gpu_info_.finalized;
+  if (IsCompleteGpuInfoAvailable())
+    complete_gpu_info_already_requested_ = true;
 
   UpdateGpuInfoHelper();
 }
 
 void GpuDataManagerImplPrivate::UpdateVideoMemoryUsageStats(
     const GPUVideoMemoryUsageStats& video_memory_usage_stats) {
   GpuDataManagerImpl::UnlockedSession session(owner_);
   observer_list_->Notify(&GpuDataManagerObserver::OnVideoMemoryUsageStatsUpdate,
                          video_memory_usage_stats);
 }
@@ skipping 502 matching lines @@
                                                    int render_process_id,
                                                    int render_view_id,
                                                    ThreeDAPIType requester) {
   GpuDataManagerImpl::UnlockedSession session(owner_);
   observer_list_->Notify(&GpuDataManagerObserver::DidBlock3DAPIs,
                          url, render_process_id, render_view_id, requester);
 }
 
 void GpuDataManagerImplPrivate::OnGpuProcessInitFailure() {
   gpu_process_accessible_ = false;
-  gpu_info_.finalized = true;
+  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