Revert "One step further into moving GPU feature decisions to GPU process"

This reverts commit 0728a856.

Revert "Attempt to fix SystemInfoHandler regression."

This reverts commit ed8968af.

Revert "Call UpdateGPUInfo and UpdateGpuFeatureInfo always on GPU process launch."

This reverts commit 77604d4d.

Bug=778680,744658
TEST=bots,perf bots (win)
TBR=piman@chromium.org,kbr@chromium.org,nednguyen@chromium.org

Cq-Include-Trybots: master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Change-Id: I7ebcb6335dff91fc396225800ebe72cb17d07ae7
Reviewed-on: https://chromium-review.googlesource.com/743741
Commit-Queue: Zhenyao Mo <zmo@chromium.org>
Reviewed-by: Zhenyao Mo <zmo@chromium.org>
Cr-Commit-Position: refs/heads/master@{#512485}

chrome/browser/extensions/api/webstore_private/webstore_private_apitest.cc

@@ -34,6 +34,7 @@
 #include "extensions/browser/extension_dialog_auto_confirm.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/install/extension_install_ui.h"
+#include "gpu/config/gpu_feature_type.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "ui/gl/gl_switches.h"
@@ -386,14 +387,6 @@ IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTestChild, InstallBlocked) {
 class ExtensionWebstoreGetWebGLStatusTest : public InProcessBrowserTest {
  protected:
   void RunTest(bool webgl_allowed) {
-#if defined(OS_CHROMEOS) && BUILDFLAG(ENABLE_PACKAGE_MASH_SERVICES)
-    // TODO(zmo): crbug.com/777681
-    // In Mus GpuFeatureInfo computed in GPU process isn't wired back to
-    // browser process, therefore GpuFeatureChecker times out.
-    base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-    if (command_line->HasSwitch(switches::kMus))
-      return;
-#endif
     // If Gpu access is disallowed then WebGL will not be available.
     if (!content::GpuDataManager::GetInstance()->GpuAccessAllowed(NULL))
       webgl_allowed = false;
@@ -423,9 +416,8 @@ IN_PROC_BROWSER_TEST_F(ExtensionWebstoreGetWebGLStatusTest, Allowed) {
 // Tests getWebGLStatus function when WebGL is blacklisted.
 IN_PROC_BROWSER_TEST_F(ExtensionWebstoreGetWebGLStatusTest, Blocked) {
   content::GpuDataManager::GetInstance()->BlacklistWebGLForTesting();
-  EXPECT_EQ(gpu::kGpuFeatureStatusBlacklisted,
-            content::GpuDataManager::GetInstance()->GetFeatureStatus(
-                gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL));
+  EXPECT_TRUE(content::GpuDataManager::GetInstance()->IsFeatureBlacklisted(
+      gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL));
 
   bool webgl_allowed = false;
   RunTest(webgl_allowed);

content/browser/devtools/protocol/system_info_handler.cc

@@ -13,8 +13,7 @@
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/gpu/compositor_util.h"
-#include "content/browser/gpu/gpu_data_manager_impl.h"
-#include "content/browser/gpu/gpu_process_host.h"
+#include "content/public/browser/gpu_data_manager.h"
 #include "gpu/config/gpu_feature_type.h"
 #include "gpu/config/gpu_info.h"
 #include "gpu/config/gpu_switches.h"
@@ -98,7 +97,7 @@ std::unique_ptr<GPUDevice> GPUDeviceToProtocol(
 }
 
 void SendGetInfoResponse(std::unique_ptr<GetInfoCallback> callback) {
-  gpu::GPUInfo gpu_info = GpuDataManagerImpl::GetInstance()->GetGPUInfo();
+  gpu::GPUInfo gpu_info = GpuDataManager::GetInstance()->GetGPUInfo();
   std::unique_ptr<protocol::Array<GPUDevice>> devices =
       protocol::Array<GPUDevice>::create();
   devices->addItem(GPUDeviceToProtocol(gpu_info.gpu));
@@ -154,17 +153,13 @@ class SystemInfoHandlerGpuObserver : public content::GpuDataManagerObserver {
                        weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(kGPUInfoWatchdogTimeoutMs));
 
-    GpuDataManagerImpl::GetInstance()->AddObserver(this);
-    OnGpuInfoUpdate();
-    // Make sure GPU process launches if it hasn't yet.
-    GpuProcessHost::CallOnIO(
-        GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED, true /* force_create */,
-        base::Bind([](GpuProcessHost* host) { (void)host; }));
+    GpuDataManager::GetInstance()->AddObserver(this);
+    // There's no other method available to request just essential GPU info.
+    GpuDataManager::GetInstance()->RequestCompleteGpuInfoIfNeeded();
   }
 
   void OnGpuInfoUpdate() override {
-    if (GpuDataManagerImpl::GetInstance()->IsGpuFeatureInfoAvailable())
-      UnregisterAndSendResponse();
+    UnregisterAndSendResponse();
   }
 
   void OnGpuProcessCrashed(base::TerminationStatus exit_code) override {
@@ -177,7 +172,7 @@ class SystemInfoHandlerGpuObserver : public content::GpuDataManagerObserver {
   }
 
   void UnregisterAndSendResponse() {
-    GpuDataManagerImpl::GetInstance()->RemoveObserver(this);
+    GpuDataManager::GetInstance()->RemoveObserver(this);
     SendGetInfoResponse(std::move(callback_));
     delete this;
   }
@@ -201,8 +196,8 @@ void SystemInfoHandler::Wire(UberDispatcher* dispatcher) {
 void SystemInfoHandler::GetInfo(
     std::unique_ptr<GetInfoCallback> callback) {
   std::string reason;
-  if (!GpuDataManagerImpl::GetInstance()->GpuAccessAllowed(&reason) ||
-      GpuDataManagerImpl::GetInstance()->IsGpuFeatureInfoAvailable() ||
+  if (!GpuDataManager::GetInstance()->GpuAccessAllowed(&reason) ||
+      GpuDataManager::GetInstance()->IsEssentialGpuInfoAvailable() ||
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kGpuTestingNoCompleteInfoCollection)) {
     // The GpuDataManager already has all of the information needed to make

content/browser/gpu/compositor_util.h

@@ -26,10 +26,16 @@ CONTENT_EXPORT bool IsPartialRasterEnabled();
 // Returns true if all compositor resources should use GPU memory buffers.
 CONTENT_EXPORT bool IsGpuMemoryBufferCompositorResourcesEnabled();
 
+// Returns true if gpu rasterization is on (via flags) for the renderer.
+CONTENT_EXPORT bool IsGpuRasterizationEnabled();
+
 // Returns the number of multisample antialiasing samples (via flags) for
 // GPU rasterization.
 CONTENT_EXPORT int GpuRasterizationMSAASampleCount();
 
+// Returns true if force-gpu-rasterization is on (via flags) for the renderer.
+CONTENT_EXPORT bool IsForceGpuRasterizationEnabled();
+
 // Returns the number of raster threads to use for compositing.
 CONTENT_EXPORT int NumberOfRendererRasterThreads();
 

content/browser/gpu/gpu_data_manager_impl.cc

@@ -20,11 +20,43 @@ GpuDataManagerImpl* GpuDataManagerImpl::GetInstance() {
 }
 
 void GpuDataManagerImpl::BlacklistWebGLForTesting() {
-  base::AutoLock auto_lock(lock_);
-  gpu::GpuFeatureInfo gpu_feature_info;
-  gpu_feature_info.status_values[gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL] =
-      gpu::kGpuFeatureStatusBlacklisted;
-  private_->UpdateGpuFeatureInfo(gpu_feature_info);
+  // Manually generate the following data instead of going through
+  // gpu/config/process_json.py because this is just one simple instance.
+  static const int kFeatureListForEntry0[1] = {
+      gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL};
+  static const gpu::GpuControlList::Entry kEntry = {
+      1,  // id
+      "ExtensionWebstoreGetWebGLStatusTest.Blocked",
+      arraysize(kFeatureListForEntry0),  // features size
+      kFeatureListForEntry0,             // features
+      0,                                 // DisabledExtensions size
+      nullptr,                           // DisabledExtensions
+      0,                                 // CrBugs size
+      nullptr,                           // CrBugs
+      {
+          gpu::GpuControlList::kOsAny,  // os_type
+          {gpu::GpuControlList::kUnknown,
+           gpu::GpuControlList::kVersionStyleNumerical, nullptr,
+           nullptr},                                   // os_version
+          0x00,                                        // vendor_id
+          0,                                           // DeviceIDs size
+          nullptr,                                     // DeviceIDs
+          gpu::GpuControlList::kMultiGpuCategoryNone,  // multi_gpu_category
+          gpu::GpuControlList::kMultiGpuStyleNone,     // multi_gpu_style
+          nullptr,                                     // driver info
+          nullptr,                                     // GL strings
+          nullptr,                                     // machine model info
+          nullptr,                                     // more conditions
+      },
+      0,        // exceptions count
+      nullptr,  // exceptions
+  };
+  static const gpu::GpuControlListData kData(1, &kEntry);
+
+  gpu::GPUInfo gpu_info;
+
+  base::AutoLock auto_lock(lock_);
+  private_->InitializeForTesting(kData, gpu_info);
 }
 
 void GpuDataManagerImpl::InitializeForTesting(
@@ -39,6 +71,21 @@ bool GpuDataManagerImpl::IsFeatureBlacklisted(int feature) const {
   return private_->IsFeatureBlacklisted(feature);
 }
 
+bool GpuDataManagerImpl::IsFeatureEnabled(int feature) const {
+  base::AutoLock auto_lock(lock_);
+  return private_->IsFeatureEnabled(feature);
+}
+
+bool GpuDataManagerImpl::IsWebGLEnabled() const {
+  base::AutoLock auto_lock(lock_);
+  return private_->IsWebGLEnabled();
+}
+
+bool GpuDataManagerImpl::IsWebGL2Enabled() const {
+  base::AutoLock auto_lock(lock_);
+  return private_->IsWebGL2Enabled();
+}
+
 gpu::GPUInfo GpuDataManagerImpl::GetGPUInfo() const {
   base::AutoLock auto_lock(lock_);
   return private_->GetGPUInfo();
@@ -59,6 +106,11 @@ bool GpuDataManagerImpl::IsEssentialGpuInfoAvailable() const {
   return private_->IsEssentialGpuInfoAvailable();
 }
 
+bool GpuDataManagerImpl::IsCompleteGpuInfoAvailable() const {
+  base::AutoLock auto_lock(lock_);
+  return private_->IsCompleteGpuInfoAvailable();
+}
+
 void GpuDataManagerImpl::RequestVideoMemoryUsageStatsUpdate(
     const base::Callback<void(const gpu::VideoMemoryUsageStats& stats)>&
         callback) const {
@@ -150,17 +202,6 @@ gpu::GpuFeatureInfo GpuDataManagerImpl::GetGpuFeatureInfo() const {
   return private_->GetGpuFeatureInfo();
 }
 
-gpu::GpuFeatureStatus GpuDataManagerImpl::GetFeatureStatus(
-    gpu::GpuFeatureType feature) const {
-  base::AutoLock auto_lock(lock_);
-  return private_->GetFeatureStatus(feature);
-}
-
-bool GpuDataManagerImpl::IsGpuFeatureInfoAvailable() const {
-  base::AutoLock auto_lock(lock_);
-  return private_->IsGpuFeatureInfoAvailable();
-}
-
 void GpuDataManagerImpl::AppendRendererCommandLine(
     base::CommandLine* command_line) const {
   base::AutoLock auto_lock(lock_);

content/browser/gpu/gpu_data_manager_impl.h

@@ -22,6 +22,7 @@
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/common/three_d_api_types.h"
 #include "gpu/config/gpu_control_list.h"
+#include "gpu/config/gpu_feature_info.h"
 #include "gpu/config/gpu_info.h"
 
 class GURL;
@@ -66,12 +67,14 @@ class CONTENT_EXPORT GpuDataManagerImpl : public GpuDataManager {
   // GpuDataManager implementation.
   void BlacklistWebGLForTesting() override;
   bool IsFeatureBlacklisted(int feature) const override;
-  gpu::GpuFeatureStatus GetFeatureStatus(
-      gpu::GpuFeatureType feature) const override;
+  bool IsFeatureEnabled(int feature) const override;
+  bool IsWebGLEnabled() const override;
+  bool IsWebGL2Enabled() const override;
   gpu::GPUInfo GetGPUInfo() const override;
   bool GpuAccessAllowed(std::string* reason) const override;
   void RequestCompleteGpuInfoIfNeeded() override;
   bool IsEssentialGpuInfoAvailable() const override;
+  bool IsCompleteGpuInfoAvailable() const override;
   void RequestVideoMemoryUsageStatsUpdate(
       const base::Callback<void(const gpu::VideoMemoryUsageStats& stats)>&
           callback) const override;
@@ -113,7 +116,6 @@ class CONTENT_EXPORT GpuDataManagerImpl : public GpuDataManager {
   void UpdateGpuFeatureInfo(const gpu::GpuFeatureInfo& gpu_feature_info);
 
   gpu::GpuFeatureInfo GetGpuFeatureInfo() const;
-  bool IsGpuFeatureInfoAvailable() const;
 
   // Insert disable-feature switches corresponding to preliminary gpu feature
   // flags into the renderer process command line.

content/browser/gpu/gpu_data_manager_impl_private.cc

@@ -349,6 +349,23 @@ bool GpuDataManagerImplPrivate::IsFeatureBlacklisted(int feature) const {
   return use_swiftshader_ || (blacklisted_features_.count(feature) == 1);
 }
 
+bool GpuDataManagerImplPrivate::IsFeatureEnabled(int feature) const {
+  DCHECK_EQ(feature, gpu::GPU_FEATURE_TYPE_GPU_RASTERIZATION);
+  return gpu_feature_info_
+             .status_values[gpu::GPU_FEATURE_TYPE_GPU_RASTERIZATION] ==
+         gpu::kGpuFeatureStatusEnabled;
+}
+
+bool GpuDataManagerImplPrivate::IsWebGLEnabled() const {
+  return use_swiftshader_ ||
+         !blacklisted_features_.count(gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL);
+}
+
+bool GpuDataManagerImplPrivate::IsWebGL2Enabled() const {
+  return /*use_swiftshader_ ||*/ // Uncomment to enable WebGL 2 with SwiftShader
+         !blacklisted_features_.count(gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL2);
+}
+
 size_t GpuDataManagerImplPrivate::GetBlacklistedFeatureCount() const {
   // SwiftShader blacklists all features
   return use_swiftshader_ ? gpu::NUMBER_OF_GPU_FEATURE_TYPES
@@ -684,21 +701,17 @@ void GpuDataManagerImplPrivate::UpdateGpuInfo(const gpu::GPUInfo& gpu_info) {
 
 void GpuDataManagerImplPrivate::UpdateGpuFeatureInfo(
     const gpu::GpuFeatureInfo& gpu_feature_info) {
-  gpu_feature_info_ = gpu_feature_info;
-  gpu_feature_info_available_ = true;
-  UpdateDriverBugListStats(gpu_feature_info);
+  if (!use_swiftshader_) {
+    gpu_feature_info_ = gpu_feature_info;
+    UpdateDriverBugListStats(gpu_feature_info);
+    NotifyGpuInfoUpdate();
+  }
 }
 
 gpu::GpuFeatureInfo GpuDataManagerImplPrivate::GetGpuFeatureInfo() const {
   return gpu_feature_info_;
 }
 
-gpu::GpuFeatureStatus GpuDataManagerImplPrivate::GetFeatureStatus(
-    gpu::GpuFeatureType feature) const {
-  DCHECK(feature >= 0 && feature < gpu::NUMBER_OF_GPU_FEATURE_TYPES);
-  return gpu_feature_info_.status_values[feature];
-}
-
 void GpuDataManagerImplPrivate::AppendRendererCommandLine(
     base::CommandLine* command_line) const {
   DCHECK(command_line);

content/browser/gpu/gpu_data_manager_impl_private.h

@@ -43,12 +43,14 @@ class CONTENT_EXPORT GpuDataManagerImplPrivate {
   void InitializeForTesting(const gpu::GpuControlListData& gpu_blacklist_data,
                             const gpu::GPUInfo& gpu_info);
   bool IsFeatureBlacklisted(int feature) const;
+  bool IsFeatureEnabled(int feature) const;
+  bool IsWebGLEnabled() const;
+  bool IsWebGL2Enabled() const;
   gpu::GPUInfo GetGPUInfo() const;
   bool GpuAccessAllowed(std::string* reason) const;
   void RequestCompleteGpuInfoIfNeeded();
   bool IsEssentialGpuInfoAvailable() const;
   bool IsCompleteGpuInfoAvailable() const;
-  bool IsGpuFeatureInfoAvailable() const { return gpu_feature_info_available_; }
   void RequestVideoMemoryUsageStatsUpdate(
       const base::Callback<void(const gpu::VideoMemoryUsageStats& stats)>&
           callback) const;
@@ -70,7 +72,6 @@ class CONTENT_EXPORT GpuDataManagerImplPrivate {
   void UpdateGpuInfo(const gpu::GPUInfo& gpu_info);
   void UpdateGpuFeatureInfo(const gpu::GpuFeatureInfo& gpu_feature_info);
   gpu::GpuFeatureInfo GetGpuFeatureInfo() const;
-  gpu::GpuFeatureStatus GetFeatureStatus(gpu::GpuFeatureType feature) const;
 
   void AppendRendererCommandLine(base::CommandLine* command_line) const;
 
@@ -227,7 +228,6 @@ class CONTENT_EXPORT GpuDataManagerImplPrivate {
 
   // Eventually |blacklisted_features_| should be folded in to this.
   gpu::GpuFeatureInfo gpu_feature_info_;
-  bool gpu_feature_info_available_ = false;
 
   gpu::GPUInfo gpu_info_;
 

content/browser/gpu/gpu_data_manager_testing_arrays_and_structs_autogen.h

@@ -94,7 +94,7 @@ const GpuControlList::DriverInfo kDriverInfoForEntry8 = {
      nullptr},  // driver_date
 };
 
-const int kFeatureListForEntry9[10] = {
+const int kFeatureListForEntry9[11] = {
     GPU_FEATURE_TYPE_FLASH_STAGE3D,
     GPU_FEATURE_TYPE_GPU_COMPOSITING,
     GPU_FEATURE_TYPE_PANEL_FITTING,
@@ -105,6 +105,7 @@ const int kFeatureListForEntry9[10] = {
     GPU_FEATURE_TYPE_ACCELERATED_WEBGL2,
     GPU_FEATURE_TYPE_ACCELERATED_WEBGL,
     GPU_FEATURE_TYPE_FLASH_STAGE3D_BASELINE,
+    GPU_FEATURE_TYPE_ACCELERATED_VIDEO_ENCODE,
 };
 
 const int kFeatureListForEntry10[1] = {

content/browser/gpu/gpu_feature_checker_impl.cc

@@ -6,8 +6,8 @@
 
 #include "base/logging.h"
 #include "build/build_config.h"
-#include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/gpu_data_manager.h"
 
 namespace content {
 
@@ -15,13 +15,9 @@ namespace {
 
 // A false return value is always valid, but a true one is only valid if full
 // GPU info has been collected in a GPU process.
-bool IsFeatureAllowed(GpuDataManagerImpl* manager,
-                      gpu::GpuFeatureType feature) {
-  // This is mostly for WebStore checking WebGL status, therefore, don't return
-  // yes if WebGL is rendering on software, because user experience on the app
-  // won't be good in most cases.
-  return (manager->GpuAccessAllowed(nullptr) &&
-          manager->GetFeatureStatus(feature) == gpu::kGpuFeatureStatusEnabled);
+bool IsFeatureAllowed(GpuDataManager* manager, gpu::GpuFeatureType feature) {
+  return (manager->GpuAccessAllowed(NULL) &&
+          !manager->IsFeatureBlacklisted(feature));
 }
 
 }  // namespace
@@ -42,27 +38,41 @@ GpuFeatureCheckerImpl::~GpuFeatureCheckerImpl() {}
 void GpuFeatureCheckerImpl::CheckGpuFeatureAvailability() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GpuDataManagerImpl* manager = GpuDataManagerImpl::GetInstance();
-  if (!manager->IsGpuFeatureInfoAvailable()) {
+  bool finalized = true;
+#if defined(OS_LINUX)
+  // On Windows and Mac, so far we can always make the final WebGL blacklisting
+  // decision based on partial GPU info; on Linux, we need to launch the GPU
+  // process to collect full GPU info and make the final decision.
+  finalized = false;
+#endif
+
+  GpuDataManager* manager = GpuDataManager::GetInstance();
+  if (manager->IsEssentialGpuInfoAvailable())
+    finalized = true;
+
+  bool feature_allowed = IsFeatureAllowed(manager, feature_);
+  if (!feature_allowed)
+    finalized = true;
+
+  if (finalized) {
+    callback_.Run(feature_allowed);
+  } else {
+    // Matched with a Release in OnGpuInfoUpdate.
     AddRef();
+
     manager->AddObserver(this);
-    return;
+    manager->RequestCompleteGpuInfoIfNeeded();
   }
-
-  bool feature_allowed = IsFeatureAllowed(manager, feature_);
-  callback_.Run(feature_allowed);
 }
 
 void GpuFeatureCheckerImpl::OnGpuInfoUpdate() {
-  GpuDataManagerImpl* manager = GpuDataManagerImpl::GetInstance();
-  if (manager->IsGpuFeatureInfoAvailable()) {
-    manager->RemoveObserver(this);
-    bool feature_allowed = IsFeatureAllowed(manager, feature_);
-    callback_.Run(feature_allowed);
+  GpuDataManager* manager = GpuDataManager::GetInstance();
+  manager->RemoveObserver(this);
+  bool feature_allowed = IsFeatureAllowed(manager, feature_);
+  callback_.Run(feature_allowed);
 
-    // Matches the AddRef in CheckGpuFeatureAvailability().
-    Release();
-  }
+  // Matches the AddRef in CheckGpuFeatureAvailability().
+  Release();
 }
 
 }  // namespace content

content/browser/gpu/gpu_process_host.cc

@@ -866,10 +866,10 @@ void GpuProcessHost::DidInitialize(
   }
 
   GpuDataManagerImpl* gpu_data_manager = GpuDataManagerImpl::GetInstance();
-  // UpdateGpuFeatureInfo() needs to be called before UpdateGpuInfo() because
-  // the latter will trigger registered callbacks waiting for the update.
-  gpu_data_manager->UpdateGpuFeatureInfo(gpu_feature_info);
-  gpu_data_manager->UpdateGpuInfo(gpu_info);
+  if (!gpu_data_manager->ShouldUseSwiftShader()) {
+    gpu_data_manager->UpdateGpuInfo(gpu_info);
+    gpu_data_manager->UpdateGpuFeatureInfo(gpu_feature_info);
+  }
   RunRequestGPUInfoCallbacks(gpu_data_manager->GetGPUInfo());
 }
 

content/browser/resources/gpu/info_view.js

@@ -93,6 +93,7 @@ cr.define('gpu', function() {
         'flash_stage3d_baseline': 'Flash Stage3D Baseline profile',
         'texture_sharing': 'Texture Sharing',
         'video_decode': 'Video Decode',
+        'video_encode': 'Video Encode',
         'panel_fitting': 'Panel Fitting',
         'rasterization': 'Rasterization',
         'multiple_raster_threads': 'Multiple Raster Threads',

content/public/browser/gpu_data_manager.h

@@ -11,7 +11,6 @@
 #include "base/callback_forward.h"
 #include "base/process/process.h"
 #include "content/common/content_export.h"
-#include "gpu/config/gpu_feature_info.h"
 
 class GURL;
 
@@ -34,9 +33,9 @@ class GpuDataManager {
   virtual void BlacklistWebGLForTesting() = 0;
 
   virtual bool IsFeatureBlacklisted(int feature) const = 0;
-
-  virtual gpu::GpuFeatureStatus GetFeatureStatus(
-      gpu::GpuFeatureType feature) const = 0;
+  virtual bool IsFeatureEnabled(int feature) const = 0;
+  virtual bool IsWebGLEnabled() const = 0;
+  virtual bool IsWebGL2Enabled() const = 0;
 
   virtual gpu::GPUInfo GetGPUInfo() const = 0;
 
@@ -56,6 +55,11 @@ class GpuDataManager {
   // Check if basic and context GPU info have been collected.
   virtual bool IsEssentialGpuInfoAvailable() const = 0;
 
+  // On Windows, besides basic and context GPU info, it also checks if
+  // DxDiagnostics have been collected.
+  // On other platforms, it's the same as IsEsentialGpuInfoAvailable().
+  virtual bool IsCompleteGpuInfoAvailable() const = 0;
+
   // Requests that the GPU process report its current video memory usage stats.
   virtual void RequestVideoMemoryUsageStatsUpdate(
       const base::Callback<void(const gpu::VideoMemoryUsageStats& stats)>&

content/test/gpu/gpu_tests/gpu_process_expectations.py

@@ -13,9 +13,8 @@ class GpuProcessExpectations(GpuTestExpectations):
 
     self.Fail('GpuProcess_video', ['linux'], bug=257109)
 
-    # GPU process should always be launched for making blacklist decisions.
-    self.Skip('GpuProcess_no_gpu_process')
-
+    # Chrome on Android doesn't support software fallback.
+    self.Skip('GpuProcess_no_gpu_process', ['android'], bug=643282)
     self.Skip('GpuProcess_skip_gpu_process', ['android'], bug=(610951, 610023))
 
     # Chrome on Windows and Linux create a GPU process that uses SwiftShader
@@ -40,7 +39,3 @@ class GpuProcessExpectations(GpuTestExpectations):
 
     # Seems to have become flaky on Windows recently.
     self.Flaky('GpuProcess_only_one_workaround', ['win'], bug=700522)
-
-    # Seems to trigger SwiftShader, so the test becomes invalid.
-    # Will re-enable this test once we move SwiftShader decision to GPU process.
-    self.Skip('GpuProcess_readback_webgl_gpu_process', ['linux'], bug=732623)

content/test/gpu/gpu_tests/gpu_process_integration_test.py

@@ -73,6 +73,7 @@ class GpuProcessIntegrationTest(gpu_integration_test.GpuIntegrationTest):
              ('GpuProcess_gpu_info_complete', 'gpu/functional_3d_css.html'),
              ('GpuProcess_no_gpu_process', 'about:blank'),
              ('GpuProcess_driver_bug_workarounds_in_gpu_process', 'chrome:gpu'),
+             ('GpuProcess_readback_webgl_gpu_process', 'chrome:gpu'),
              ('GpuProcess_driver_bug_workarounds_upon_gl_renderer',
               'chrome:gpu'),
              ('GpuProcess_only_one_workaround', 'chrome:gpu'),
@@ -251,10 +252,7 @@ class GpuProcessIntegrationTest(gpu_integration_test.GpuIntegrationTest):
       self.fail('Browser must support GPU aux attributes')
     if not 'gl_renderer' in system_info.gpu.aux_attributes:
       self.fail('Browser must have gl_renderer in aux attribs')
-    if (len(system_info.gpu.aux_attributes['gl_renderer']) <= 0 and
-        sys.platform != 'darwin'):
-      # We don't create a GL context and collect GL strings on GPU process
-      # startup on MacOSX because it's too slow.
+    if len(system_info.gpu.aux_attributes['gl_renderer']) <= 0:
       self.fail('Must have a non-empty gl_renderer string')
 
   def _GpuProcess_no_gpu_process(self, test_path):
@@ -297,6 +295,39 @@ class GpuProcessIntegrationTest(gpu_integration_test.GpuIntegrationTest):
     self._ValidateDriverBugWorkarounds(
       'use_gpu_driver_workaround_for_testing', None)
 
+  def _GpuProcess_readback_webgl_gpu_process(self, test_path):
+    # This test was designed to only run on desktop Linux.
+    options = self.__class__._original_finder_options.browser_options
+    is_platform_android = options.browser_type.startswith('android')
+    if sys.platform.startswith('linux') and not is_platform_android:
+      # Hit id 110 from kSoftwareRenderingListEntries.
+      self.RestartBrowserIfNecessaryWithArgs([
+        '--gpu-testing-vendor-id=0x10de',
+        '--gpu-testing-device-id=0x0de1',
+        '--gpu-testing-gl-vendor=VMware',
+        '--gpu-testing-gl-renderer=Gallium 0.4 ' \
+        'on llvmpipe (LLVM 3.4, 256 bits)',
+        '--gpu-testing-gl-version="3.0 Mesa 11.2"'])
+      self._Navigate(test_path)
+      feature_status_list = self.tab.EvaluateJavaScript(
+          'browserBridge.gpuInfo.featureStatus.featureStatus')
+      result = True
+      for name, status in feature_status_list.items():
+        if name == 'multiple_raster_threads':
+          result = result and status == 'enabled_on'
+        elif name == 'native_gpu_memory_buffers':
+          result = result and status == 'disabled_software'
+        elif name == 'webgl':
+          result = result and status == 'enabled_readback'
+        elif name == 'webgl2':
+          result = result and status == 'unavailable_software'
+        elif name == 'checker_imaging':
+          pass
+        else:
+          result = result and status == 'unavailable_software'
+      if not result:
+        self.fail('WebGL readback setup failed: %s' % feature_status_list)
+
   def _GpuProcess_driver_bug_workarounds_upon_gl_renderer(self, test_path):
     is_platform_android = self._RunningOnAndroid()
     if is_platform_android:

gpu/config/gpu_blacklist.cc

@@ -38,6 +38,8 @@ std::unique_ptr<GpuBlacklist> GpuBlacklist::Create(
                             GPU_FEATURE_TYPE_FLASH_STAGE3D_BASELINE);
   list->AddSupportedFeature("accelerated_video_decode",
                             GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE);
+  list->AddSupportedFeature("accelerated_video_encode",
+                            GPU_FEATURE_TYPE_ACCELERATED_VIDEO_ENCODE);
   list->AddSupportedFeature("panel_fitting", GPU_FEATURE_TYPE_PANEL_FITTING);
   list->AddSupportedFeature("gpu_rasterization",
                             GPU_FEATURE_TYPE_GPU_RASTERIZATION);

gpu/config/gpu_blacklist_unittest.cc

@@ -95,6 +95,9 @@ GPU_BLACKLIST_FEATURE_TEST(FlashStage3DBaseline,
 GPU_BLACKLIST_FEATURE_TEST(AcceleratedVideoDecode,
                            GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE)
 
+GPU_BLACKLIST_FEATURE_TEST(AcceleratedVideoEncode,
+                           GPU_FEATURE_TYPE_ACCELERATED_VIDEO_ENCODE)
+
 GPU_BLACKLIST_FEATURE_TEST(PanelFitting,
                            GPU_FEATURE_TYPE_PANEL_FITTING)
 

gpu/config/gpu_feature_type.h

@@ -17,6 +17,7 @@ enum GpuFeatureType {
   GPU_FEATURE_TYPE_FLASH3D,
   GPU_FEATURE_TYPE_FLASH_STAGE3D,
   GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE,
+  GPU_FEATURE_TYPE_ACCELERATED_VIDEO_ENCODE,
   GPU_FEATURE_TYPE_PANEL_FITTING,
   GPU_FEATURE_TYPE_FLASH_STAGE3D_BASELINE,
   GPU_FEATURE_TYPE_GPU_RASTERIZATION,

gpu/config/gpu_util.cc

@@ -166,37 +166,6 @@ GpuFeatureStatus GetAcceleratedVideoDecodeFeatureStatus(
   return kGpuFeatureStatusEnabled;
 }
 
-GpuFeatureStatus GetPanelFittingFeatureStatus(
-    const std::set<int>& blacklisted_features,
-    bool use_swift_shader,
-    bool use_swift_shader_for_webgl) {
-#if defined(OS_CHROMEOS)
-  if (use_swift_shader || use_swift_shader_for_webgl)
-    return kGpuFeatureStatusDisabled;
-  if (blacklisted_features.count(GPU_FEATURE_TYPE_PANEL_FITTING))
-    return kGpuFeatureStatusBlacklisted;
-  return kGpuFeatureStatusEnabled;
-#else
-  return kGpuFeatureStatusDisabled;
-#endif
-}
-
-GpuFeatureStatus GetGpuCompositingFeatureStatus(
-    const std::set<int>& blacklisted_features,
-    bool use_swift_shader,
-    bool use_swift_shader_for_webgl) {
-  if (use_swift_shader) {
-    // This is for testing only. Chrome should exercise the GPU accelerated
-    // path on top of SwiftShader driver.
-    return kGpuFeatureStatusEnabled;
-  }
-  if (use_swift_shader_for_webgl)
-    return kGpuFeatureStatusDisabled;
-  if (blacklisted_features.count(GPU_FEATURE_TYPE_GPU_COMPOSITING))
-    return kGpuFeatureStatusBlacklisted;
-  return kGpuFeatureStatusEnabled;
-}
-
 void AppendWorkaroundsToCommandLine(const GpuFeatureInfo& gpu_feature_info,
                                     base::CommandLine* command_line) {
   if (gpu_feature_info.IsWorkaroundEnabled(DISABLE_D3D11)) {
@@ -358,17 +327,6 @@ GpuFeatureInfo ComputeGpuFeatureInfo(const GPUInfo& gpu_info,
   gpu_feature_info.status_values[GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE] =
       GetAcceleratedVideoDecodeFeatureStatus(
           blacklisted_features, use_swift_shader, use_swift_shader_for_webgl);
-  gpu_feature_info.status_values[GPU_FEATURE_TYPE_PANEL_FITTING] =
-      GetPanelFittingFeatureStatus(blacklisted_features, use_swift_shader,
-                                   use_swift_shader_for_webgl);
-  gpu_feature_info.status_values[GPU_FEATURE_TYPE_GPU_COMPOSITING] =
-      GetGpuCompositingFeatureStatus(blacklisted_features, use_swift_shader,
-                                     use_swift_shader_for_webgl);
-#if DCHECK_IS_ON()
-  for (int ii = 0; ii < NUMBER_OF_GPU_FEATURE_TYPES; ++ii) {
-    DCHECK_NE(kGpuFeatureStatusUndefined, gpu_feature_info.status_values[ii]);
-  }
-#endif
 
   std::set<base::StringPiece> all_disabled_extensions;
   std::string disabled_gl_extensions_value =

gpu/config/software_rendering_list.json

@@ -1382,6 +1382,16 @@
         { "vendor_id": "0x8086" }
       ]
     },
+    {
+      "id": 138,
+      "description": "Accelerated video encode is unavailable on Linux",
+      "os": {
+        "type": "linux"
+      },
+      "features": [
+        "accelerated_video_encode"
+      ]
+    },
     {
       "id": 139,
       "description": "GPU Rasterization is disabled on pre-GCN AMD cards",