WebGL feature will only enabled when accelerated

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 <algorithm>
 #include <iterator>
 #include <memory>
 #include <utility>
@@ skipping 915 matching lines @@
 void GpuDataManagerImplPrivate::DisableHardwareAcceleration() {
   if (!is_initialized_) {
     post_init_tasks_.push_back(
         base::Bind(&GpuDataManagerImplPrivate::DisableHardwareAcceleration,
                    base::Unretained(this)));
     return;
   }
 
   card_blacklisted_ = true;
 
-  for (int i = 0; i < gpu::NUMBER_OF_GPU_FEATURE_TYPES; ++i)
-    blacklisted_features_.insert(i);
+  for (int i = 0; i < gpu::NUMBER_OF_GPU_FEATURE_TYPES; ++i) {
+    if ((i != gpu::GPU_FEATURE_TYPE_SWIFTSHADER) ||
+        base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kDisableSoftwareRasterizer)) {

[Zhenyao Mo, 2017/03/09 19:18:03]

Consider this situation: on a system where kDisableSoftwareRasterizer is passed,
and accelerated WebGL is blacklisted.

You will still want the SwiftShader for WebGL, but not for Rasterizer.

What you did here is not to allow SwiftShader for WebGL, which I think it's an
overkill.

[sugoi1, 2017/03/09 19:24:33]

Ok, but this isn't new, I simply moved it from
GpuDataManagerImplPrivate::EnableSwiftShaderIfNecessary() below. I can remove it
if it's wrong.

[sugoi1, 2017/03/09 20:07:12]

Removed kDisableSoftwareRasterizer check.

[sugoi1, 2017/03/09 20:17:07]

Wait a second, I just looked into it and the kDisableSoftwareRasterizer flag is
only used to disable SwiftShader and the description mentions a 3D software
rasterizer, so I think this was correct before.

+      blacklisted_features_.insert(i);
+    }
+  }
 
   EnableSwiftShaderIfNecessary();
   NotifyGpuInfoUpdate();
 }
 
 void GpuDataManagerImplPrivate::SetGpuInfo(const gpu::GPUInfo& gpu_info) {
   DCHECK(!is_initialized_);
   gpu_info_ = gpu_info;
   DCHECK(IsCompleteGpuInfoAvailable());
 }
@@ skipping 276 matching lines @@
     const std::set<int>& features) {
   blacklisted_features_ = features;
 
   // Force disable using the GPU for these features, even if they would
   // otherwise be allowed.
   if (card_blacklisted_) {
     blacklisted_features_.insert(gpu::GPU_FEATURE_TYPE_GPU_COMPOSITING);
     blacklisted_features_.insert(gpu::GPU_FEATURE_TYPE_WEBGL);
   }
 
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisableSoftwareRasterizer)) {
+    blacklisted_features_.insert(gpu::GPU_FEATURE_TYPE_SWIFTSHADER);

[Zhenyao Mo, 2017/03/09 19:18:03]

Same here.

[sugoi1, 2017/03/09 20:07:12]

Removed this change.

+  }
+
   EnableSwiftShaderIfNecessary();
 }
 
 void GpuDataManagerImplPrivate::UpdatePreliminaryBlacklistedFeatures() {
   preliminary_blacklisted_features_ = blacklisted_features_;
   preliminary_blacklisted_features_initialized_ = true;
 }
 
 void GpuDataManagerImplPrivate::UpdateGpuSwitchingManager(
     const gpu::GPUInfo& gpu_info) {
   // The vendor IDs might be 0 on non-PCI devices (like Android), but
   // the length of the vector is all we care about in most cases.
   std::vector<uint32_t> vendor_ids;
   vendor_ids.push_back(gpu_info.gpu.vendor_id);
   for (const auto& device : gpu_info.secondary_gpus) {
     vendor_ids.push_back(device.vendor_id);
   }
   ui::GpuSwitchingManager::GetInstance()->SetGpuVendorIds(vendor_ids);
   gpu::InitializeDualGpusIfSupported(gpu_driver_bugs_);
 }
 
 void GpuDataManagerImplPrivate::NotifyGpuInfoUpdate() {
   observer_list_->Notify(FROM_HERE, &GpuDataManagerObserver::OnGpuInfoUpdate);
 }
 
 void GpuDataManagerImplPrivate::EnableSwiftShaderIfNecessary() {
-  if (!GpuAccessAllowed(NULL) ||
+  if (!GpuAccessAllowed(nullptr) ||
       blacklisted_features_.count(gpu::GPU_FEATURE_TYPE_WEBGL)) {
     if (!swiftshader_path_.empty() &&
-        !base::CommandLine::ForCurrentProcess()->HasSwitch(
-             switches::kDisableSoftwareRasterizer))
+        !blacklisted_features_.count(gpu::GPU_FEATURE_TYPE_SWIFTSHADER))
       use_swiftshader_ = true;
   }
 }
 
 std::string GpuDataManagerImplPrivate::GetDomainFromURL(
     const GURL& url) const {
   // For the moment, we just use the host, or its IP address, as the
   // entry in the set, rather than trying to figure out the top-level
   // domain. This does mean that a.foo.com and b.foo.com will be
   // treated independently in the blocking of a given domain, but it
@@ skipping 97 matching lines @@
   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