Moving SwiftShader from component to bundled library

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 25 matching lines @@
 #include "gpu/config/gpu_control_list_jsons.h"
 #include "gpu/config/gpu_driver_bug_workaround_type.h"
 #include "gpu/config/gpu_feature_type.h"
 #include "gpu/config/gpu_info_collector.h"
 #include "gpu/config/gpu_switches.h"
 #include "gpu/config/gpu_util.h"
 #include "gpu/ipc/common/memory_stats.h"
 #include "gpu/ipc/service/switches.h"
 #include "media/media_features.h"
 #include "ui/base/ui_base_switches.h"
+#include "ui/gl/gl_features.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/gpu_switching_manager.h"
 
 #if defined(USE_OZONE)
 #include "ui/ozone/public/ozone_switches.h"
 #endif
 #if defined(OS_MACOSX)
 #include <ApplicationServices/ApplicationServices.h>
 #endif  // OS_MACOSX
@@ skipping 232 matching lines @@
 #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 (feature == gpu::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS ||
+            feature == gpu::GPU_FEATURE_TYPE_WEBGL2);
   }
 
   return (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::IsDriverBugWorkaroundActive(int feature) const {
   return (gpu_driver_bugs_.count(feature) == 1);
 }
 
 size_t GpuDataManagerImplPrivate::GetBlacklistedFeatureCount() const {
   if (use_swiftshader_)
-    return 1;
+    return 2;  // GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS and
+               // GPU_FEATURE_TYPE_WEBGL2
   return blacklisted_features_.size();
 }
 
 gpu::GPUInfo GpuDataManagerImplPrivate::GetGPUInfo() const {
   return gpu_info_;
 }
 
 void GpuDataManagerImplPrivate::GetGpuProcessHandles(
     const GpuDataManager::GetGpuProcessHandlesCallback& callback) const {
   GpuProcessHost::GetProcessHandles(callback);
@@ skipping 103 matching lines @@
 void GpuDataManagerImplPrivate::RequestVideoMemoryUsageStatsUpdate() const {
   GpuProcessHost::SendOnIO(GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
                            false /* force_create */,
                            new GpuMsg_GetVideoMemoryUsageStats());
 }
 
 bool GpuDataManagerImplPrivate::ShouldUseSwiftShader() const {
   return use_swiftshader_;
 }
 
-void GpuDataManagerImplPrivate::RegisterSwiftShaderPath(
-    const base::FilePath& path) {
-  swiftshader_path_ = path;
-  EnableSwiftShaderIfNecessary();
-}
-
 void GpuDataManagerImplPrivate::AddObserver(GpuDataManagerObserver* observer) {
   GpuDataManagerImpl::UnlockedSession session(owner_);
   observer_list_->AddObserver(observer);
 }
 
 void GpuDataManagerImplPrivate::RemoveObserver(
     GpuDataManagerObserver* observer) {
   GpuDataManagerImpl::UnlockedSession session(owner_);
   observer_list_->RemoveObserver(observer);
 }
@@ skipping 288 matching lines @@
         switches::kUseGL,
         gl::GetGLImplementationName(gl::GetSoftwareGLImplementation()));
   } else if (!use_gl.empty()) {
     command_line->AppendSwitchASCII(switches::kUseGL, use_gl);
   }
   if (ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus())
     command_line->AppendSwitchASCII(switches::kSupportsDualGpus, "true");
   else
     command_line->AppendSwitchASCII(switches::kSupportsDualGpus, "false");
 
-  if (!swiftshader_path_.empty()) {
-    command_line->AppendSwitchPath(switches::kSwiftShaderPath,
-                                   swiftshader_path_);
-  }
-
   if (!gpu_driver_bugs_.empty()) {
     command_line->AppendSwitchASCII(switches::kGpuDriverBugWorkarounds,
                                     IntSetToString(gpu_driver_bugs_));
   }
 
   if (!disabled_extensions_.empty()) {
     command_line->AppendSwitchASCII(switches::kDisableGLExtensions,
                                     disabled_extensions_);
   }
 
@@ skipping 360 matching lines @@
       update_histograms_(true),
       domain_blocking_enabled_(true),
       owner_(owner),
       gpu_process_accessible_(true),
       is_initialized_(false),
       finalized_(false),
       in_process_gpu_(false) {
   DCHECK(owner_);
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
-  swiftshader_path_ = command_line->GetSwitchValuePath(
-      switches::kSwiftShaderPath);
   if (ShouldDisableHardwareAcceleration())
     DisableHardwareAcceleration();
 
   if (command_line->HasSwitch(switches::kSingleProcess) ||
       command_line->HasSwitch(switches::kInProcessGPU)) {
     in_process_gpu_ = true;
   }
 
 #if defined(OS_MACOSX)
   CGDisplayRegisterReconfigurationCallback(DisplayReconfigCallback, owner_);
@@ skipping 82 matching lines @@
   }
   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 BUILDFLAG(ENABLE_SWIFTSHADER)
+  if (!GpuAccessAllowed(nullptr) ||

[sugoi1, 2017/03/01 16:50:22]

This call to GpuAccessAllowed() causes SwiftShader to be enabled too often.
This is due to:
https://cs.chromium.org/chromium/src/content/browser/gpu/gpu_data_manager_imp...

Because EnableSwiftShaderIfNecessary() is called within UpdateGpuInfo(),
GpuAccessAllowed() can return false simply because
UpdatePreliminaryBlacklistedFeatures() hasn't been called yet. I don't think
GpuAccessAllowed() is necessary here, correct me if I'm wrong.

I'll remove it so that SwiftShader is only enabled when WebGL is explictly
blacklisted, which should be enough for now.

       blacklisted_features_.count(gpu::GPU_FEATURE_TYPE_WEBGL)) {
-    if (!swiftshader_path_.empty() &&
-        !base::CommandLine::ForCurrentProcess()->HasSwitch(
-             switches::kDisableSoftwareRasterizer))
+    if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kDisableSoftwareRasterizer))
       use_swiftshader_ = true;
   }
+#endif
 }
 
 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
   // would require a third-party library to reliably figure out the
   // top-level domain from a URL.
@@ skipping 95 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