Compute the correct info for hardware GPU for about:gpu

The way we compute feature status and problems identified depends
on a few global states for example, if gpu compositing is enabled
at the time when we do the computing.

So currently when we compute the info for hardware gpu, if we
already fallback to SwiftShader, then the global states may
have changed.

This is not what we want. We want to capture a state of info
where we were still using GPU acceleration.

So the fix here is that we also cache these global states for the
later computing.

BUG=1154047
TEST=manual
R=kbr@chromium.org

Change-Id: Ie9abedafe28a36f635bbe8bff183ba52495f4404
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2594315
Commit-Queue: Zhenyao Mo <zmo@chromium.org>
Reviewed-by: Kenneth Russell <kbr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#838987}

content/browser/gpu/compositor_util.cc

@@ -90,6 +90,7 @@ gpu::GpuFeatureStatus SafeGetFeatureStatus(
 const GpuFeatureData GetGpuFeatureData(
     const gpu::GpuFeatureInfo& gpu_feature_info,
     size_t index,
+    bool is_gpu_compositing_disabled,
     bool* eof) {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
@@ -110,7 +111,7 @@ const GpuFeatureData GetGpuFeatureData(
      // if GPU compositing is disabled.
      SafeGetFeatureStatus(gpu_feature_info,
                           gpu::GPU_FEATURE_TYPE_ACCELERATED_GL),
-     GpuDataManagerImpl::GetInstance()->IsGpuCompositingDisabled(),
+     is_gpu_compositing_disabled,
      DisableInfo::Problem(
          "Gpu compositing has been disabled, either via blocklist, about:flags "
          "or the command line. The browser will fall back to software "
@@ -206,19 +207,27 @@ std::unique_ptr<base::DictionaryValue> GetFeatureStatusImpl(
     GpuFeatureInfoType type) {
   GpuDataManagerImpl* manager = GpuDataManagerImpl::GetInstance();
   std::string gpu_access_blocked_reason;
-  bool gpu_access_blocked =
-      !manager->GpuAccessAllowed(&gpu_access_blocked_reason);
-  const gpu::GpuFeatureInfo gpu_feature_info =
-      type == GpuFeatureInfoType::kCurrent
-          ? manager->GetGpuFeatureInfo()
-          : manager->GetGpuFeatureInfoForHardwareGpu();
+  bool gpu_access_blocked;
+  gpu::GpuFeatureInfo gpu_feature_info;
+  bool is_gpu_compositing_disabled;
+  if (type == GpuFeatureInfoType::kCurrent) {
+    gpu_access_blocked = !manager->GpuAccessAllowed(&gpu_access_blocked_reason);
+    gpu_feature_info = manager->GetGpuFeatureInfo();
+    is_gpu_compositing_disabled = manager->IsGpuCompositingDisabled();
+  } else {
+    gpu_access_blocked =
+        !manager->GpuAccessAllowedForHardwareGpu(&gpu_access_blocked_reason);
+    gpu_feature_info = manager->GetGpuFeatureInfoForHardwareGpu();
+    is_gpu_compositing_disabled =
+        manager->IsGpuCompositingDisabledForHardwareGpu();
+  }
 
   auto feature_status_dict = std::make_unique<base::DictionaryValue>();
 
   bool eof = false;
   for (size_t i = 0; !eof; ++i) {
-    const GpuFeatureData gpu_feature_data =
-        GetGpuFeatureData(gpu_feature_info, i, &eof);
+    const GpuFeatureData gpu_feature_data = GetGpuFeatureData(
+        gpu_feature_info, i, is_gpu_compositing_disabled, &eof);
     std::string status;
     // Features undergoing a finch controlled roll out.
     if (gpu_feature_data.name == "skia_renderer" ||
@@ -239,7 +248,7 @@ std::unique_ptr<base::DictionaryValue> GetFeatureStatusImpl(
       status = "enabled";
       if ((gpu_feature_data.name == "webgl" ||
            gpu_feature_data.name == "webgl2") &&
-          manager->IsGpuCompositingDisabled())
+          is_gpu_compositing_disabled)
         status += "_readback";
       if (gpu_feature_data.name == "rasterization") {
         const base::CommandLine& command_line =
@@ -269,12 +278,20 @@ std::unique_ptr<base::DictionaryValue> GetFeatureStatusImpl(
 std::unique_ptr<base::ListValue> GetProblemsImpl(GpuFeatureInfoType type) {
   GpuDataManagerImpl* manager = GpuDataManagerImpl::GetInstance();
   std::string gpu_access_blocked_reason;
-  bool gpu_access_blocked =
-      !manager->GpuAccessAllowed(&gpu_access_blocked_reason);
-  const gpu::GpuFeatureInfo gpu_feature_info =
-      type == GpuFeatureInfoType::kCurrent
-          ? manager->GetGpuFeatureInfo()
-          : manager->GetGpuFeatureInfoForHardwareGpu();
+  bool gpu_access_blocked;
+  gpu::GpuFeatureInfo gpu_feature_info;
+  bool is_gpu_compositing_disabled;
+  if (type == GpuFeatureInfoType::kCurrent) {
+    gpu_access_blocked = !manager->GpuAccessAllowed(&gpu_access_blocked_reason);
+    gpu_feature_info = manager->GetGpuFeatureInfo();
+    is_gpu_compositing_disabled = manager->IsGpuCompositingDisabled();
+  } else {
+    gpu_access_blocked =
+        !manager->GpuAccessAllowedForHardwareGpu(&gpu_access_blocked_reason);
+    gpu_feature_info = manager->GetGpuFeatureInfoForHardwareGpu();
+    is_gpu_compositing_disabled =
+        manager->IsGpuCompositingDisabledForHardwareGpu();
+  }
 
   auto problem_list = std::make_unique<base::ListValue>();
   if (!gpu_feature_info.applied_gpu_blocklist_entries.empty()) {
@@ -303,8 +320,8 @@ std::unique_ptr<base::ListValue> GetProblemsImpl(GpuFeatureInfoType type) {
 
   bool eof = false;
   for (size_t i = 0; !eof; ++i) {
-    const GpuFeatureData gpu_feature_data =
-        GetGpuFeatureData(gpu_feature_info, i, &eof);
+    const GpuFeatureData gpu_feature_data = GetGpuFeatureData(
+        gpu_feature_info, i, is_gpu_compositing_disabled, &eof);
     if (gpu_feature_data.disabled &&
         gpu_feature_data.disabled_info.is_problem) {
       auto problem = std::make_unique<base::DictionaryValue>();

content/browser/gpu/gpu_data_manager_impl.cc

@@ -267,6 +267,16 @@ gpu::GpuFeatureInfo GpuDataManagerImpl::GetGpuFeatureInfoForHardwareGpu()
   return private_->GetGpuFeatureInfoForHardwareGpu();
 }
 
+bool GpuDataManagerImpl::GpuAccessAllowedForHardwareGpu(std::string* reason) {
+  base::AutoLock auto_lock(lock_);
+  return private_->GpuAccessAllowedForHardwareGpu(reason);
+}
+
+bool GpuDataManagerImpl::IsGpuCompositingDisabledForHardwareGpu() const {
+  base::AutoLock auto_lock(lock_);
+  return private_->IsGpuCompositingDisabledForHardwareGpu();
+}
+
 gfx::GpuExtraInfo GpuDataManagerImpl::GetGpuExtraInfo() const {
   base::AutoLock auto_lock(lock_);
   return private_->GetGpuExtraInfo();

content/browser/gpu/gpu_data_manager_impl.h

@@ -113,8 +113,13 @@ class CONTENT_EXPORT GpuDataManagerImpl : public GpuDataManager,
 
   gpu::GpuFeatureInfo GetGpuFeatureInfo() const;
 
+  // The following functions for cached GPUInfo and GpuFeatureInfo from the
+  // hardware GPU even if currently Chrome has fallen back to SwiftShader.
+  // Such info are displayed in about:gpu for diagostic purpose.
   gpu::GPUInfo GetGPUInfoForHardwareGpu() const;
   gpu::GpuFeatureInfo GetGpuFeatureInfoForHardwareGpu() const;
+  bool GpuAccessAllowedForHardwareGpu(std::string* reason);
+  bool IsGpuCompositingDisabledForHardwareGpu() const;
 
   gfx::GpuExtraInfo GetGpuExtraInfo() const;
 

content/browser/gpu/gpu_data_manager_impl_private.cc

@@ -616,6 +616,13 @@ bool GpuDataManagerImplPrivate::GpuAccessAllowed(std::string* reason) const {
   }
 }
 
+bool GpuDataManagerImplPrivate::GpuAccessAllowedForHardwareGpu(
+    std::string* reason) const {
+  if (reason)
+    *reason = gpu_access_blocked_reason_for_hardware_gpu_;
+  return gpu_access_allowed_for_hardware_gpu_;
+}
+
 bool GpuDataManagerImplPrivate::GpuProcessStartAllowed() const {
   return gpu_mode_ != gpu::GpuMode::DISABLED;
 }
@@ -1072,6 +1079,9 @@ void GpuDataManagerImplPrivate::UpdateGpuFeatureInfo(
     } else {
       gpu_feature_info_for_hardware_gpu_ = gpu_feature_info_;
     }
+    is_gpu_compositing_disabled_for_hardware_gpu_ = IsGpuCompositingDisabled();
+    gpu_access_allowed_for_hardware_gpu_ =
+        GpuAccessAllowed(&gpu_access_blocked_reason_for_hardware_gpu_);
   }
   if (update_histograms_) {
     UpdateFeatureStats(gpu_feature_info_);
@@ -1103,6 +1113,10 @@ bool GpuDataManagerImplPrivate::IsGpuCompositingDisabled() const {
   return disable_gpu_compositing_ || !HardwareAccelerationEnabled();
 }
 
+bool GpuDataManagerImplPrivate::IsGpuCompositingDisabledForHardwareGpu() const {
+  return is_gpu_compositing_disabled_for_hardware_gpu_;
+}
+
 void GpuDataManagerImplPrivate::SetGpuCompositingDisabled() {
   if (!IsGpuCompositingDisabled()) {
     disable_gpu_compositing_ = true;

content/browser/gpu/gpu_data_manager_impl_private.h

@@ -43,6 +43,7 @@ class CONTENT_EXPORT GpuDataManagerImplPrivate {
   gpu::GPUInfo GetGPUInfo() const;
   gpu::GPUInfo GetGPUInfoForHardwareGpu() const;
   bool GpuAccessAllowed(std::string* reason) const;
+  bool GpuAccessAllowedForHardwareGpu(std::string* reason) const;
   bool GpuProcessStartAllowed() const;
   void RequestDxdiagDx12VulkanGpuInfoIfNeeded(GpuInfoRequest request,
                                               bool delayed);
@@ -87,6 +88,7 @@ class CONTENT_EXPORT GpuDataManagerImplPrivate {
   gfx::GpuExtraInfo GetGpuExtraInfo() const;
 
   bool IsGpuCompositingDisabled() const;
+  bool IsGpuCompositingDisabledForHardwareGpu() const;
 
   void SetGpuCompositingDisabled();
 
@@ -223,6 +225,9 @@ class CONTENT_EXPORT GpuDataManagerImplPrivate {
   // pure software (in the viz case).
   gpu::GpuFeatureInfo gpu_feature_info_for_hardware_gpu_;
   gpu::GPUInfo gpu_info_for_hardware_gpu_;
+  bool is_gpu_compositing_disabled_for_hardware_gpu_ = false;
+  bool gpu_access_allowed_for_hardware_gpu_ = true;
+  std::string gpu_access_blocked_reason_for_hardware_gpu_;
 
   gfx::GpuExtraInfo gpu_extra_info_;
 

content/test/data/gpu/simple.html

+<html>
+<head>
+<script type="text/javascript">
+function onLoad() {
+  window.domAutomationController.reset = function() {
+    window.domAutomationController._loaded = false;
+    window.domAutomationController._succeeded = false;
+    window.domAutomationController._finished = false;
+    window.requestAnimationFrame(succeed);
+  };
+  window.domAutomationController.send("LOADED");
+}
+
+function succeed() {
+  window.domAutomationController.send("SUCCESS");
+}
+</script>
+</head>
+<body onload="onLoad()">
+Simple page.
+</body>
+</html>

content/test/gpu/gpu_tests/context_lost_integration_test.py

@@ -51,6 +51,24 @@ harness_script = r"""
   console.log("Harness injected.");
 """
 
+feature_query_script = """
+  function GetFeatureStatus(feature_name, for_hardware_gpu) {
+    let query_result;
+    if (for_hardware_gpu) {
+      query_result = document.querySelector(
+          '.feature-status-for-hardware-gpu-list');
+    } else {
+      query_result = document.querySelector('.feature-status-list');
+    }
+    for (let i=0; i < query_result.childElementCount; i++) {
+      let feature_status = query_result.children[i].textContent.split(': ');
+      if (feature_status.length == 2 && feature_status[0] == feature_name)
+        return feature_status[1];
+    }
+    return "";
+  }
+"""
+
 
 class ContextLostIntegrationTest(gpu_integration_test.GpuIntegrationTest):
 
@@ -78,7 +96,6 @@ class ContextLostIntegrationTest(gpu_integration_test.GpuIntegrationTest):
     default_args = super(ContextLostIntegrationTest,
                          cls).GenerateBrowserArgs(additional_args)
     default_args.extend([
-        cba.DISABLE_GPU_PROCESS_CRASH_LIMIT,
         # Required to call crashGpuProcess.
         cba.ENABLE_GPU_BENCHMARKING,
         # Disable:
@@ -122,7 +139,8 @@ class ContextLostIntegrationTest(gpu_integration_test.GpuIntegrationTest):
              ('ContextLost_MacWebGLMultisamplingHighPowerSwitchLosesContext',
               'webgl2-multisampling-high-power-switch-loses-context.html'),
              ('ContextLost_MacWebGLPreserveDBHighPowerSwitchLosesContext',
-              'webgl2-preserve-db-high-power-switch-loses-context.html'))
+              'webgl2-preserve-db-high-power-switch-loses-context.html'),
+             ('GpuCrash_InfoForHardwareGpu', 'simple.html'))
     for t in tests:
       yield (t[0], t[1], ('_' + t[0]))
 
@@ -227,6 +245,16 @@ class ContextLostIntegrationTest(gpu_integration_test.GpuIntegrationTest):
     tab.action_runner.WaitForJavaScriptCondition(
         'window.domAutomationController._loaded')
 
+  def _GetWebGLFeatureStatus(self, for_hardware_gpu):
+    tab = self.tab.browser.tabs.New()
+    tab.Navigate('chrome:gpu',
+                 script_to_evaluate_on_commit=feature_query_script)
+    tab.WaitForJavaScriptCondition('window.gpuPagePopulated', timeout=10)
+    status = (tab.EvaluateJavaScript('GetFeatureStatus("WebGL", %s)' %
+                                     ('true' if for_hardware_gpu else 'false')))
+    tab.Close()
+    return status
+
   def _WaitForTabAndCheckCompletion(self):
     tab = self.tab
     completed = _WaitForPageToFinish(tab)
@@ -446,6 +474,33 @@ class ContextLostIntegrationTest(gpu_integration_test.GpuIntegrationTest):
     self._WaitForTabAndCheckCompletion()
     self._CheckCrashCount(tab, 0)
 
+  def _GpuCrash_InfoForHardwareGpu(self, test_path):
+    # Ensure that info displayed in chrome:gpu for hardware gpu is correct,
+    # after gpu process crashes three times and falls back to SwiftShader.
+    self.RestartBrowserIfNecessaryWithArgs(
+        [cba.DISABLE_DOMAIN_BLOCKING_FOR_3D_APIS])
+    self._NavigateAndWaitForLoad(test_path)
+    # Check WebGL status at browser startup.
+    webgl_status = self._GetWebGLFeatureStatus(False)
+    if webgl_status != 'Hardware accelerated':
+      self.fail('WebGL should be hardware accelerated initially, but got %s' %
+                webgl_status)
+    webgl_status_for_hardware_gpu = self._GetWebGLFeatureStatus(True)
+    if webgl_status_for_hardware_gpu != '':
+      self.fail('Feature status for hardware gpu should not be displayed '
+                'initially')
+    # Check WebGL status after three GPU crashes - fallback to SwiftShader.
+    self._KillGPUProcess(3, True)
+    webgl_status = self._GetWebGLFeatureStatus(False)
+    if webgl_status != 'Software only, hardware acceleration unavailable':
+      self.fail('WebGL should be software only with SwiftShader, but got %s' %
+                webgl_status)
+    webgl_status_for_hardware_gpu = self._GetWebGLFeatureStatus(True)
+    if webgl_status_for_hardware_gpu != 'Hardware accelerated':
+      self.fail('WebGL status for hardware gpu should be "accelerated", '
+                'but got %s' % webgl_status_for_hardware_gpu)
+    self._RestartBrowser('must restart after tests that kill the GPU process')
+
   @classmethod
   def GetPlatformTags(cls, browser):
     tags = super(ContextLostIntegrationTest, cls).GetPlatformTags(browser)

content/test/gpu/gpu_tests/test_expectations/context_lost_expectations.txt

@@ -128,3 +128,8 @@ crbug.com/1105308 [ fuchsia ] GpuNormalTermination_NewWebGLNotBlocked [ Skip ]
 
 # Flakily not getting WebGL blocked on context loss
 crbug.com/1143774 [ chromeos chromeos-board-kevin ] ContextLost_WebGLUnblockedAfterUserInitiatedReload [ RetryOnFailure ]
+
+# GPU process fallback isn't supported on certain platforms.
+crbug.com/1154047 [ chromeos ] GpuCrash_InfoForHardwareGpu [ Skip ]
+crbug.com/1154047 [ android ] GpuCrash_InfoForHardwareGpu [ Skip ]
+crbug.com/1154047 [ fuchsia ] GpuCrash_InfoForHardwareGpu [ Skip ]

gpu/ipc/service/gpu_init.cc

@@ -350,6 +350,7 @@ bool GpuInit::InitializeAndStartSandbox(base::CommandLine* command_line,
             << "on Linux";
     return false;
 #else
+    SaveHardwareGpuInfoAndGpuFeatureInfo();
     gl::init::ShutdownGL(true);
     gl_initialized = false;
 #endif  // defined(OS_LINUX) || defined(OS_CHROMEOS)
@@ -437,6 +438,7 @@ bool GpuInit::InitializeAndStartSandbox(base::CommandLine* command_line,
                 << "on Linux";
         return false;
 #else
+        SaveHardwareGpuInfoAndGpuFeatureInfo();
         gl::init::ShutdownGL(true);
         watchdog_thread_ = nullptr;
         watchdog_init.SetGpuWatchdogPtr(nullptr);
@@ -693,6 +695,7 @@ void GpuInit::InitializeInProcess(base::CommandLine* command_line,
         command_line, gpu_feature_info_,
         gpu_preferences_.disable_software_rasterizer, false);
     if (gl_use_swiftshader_) {
+      SaveHardwareGpuInfoAndGpuFeatureInfo();
       gl::init::ShutdownGL(true);
       if (!gl::init::InitializeGLNoExtensionsOneOff(/*init_bindings*/ true)) {
         VLOG(1) << "gl::init::InitializeGLNoExtensionsOneOff failed "
@@ -731,6 +734,7 @@ void GpuInit::InitializeInProcess(base::CommandLine* command_line,
         command_line, gpu_feature_info_,
         gpu_preferences_.disable_software_rasterizer, false);
     if (gl_use_swiftshader_) {
+      SaveHardwareGpuInfoAndGpuFeatureInfo();
       gl::init::ShutdownGL(true);
       if (!gl::init::InitializeGLNoExtensionsOneOff(/*init_bindings*/ true)) {
         VLOG(1) << "gl::init::InitializeGLNoExtensionsOneOff failed "
@@ -768,10 +772,13 @@ void GpuInit::InitializeInProcess(base::CommandLine* command_line,
 }
 #endif  // OS_ANDROID
 
-void GpuInit::AdjustInfoToSwiftShader() {
+void GpuInit::SaveHardwareGpuInfoAndGpuFeatureInfo() {
   gpu_info_for_hardware_gpu_ = gpu_info_;
-  gpu_info_.passthrough_cmd_decoder = false;
   gpu_feature_info_for_hardware_gpu_ = gpu_feature_info_;
+}
+
+void GpuInit::AdjustInfoToSwiftShader() {
+  gpu_info_.passthrough_cmd_decoder = false;
   gpu_feature_info_ = ComputeGpuFeatureInfoForSwiftShader();
   CollectContextGraphicsInfo(&gpu_info_);
 

gpu/ipc/service/gpu_init.h

@@ -108,6 +108,7 @@ class GPU_IPC_SERVICE_EXPORT GpuInit {
   std::unique_ptr<VulkanImplementation> vulkan_implementation_;
 #endif
 
+  void SaveHardwareGpuInfoAndGpuFeatureInfo();
   void AdjustInfoToSwiftShader();
 
   DISALLOW_COPY_AND_ASSIGN(GpuInit);