Allow switching to SwiftShader when GPU is blacklisted

content/browser/gpu/gpu_data_manager.cc

 // Copyright (c) 2011 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.h"
 
 #if defined(OS_MACOSX)
 #include <CoreGraphics/CGDisplayConfiguration.h>
 #endif
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
+#include "base/file_util.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "content/browser/gpu/gpu_blacklist.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/gpu/gpu_info_collector.h"
@@ skipping 164 matching lines @@
 
 void GpuDataManager::UserFlags::ApplyPolicies() {
   if (disable_accelerated_compositing_) {
     disable_accelerated_2d_canvas_ = true;
     disable_accelerated_layers_ = true;
   }
 }
 
 GpuDataManager::GpuDataManager()
     : complete_gpu_info_already_requested_(false),
-      observer_list_(new GpuDataManagerObserverList) {
+      observer_list_(new GpuDataManagerObserverList),
+      software_rendering_(false) {
   Initialize();
 }
 
 void GpuDataManager::Initialize() {
   // User flags need to be collected before any further initialization.
   user_flags_.Initialize();
 
   // Certain tests doesn't go through the browser startup path that
   // initializes GpuDataManager on FILE thread; therefore, it is initialized
   // on UI thread later, and we skip the preliminary gpu info collection
@@ skipping 110 matching lines @@
     ListValue* feature_status_list = new ListValue();
 
     for (size_t i = 0; i < kNumFeatures; ++i) {
       std::string status;
       if (kGpuFeatureInfo[i].disabled) {
         status = "disabled";
         if (kGpuFeatureInfo[i].fallback_to_software)
           status += "_software";
         else
           status += "_off";
-      } else if (kGpuFeatureInfo[i].blocked || gpu_access_blocked) {
+      } else if (software_rendering()) {
+        status = "unavailable_software";
+      } else if (kGpuFeatureInfo[i].blocked ||
+                 gpu_access_blocked) {
         status = "unavailable";
         if (kGpuFeatureInfo[i].fallback_to_software)
           status += "_software";
         else
           status += "_off";
       } else {
         status = "enabled";
         if (kGpuFeatureInfo[i].name == "webgl" &&
             (user_flags_.disable_accelerated_compositing() ||
              (flags & GpuFeatureFlags::kGpuFeatureAcceleratedCompositing)))
@@ skipping 59 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   log_messages_.Append(msg);
 }
 
 const ListValue& GpuDataManager::log_messages() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return log_messages_;
 }
 
 GpuFeatureFlags GpuDataManager::GetGpuFeatureFlags() {
+  if (software_rendering_) {
+    GpuFeatureFlags flags;
+
+    // Skia's software rendering is probably more efficient than going through
+    // software emulation of the GPU, so use that.
+    flags.set_flags(GpuFeatureFlags::kGpuFeatureAccelerated2dCanvas);
+    return flags;
+  }
+
   return gpu_feature_flags_;
 }
 
 bool GpuDataManager::GpuAccessAllowed() {
+  if (software_rendering())
+    return true;
+
   // 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
   // through renderer commandline switches.
   uint32 mask = (~(preliminary_gpu_feature_flags_.flags()));
   return (gpu_feature_flags_.flags() & mask) == 0;
 }
 
 void GpuDataManager::AddObserver(Observer* observer) {
   observer_list_->AddObserver(observer);
 }
 
 void GpuDataManager::RemoveObserver(Observer* observer) {
   observer_list_->RemoveObserver(observer);
 }
 
 void GpuDataManager::AppendRendererCommandLine(
     CommandLine* command_line) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(command_line);
 
-  uint32 flags = gpu_feature_flags_.flags();
+  uint32 flags = GpuFeatureFlags().flags();
   if ((flags & GpuFeatureFlags::kGpuFeatureWebgl)) {
     if (!command_line->HasSwitch(switches::kDisableExperimentalWebGL))
       command_line->AppendSwitch(switches::kDisableExperimentalWebGL);
     if (!command_line->HasSwitch(switches::kDisablePepper3dForUntrustedUse))
       command_line->AppendSwitch(switches::kDisablePepper3dForUntrustedUse);
   }
   if ((flags & GpuFeatureFlags::kGpuFeatureMultisampling) &&
       !command_line->HasSwitch(switches::kDisableGLMultisampling))
     command_line->AppendSwitch(switches::kDisableGLMultisampling);
   if ((flags & GpuFeatureFlags::kGpuFeatureAcceleratedCompositing) &&
       !command_line->HasSwitch(switches::kDisableAcceleratedCompositing))
     command_line->AppendSwitch(switches::kDisableAcceleratedCompositing);
   if ((flags & GpuFeatureFlags::kGpuFeatureAccelerated2dCanvas) &&
       !command_line->HasSwitch(switches::kDisableAccelerated2dCanvas))
     command_line->AppendSwitch(switches::kDisableAccelerated2dCanvas);
 }
 
 void GpuDataManager::AppendGpuCommandLine(
     CommandLine* command_line) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(command_line);
 
-  uint32 flags = gpu_feature_flags_.flags();
+  uint32 flags = GpuFeatureFlags().flags();
   if ((flags & GpuFeatureFlags::kGpuFeatureMultisampling) &&
       !command_line->HasSwitch(switches::kDisableGLMultisampling))
     command_line->AppendSwitch(switches::kDisableGLMultisampling);
 
-  if ((flags & (GpuFeatureFlags::kGpuFeatureWebgl |
+  if (software_rendering_) {
+    command_line->AppendSwitchASCII(switches::kUseGL, "swiftshader");
+    command_line->AppendSwitchPath(switches::kSwiftShaderPath,
+                                   swiftshader_path_);
+  } else if ((flags & (GpuFeatureFlags::kGpuFeatureWebgl |
                 GpuFeatureFlags::kGpuFeatureAcceleratedCompositing |
                 GpuFeatureFlags::kGpuFeatureAccelerated2dCanvas)) &&
       (user_flags_.use_gl() == "any")) {
     command_line->AppendSwitchASCII(
         switches::kUseGL, gfx::kGLImplementationOSMesaName);
   } else if (!user_flags_.use_gl().empty()) {
     command_line->AppendSwitchASCII(switches::kUseGL, user_flags_.use_gl());
   }
 }
 
@@ skipping 194 matching lines @@
     histogram_pointer->Add(value);
 #if defined(OS_WIN)
     histogram_pointer = base::LinearHistogram::FactoryGet(
         kGpuBlacklistFeatureHistogramNamesWin[i],
         1, kNumWinSubVersions * kGpuFeatureNumStatus,
         kNumWinSubVersions * kGpuFeatureNumStatus + 1,
         base::Histogram::kUmaTargetedHistogramFlag);
     histogram_pointer->Add(GetGpuBlacklistHistogramValueWin(value));
 #endif
   }
+
+  EnableSoftwareRenderingIfNecessary();
+}
+
+void GpuDataManager::RegisterSwiftShaderPath(FilePath path) {
+  swiftshader_path_ = path;
+  EnableSoftwareRenderingIfNecessary();
+}
+
+void GpuDataManager::EnableSoftwareRenderingIfNecessary() {
+  if (!GpuAccessAllowed() ||
+      (gpu_feature_flags_.flags() & GpuFeatureFlags::kGpuFeatureWebgl)) {
+#if defined(ENABLE_SWIFTSHADER)
+    if (!swiftshader_path_.empty())
+      software_rendering_ = true;
+#endif
+  }
 }
 
+bool GpuDataManager::software_rendering() {
+  return software_rendering_;
+}
+
 GpuBlacklist* GpuDataManager::GetGpuBlacklist() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (user_flags_.ignore_gpu_blacklist())
     return NULL;
   // No need to return an empty blacklist.
   if (gpu_blacklist_.get() != NULL && gpu_blacklist_->max_entry_id() == 0)
     return NULL;
   return gpu_blacklist_.get();
 }
 
@@ skipping 65 matching lines @@
 bool GpuDataManager::supportsAccelerated2dCanvas() const {
   if (gpu_info_.can_lose_context)
     return false;
 #if defined(USE_SKIA)
   return true;
 #else
   return false;
 #endif
 }