[CLOSED] Cleaning up the plethora of switches for GPU vs software vs SwiftShader.

content/browser/gpu/gpu_data_manager_impl.cc

 // Copyright (c) 2012 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.h"
 
 #if defined(OS_MACOSX)
 #include <ApplicationServices/ApplicationServices.h>
 #endif  // OS_MACOSX
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/sys_info.h"
 #include "base/values.h"
 #include "base/version.h"
+#include "cc/base/switches.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/gpu/gpu_util.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/gpu/gpu_info_collector.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/gpu_data_manager_observer.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/gpu_feature_type.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "grit/content_resources.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/gpu_switching_manager.h"
 #include "webkit/glue/webpreferences.h"
 #include "webkit/plugins/plugin_switches.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 namespace content {
 namespace {
 
+const bool DISABLE_GPU = true;
+
 // Strip out the non-digital info; if after that, we get an empty string,
 // return "0".
 std::string ProcessVersionString(const std::string& raw_string) {
   const std::string valid_set = "0123456789.";
   size_t start_pos = raw_string.find_first_of(valid_set);
   if (start_pos == std::string::npos)
     return "0";
   size_t end_pos = raw_string.find_first_not_of(raw_string, start_pos);
   std::string version_string = raw_string.substr(
       start_pos, end_pos - start_pos);
@@ skipping 55 matching lines @@
 void GpuDataManagerImpl::InitializeForTesting(
     const std::string& gpu_blacklist_json,
     const GPUInfo& gpu_info) {
   // This function is for testing only, so disable histograms.
   update_histograms_ = false;
 
   InitializeImpl(gpu_blacklist_json, std::string(), std::string(), gpu_info);
 }
 
 bool GpuDataManagerImpl::IsFeatureBlacklisted(int feature) const {
-  if (software_rendering_) {
-    // Skia's software rendering is probably more efficient than going through
-    // software emulation of the GPU, so use that.
+  if (use_swiftshader_) {
+    // Skia's rendering is more efficient than going through
+    // SwiftShader emulation, so use that.
     if (feature == GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS)
       return true;
     return false;
   }
 
   return (blacklisted_features_.count(feature) == 1);
 }
 
 size_t GpuDataManagerImpl::GetBlacklistedFeatureCount() const {
-  if (software_rendering_)
+  if (use_swiftshader_)
     return 1;
   return blacklisted_features_.size();
 }
 
 void GpuDataManagerImpl::AddGpuSwitchCallback(
     const GpuSwitchCallback& callback) {
   gpu_switch_callbacks_.push_back(callback);
 }
 
 void GpuDataManagerImpl::RemoveGpuSwitchCallback(
@@ skipping 14 matching lines @@
   }
   return gpu_info;
 }
 
 void GpuDataManagerImpl::GetGpuProcessHandles(
     const GetGpuProcessHandlesCallback& callback) const {
   GpuProcessHost::GetProcessHandles(callback);
 }
 
 bool GpuDataManagerImpl::GpuAccessAllowed() const {
-  if (software_rendering_)
+  if (use_swiftshader_)
     return true;
 
   if (!gpu_info_.gpu_accessible)
     return false;
 
   if (card_blacklisted_)
     return false;
 
   // We only need to block GPU process if more features are disallowed other
   // than those in the preliminary gpu feature flags because the latter work
@@ skipping 36 matching lines @@
   return gpu_info_.finalized;
 }
 
 void GpuDataManagerImpl::RequestVideoMemoryUsageStatsUpdate() const {
   GpuProcessHost::SendOnIO(
       GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
       CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH,
       new GpuMsg_GetVideoMemoryUsageStats());
 }
 
-bool GpuDataManagerImpl::ShouldUseSoftwareRendering() const {
-  return software_rendering_;
+bool GpuDataManagerImpl::ShouldUseSwiftShader() const {
+  return use_swiftshader_;
 }
 
 void GpuDataManagerImpl::RegisterSwiftShaderPath(const base::FilePath& path) {
   swiftshader_path_ = path;
-  EnableSoftwareRenderingIfNecessary();
+  EnableSwiftShaderIfNecessary();
 }
 
 void GpuDataManagerImpl::AddObserver(GpuDataManagerObserver* observer) {
   observer_list_->AddObserver(observer);
 }
 
 void GpuDataManagerImpl::RemoveObserver(GpuDataManagerObserver* observer) {
   observer_list_->RemoveObserver(observer);
 }
 
@@ skipping 96 matching lines @@
             IDR_GPU_DRIVER_BUG_LIST, ui::SCALE_FACTOR_NONE);
     gpu_driver_bug_list_string = gpu_driver_bug_list_json.as_string();
   }
   InitializeImpl(gpu_blacklist_string,
                  gpu_switching_list_string,
                  gpu_driver_bug_list_string,
                  gpu_info);
 }
 
 void GpuDataManagerImpl::UpdateGpuInfo(const GPUInfo& gpu_info) {
-  // No further update of gpu_info if falling back to software renderer.
-  if (software_rendering_)
+  // No further update of gpu_info if falling back to SwiftShader.
+  if (use_swiftshader_)
     return;
 
   GPUInfo my_gpu_info;
   {
     base::AutoLock auto_lock(gpu_info_lock_);
     gpu_info_collector::MergeGPUInfo(&gpu_info_, gpu_info);
     complete_gpu_info_already_requested_ =
         complete_gpu_info_already_requested_ || gpu_info_.finalized;
     my_gpu_info = gpu_info_;
   }
@@ skipping 29 matching lines @@
 void GpuDataManagerImpl::UpdateVideoMemoryUsageStats(
     const GPUVideoMemoryUsageStats& video_memory_usage_stats) {
   observer_list_->Notify(&GpuDataManagerObserver::OnVideoMemoryUsageStatsUpdate,
                          video_memory_usage_stats);
 }
 
 void GpuDataManagerImpl::AppendRendererCommandLine(
     CommandLine* command_line) const {
   DCHECK(command_line);
 
+  if (DISABLE_GPU) {
+    if (!command_line->HasSwitch(switches::kAllowWebUICompositing))
+      command_line->AppendSwitch(switches::kAllowWebUICompositing);
+    if (!command_line->HasSwitch(switches::kDisableGpu))
+      command_line->AppendSwitch(switches::kDisableGpu);
+#ifndef OS_ANDROID
+    if (!command_line->HasSwitch(switches::kDisableExperimentalWebGL))
+      command_line->AppendSwitch(switches::kDisableExperimentalWebGL);
+#endif
+    if (!command_line->HasSwitch(switches::kDisablePepper3d))
+      command_line->AppendSwitch(switches::kDisablePepper3d);
+    if (!command_line->HasSwitch(switches::kDisableAcceleratedPlugins))
+      command_line->AppendSwitch(switches::kDisableAcceleratedPlugins);
+    if (!command_line->HasSwitch(switches::kDisableAccelerated2dCanvas))
+      command_line->AppendSwitch(switches::kDisableAccelerated2dCanvas);
+    if (!command_line->HasSwitch(switches::kDisableAcceleratedVideoDecode))
+      command_line->AppendSwitch(switches::kDisableAcceleratedVideoDecode);
+    if (!command_line->HasSwitch(switches::kDisableFlashFullscreen3d))
+      command_line->AppendSwitch(switches::kDisableFlashFullscreen3d);
+    if (!command_line->HasSwitch(cc::switches::kEnableCompositorFrameMessage))
+      command_line->AppendSwitch(cc::switches::kEnableCompositorFrameMessage);
+    return;
+  }
+
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL)) {
 #if !defined(OS_ANDROID)
     if (!command_line->HasSwitch(switches::kDisableExperimentalWebGL))
       command_line->AppendSwitch(switches::kDisableExperimentalWebGL);
 #endif
     if (!command_line->HasSwitch(switches::kDisablePepper3d))
       command_line->AppendSwitch(switches::kDisablePepper3d);
   }
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_MULTISAMPLING) &&
       !command_line->HasSwitch(switches::kDisableGLMultisampling))
     command_line->AppendSwitch(switches::kDisableGLMultisampling);
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING) &&
       !command_line->HasSwitch(switches::kDisableAcceleratedCompositing))
     command_line->AppendSwitch(switches::kDisableAcceleratedCompositing);
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS) &&
       !command_line->HasSwitch(switches::kDisableAccelerated2dCanvas))
     command_line->AppendSwitch(switches::kDisableAccelerated2dCanvas);
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE) &&
       !command_line->HasSwitch(switches::kDisableAcceleratedVideoDecode))
     command_line->AppendSwitch(switches::kDisableAcceleratedVideoDecode);
-  if (ShouldUseSoftwareRendering())
+  if (ShouldUseSwiftShader())
     command_line->AppendSwitch(switches::kDisableFlashFullscreen3d);
 }
 
 void GpuDataManagerImpl::AppendGpuCommandLine(
     CommandLine* command_line) const {
   DCHECK(command_line);
 
   std::string use_gl =
       CommandLine::ForCurrentProcess()->GetSwitchValueASCII(switches::kUseGL);
   base::FilePath swiftshader_path =
       CommandLine::ForCurrentProcess()->GetSwitchValuePath(
           switches::kSwiftShaderPath);
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_MULTISAMPLING) &&
       !command_line->HasSwitch(switches::kDisableGLMultisampling))
     command_line->AppendSwitch(switches::kDisableGLMultisampling);
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_TEXTURE_SHARING))
     command_line->AppendSwitch(switches::kDisableImageTransportSurface);
 
-  if (software_rendering_) {
+  if (use_swiftshader_) {
     command_line->AppendSwitchASCII(switches::kUseGL, "swiftshader");
     if (swiftshader_path.empty())
       swiftshader_path = swiftshader_path_;
   } else if ((IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL) ||
               IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING) ||
               IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS)) &&
       (use_gl == "any")) {
     command_line->AppendSwitchASCII(
         switches::kUseGL, gfx::kGLImplementationOSMesaName);
   } else if (!use_gl.empty()) {
@@ skipping 79 matching lines @@
            switches::kDisableCoreAnimationPlugins))
       command_line->AppendSwitch(
           switches::kDisableCoreAnimationPlugins);
   }
 #endif
 }
 
 void GpuDataManagerImpl::UpdateRendererWebPrefs(
     webkit_glue::WebPreferences* prefs) const {
   DCHECK(prefs);
+
+  if (DISABLE_GPU) {
+    prefs->force_compositing_mode = true;
+    prefs->accelerated_compositing_enabled = true;
+    prefs->accelerated_compositing_for_3d_transforms_enabled = true;
+    prefs->accelerated_compositing_for_animation_enabled = true;
+    prefs->experimental_webgl_enabled = false;
+    prefs->flash_3d_enabled = false;
+    prefs->flash_stage3d_enabled = false;
+    prefs->flash_stage3d_baseline_enabled = false;
+    prefs->accelerated_2d_canvas_enabled = false;
+    prefs->gl_multisampling_enabled = false;
+    prefs->accelerated_compositing_for_video_enabled = false;
+    prefs->accelerated_compositing_for_plugins_enabled = false;
+    return;
+  }
+
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING))
     prefs->accelerated_compositing_enabled = false;
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL))
     prefs->experimental_webgl_enabled = false;
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_FLASH3D))
     prefs->flash_3d_enabled = false;
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_FLASH_STAGE3D)) {
     prefs->flash_stage3d_enabled = false;
     prefs->flash_stage3d_baseline_enabled = false;
   }
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_FLASH_STAGE3D_BASELINE))
     prefs->flash_stage3d_baseline_enabled = false;
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS))
     prefs->accelerated_2d_canvas_enabled = false;
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_MULTISAMPLING))
     prefs->gl_multisampling_enabled = false;
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_3D_CSS)) {
     prefs->accelerated_compositing_for_3d_transforms_enabled = false;
     prefs->accelerated_compositing_for_animation_enabled = false;
   }
   if (IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_VIDEO))
     prefs->accelerated_compositing_for_video_enabled = false;
 
-  // Accelerated video and animation are slower than regular when using a
-  // software 3d rasterizer. 3D CSS may also be too slow to be worthwhile.
-  if (ShouldUseSoftwareRendering()) {
+  // Accelerated video and animation are slower than regular when using
+  // SwiftShader. 3D CSS may also be too slow to be worthwhile.
+  if (ShouldUseSwiftShader()) {
     prefs->accelerated_compositing_for_video_enabled = false;
     prefs->accelerated_compositing_for_animation_enabled = false;
     prefs->accelerated_compositing_for_3d_transforms_enabled = false;
     prefs->accelerated_compositing_for_plugins_enabled = false;
   }
 }
 
 GpuSwitchingOption GpuDataManagerImpl::GetGpuSwitchingOption() const {
   if (!ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus())
     return GPU_SWITCHING_OPTION_UNKNOWN;
   return gpu_switching_;
 }
 
 void GpuDataManagerImpl::DisableHardwareAcceleration() {
   card_blacklisted_ = true;
 
   for (int i = 0; i < NUMBER_OF_GPU_FEATURE_TYPES; ++i)
     blacklisted_features_.insert(i);
 
-  EnableSoftwareRenderingIfNecessary();
+  EnableSwiftShaderIfNecessary();
   NotifyGpuInfoUpdate();
 }
 
 std::string GpuDataManagerImpl::GetBlacklistVersion() const {
   if (gpu_blacklist_)
     return gpu_blacklist_->version();
   return "0";
 }
 
 base::ListValue* GpuDataManagerImpl::GetBlacklistReasons() const {
@@ skipping 42 matching lines @@
     gpu_switch_callbacks_[i].Run();
 }
 
 #if defined(OS_WIN)
 bool GpuDataManagerImpl::IsUsingAcceleratedSurface() const {
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     return false;
 
   if (gpu_info_.amd_switchable)
     return false;
-  if (software_rendering_)
+  if (use_swiftshader_)
     return false;
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kDisableImageTransportSurface))
     return false;
   return !IsFeatureBlacklisted(GPU_FEATURE_TYPE_TEXTURE_SHARING);
 }
 #endif
 
 void GpuDataManagerImpl::BlockDomainFrom3DAPIs(
     const GURL& url, DomainGuilt guilt) {
@@ skipping 18 matching lines @@
 }
 
 void GpuDataManagerImpl::DisableDomainBlockingFor3DAPIsForTesting() {
   domain_blocking_enabled_ = false;
 }
 
 GpuDataManagerImpl::GpuDataManagerImpl()
     : complete_gpu_info_already_requested_(false),
       gpu_switching_(GPU_SWITCHING_OPTION_AUTOMATIC),
       observer_list_(new GpuDataManagerObserverList),
-      software_rendering_(false),
+      use_swiftshader_(false),
       card_blacklisted_(false),
       update_histograms_(true),
       window_count_(0),
       domain_blocking_enabled_(true) {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kDisableAcceleratedCompositing)) {
     command_line->AppendSwitch(switches::kDisableAccelerated2dCanvas);
     command_line->AppendSwitch(switches::kDisableAcceleratedLayers);
   }
   if (command_line->HasSwitch(switches::kDisableGpu))
@@ skipping 63 matching lines @@
   // otherwise be allowed.
   if (card_blacklisted_ ||
       command_line->HasSwitch(switches::kBlacklistAcceleratedCompositing)) {
     blacklisted_features_.insert(GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING);
   }
   if (card_blacklisted_ ||
       command_line->HasSwitch(switches::kBlacklistWebGL)) {
     blacklisted_features_.insert(GPU_FEATURE_TYPE_WEBGL);
   }
 
-  EnableSoftwareRenderingIfNecessary();
+  EnableSwiftShaderIfNecessary();
 }
 
 void GpuDataManagerImpl::UpdatePreliminaryBlacklistedFeatures() {
   preliminary_blacklisted_features_ = blacklisted_features_;
 }
 
 void GpuDataManagerImpl::UpdateGpuSwitchingManager(const GPUInfo& gpu_info) {
   ui::GpuSwitchingManager::GetInstance()->SetGpuCount(
       gpu_info.secondary_gpus.size() + 1);
 
   if (ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus()) {
     switch (gpu_switching_) {
       case GPU_SWITCHING_OPTION_FORCE_DISCRETE:
         ui::GpuSwitchingManager::GetInstance()->ForceUseOfDiscreteGpu();
         break;
       case GPU_SWITCHING_OPTION_FORCE_INTEGRATED:
         ui::GpuSwitchingManager::GetInstance()->ForceUseOfIntegratedGpu();
         break;
       case GPU_SWITCHING_OPTION_AUTOMATIC:
       case GPU_SWITCHING_OPTION_UNKNOWN:
         break;
     }
   }
 }
 
 void GpuDataManagerImpl::NotifyGpuInfoUpdate() {
   observer_list_->Notify(&GpuDataManagerObserver::OnGpuInfoUpdate);
 }
 
-void GpuDataManagerImpl::EnableSoftwareRenderingIfNecessary() {
+void GpuDataManagerImpl::EnableSwiftShaderIfNecessary() {
   if (!GpuAccessAllowed() ||
       blacklisted_features_.count(GPU_FEATURE_TYPE_WEBGL)) {
     if (!swiftshader_path_.empty() &&
         !CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kDisableSoftwareRasterizer))
-      software_rendering_ = true;
+      use_swiftshader_ = true;
   }
 }
 
 std::string GpuDataManagerImpl::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 87 matching lines @@
 
 void GpuDataManagerImpl::Notify3DAPIBlocked(const GURL& url,
                                             int render_process_id,
                                             int render_view_id,
                                             ThreeDAPIType requester) {
   observer_list_->Notify(&GpuDataManagerObserver::DidBlock3DAPIs,
                          url, render_process_id, render_view_id, requester);
 }
 
 }  // namespace content