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 149 matching lines @@
   blacklist->GetDecisionEntries(&flag_disabled_entries, disabled);
   for (uint32_t disabled_entry : flag_disabled_entries) {
     UMA_HISTOGRAM_ENUMERATION("GPU.BlacklistTestResultsPerDisabledEntry",
         disabled_entry, max_entry_id + 1);
   }
 
   const gpu::GpuFeatureType kGpuFeatures[] = {
       gpu::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS,
       gpu::GPU_FEATURE_TYPE_GPU_COMPOSITING,
       gpu::GPU_FEATURE_TYPE_GPU_RASTERIZATION,
-      gpu::GPU_FEATURE_TYPE_WEBGL,
-      gpu::GPU_FEATURE_TYPE_WEBGL2};
+      gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL,
+      gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL2};
   const std::string kGpuBlacklistFeatureHistogramNames[] = {
       "GPU.BlacklistFeatureTestResults.Accelerated2dCanvas",
       "GPU.BlacklistFeatureTestResults.GpuCompositing",
       "GPU.BlacklistFeatureTestResults.GpuRasterization",
       "GPU.BlacklistFeatureTestResults.Webgl",
       "GPU.BlacklistFeatureTestResults.Webgl2"};
   const bool kGpuFeatureUserFlags[] = {
       command_line.HasSwitch(switches::kDisableAccelerated2dCanvas),
       command_line.HasSwitch(switches::kDisableGpu),
       command_line.HasSwitch(switches::kDisableGpuRasterization),
@@ skipping 113 matching lines @@
 }
 
 bool GpuDataManagerImplPrivate::IsFeatureBlacklisted(int feature) const {
 #if defined(OS_CHROMEOS)
   if (feature == gpu::GPU_FEATURE_TYPE_PANEL_FITTING &&
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePanelFitting)) {
     return true;
   }
 #endif  // OS_CHROMEOS
-  if (use_swiftshader_) {
-    // Skia's software rendering is probably more efficient than going through
-    // software emulation of the GPU, so use that.
-    if (feature == gpu::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS)
-      return true;
-    return false;
-  }
 
-  return (blacklisted_features_.count(feature) == 1);
+  // SwiftShader blacklists all features
+  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::IsDriverBugWorkaroundActive(int feature) const {
   return (gpu_driver_bugs_.count(feature) == 1);
 }
 
 size_t GpuDataManagerImplPrivate::GetBlacklistedFeatureCount() const {
-  if (use_swiftshader_)
-    return 1;
-  return blacklisted_features_.size();
+  // SwiftShader blacklists all features
+  return use_swiftshader_ ? gpu::NUMBER_OF_GPU_FEATURE_TYPES
+                          : blacklisted_features_.size();
 }
 
 gpu::GPUInfo GpuDataManagerImplPrivate::GetGPUInfo() const {
   return gpu_info_;
 }
 
 void GpuDataManagerImplPrivate::GetGpuProcessHandles(
     const GpuDataManager::GetGpuProcessHandlesCallback& callback) const {
   GpuProcessHost::GetProcessHandles(callback);
 }
@@ skipping 32 matching lines @@
     // because their context creation can always be rejected on the GPU process
     // side.
     std::set<int> feature_diffs;
     std::set_difference(blacklisted_features_.begin(),
                         blacklisted_features_.end(),
                         preliminary_blacklisted_features_.begin(),
                         preliminary_blacklisted_features_.end(),
                         std::inserter(feature_diffs, feature_diffs.begin()));
     if (feature_diffs.size()) {
       // TODO(zmo): Other features might also be OK to ignore here.
-      feature_diffs.erase(gpu::GPU_FEATURE_TYPE_WEBGL);
-      feature_diffs.erase(gpu::GPU_FEATURE_TYPE_WEBGL2);
+      feature_diffs.erase(gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL);
+      feature_diffs.erase(gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL2);
     }
     if (feature_diffs.size()) {
       if (reason) {
         *reason = "Features are disabled on full but not preliminary GPU info.";
       }
       return false;
     }
   }
 
   if (blacklisted_features_.size() == gpu::NUMBER_OF_GPU_FEATURE_TYPES) {
@@ skipping 348 matching lines @@
       gpu_driver_bugs_.end()) {
     command_line->AppendSwitch(switches::kDisableES3GLContext);
   }
   if (gpu_driver_bugs_.find(gpu::DISABLE_DIRECT_COMPOSITION) !=
       gpu_driver_bugs_.end()) {
     command_line->AppendSwitch(switches::kDisableDirectComposition);
   }
   if (use_swiftshader_) {
     command_line->AppendSwitchASCII(
         switches::kUseGL, gl::kGLImplementationSwiftShaderForWebGLName);
-  } else if ((IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_WEBGL) ||
+  } else if ((IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL) ||
               IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_GPU_COMPOSITING) ||
               IsFeatureBlacklisted(
                   gpu::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS)) &&
              (use_gl == "any")) {
     command_line->AppendSwitchASCII(
         switches::kUseGL,
         gl::GetGLImplementationName(gl::GetSoftwareGLImplementation()));
   } else if (!use_gl.empty()) {
     command_line->AppendSwitchASCII(switches::kUseGL, use_gl);
   }
@@ skipping 57 matching lines @@
       command_line->AppendSwitch(switches::kDisableWebRtcHWEncoding);
     if (gpu_preferences)
       gpu_preferences->disable_web_rtc_hw_encoding = true;
 #if defined (OS_ANDROID)
   }
 #endif
 }
 #endif
 
   if (gpu_preferences) { // enable_es3_apis
-    bool blacklisted = IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_WEBGL2);
+    bool blacklisted =
+        IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL2);
     bool enabled = base::CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kEnableES3APIs);
     bool disabled = base::CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kDisableES3APIs);
     gpu_preferences->enable_es3_apis = (enabled || !blacklisted) && !disabled;

[piman, 2017/03/10 20:31:40]

Mmh, I think we still want to be precise about webgl2. Is is the case that using
SwiftShader implies webgl2 is disabled altogether, or is it that it is just
unaccelerated?

If the former, then we should keep the blacklist feature named
"webgl2"/"GPU_FEATURE_TYPE_WEBGL2", but this code is still right. If the latter,
then we need to change the code here, because blacklisting "accelerated webgl2"
shouldn't result in disabling webgl2 altogether.

[sugoi1, 2017/03/10 20:42:38]

Ok, I can revert the WebGL2 change. For now, SwiftShader is not yet used for
WebGL2.

   }
 
   // Pass GPU and driver information to GPU process. We try to avoid full GPU
   // info collection at GPU process startup, but we need gpu vendor_id,
   // device_id, driver_vendor, driver_version for deciding whether we need to
   // collect full info (on Linux) and for crash reporting purpose.
   command_line->AppendSwitchASCII(switches::kGpuVendorID,
       base::StringPrintf("0x%04x", gpu_info_.gpu.vendor_id));
   command_line->AppendSwitchASCII(switches::kGpuDeviceID,
       base::StringPrintf("0x%04x", gpu_info_.gpu.device_id));
@@ skipping 36 matching lines @@
     command_line->AppendSwitchASCII(
         switches::kGpuActiveDeviceID,
         base::StringPrintf("0x%04x", maybe_active_gpu_device.device_id));
   }
 }
 
 void GpuDataManagerImplPrivate::UpdateRendererWebPrefs(
     WebPreferences* prefs) const {
   DCHECK(prefs);
 
-  if (IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_WEBGL)) {
+  if (!IsWebGLEnabled()) {
     prefs->experimental_webgl_enabled = false;
     prefs->pepper_3d_enabled = false;
   }
   if (IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_FLASH3D))
     prefs->flash_3d_enabled = false;
   if (IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_FLASH_STAGE3D)) {
     prefs->flash_stage3d_enabled = false;
     prefs->flash_stage3d_baseline_enabled = false;
   }
   if (IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_FLASH_STAGE3D_BASELINE))
@@ skipping 317 matching lines @@
 }
 
 void GpuDataManagerImplPrivate::UpdateBlacklistedFeatures(
     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);
+    blacklisted_features_.insert(gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL);
+    blacklisted_features_.insert(gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL2);
   }
 
   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) ||
-      blacklisted_features_.count(gpu::GPU_FEATURE_TYPE_WEBGL)) {
+      blacklisted_features_.count(gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL)) {
     if (!swiftshader_path_.empty() &&
         !base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kDisableSoftwareRasterizer))
       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
@@ skipping 100 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