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 (IsSoftwareRendering()) {
+        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);

[Zhenyao Mo, 2011/11/05 00:39:19]

What about accelerated_compositing?  what about multisampling?

[jbauman, 2011/11/05 00:49:34]

We need accelerated compositing, or webgl will be even slower. Having support
for 3D css everywhere would also be nice. I'm not sure about multisampling, but
I might as well leave it on for now.

[Zhenyao Mo, 2011/11/05 01:03:58]

OK.  Multisampling on/off depends on performance.  If it turns out to be too
slow, we could turn it off later.

+    return flags;
+  }
+
   return gpu_feature_flags_;
 }
 
 bool GpuDataManager::GpuAccessAllowed() {
+  if (IsSoftwareRendering())
+    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);
 }
@@ skipping 28 matching lines @@
 void GpuDataManager::AppendGpuCommandLine(
     CommandLine* command_line) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(command_line);
 
   uint32 flags = gpu_feature_flags_.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 22 matching lines @@
   if (!updated_list->GetVersion(
           &updated_version_major, &updated_version_minor))
     return;
 
   uint16 current_version_major, current_version_minor;
   bool succeed = gpu_blacklist_->GetVersion(
       &current_version_major, &current_version_minor);
   DCHECK(succeed);
   if (updated_version_major < current_version_major ||
       (updated_version_major == current_version_major &&
-       updated_version_minor <= current_version_minor))
+       updated_version_minor <= current_version_minor)) {
     return;
+  }
 
   gpu_blacklist_.reset(updated_list.release());
   UpdateGpuFeatureFlags();
   if (preliminary)
     preliminary_gpu_feature_flags_ = gpu_feature_flags_;
   VLOG(1) << "Using software rendering list version "
           << updated_version_major << "." << updated_version_minor;
 }
 
 void GpuDataManager::HandleGpuSwitch() {
@@ skipping 150 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()) {

[Zhenyao Mo, 2011/11/05 00:39:19]

Even if GpuAccessAllowed() returns true, but if webgl is blocked, you should
still enable software rendering.

[jbauman, 2011/11/05 00:49:34]

It's kind of annoying that this would slow down accelerated compositing on those
platforms, but you're right.

+#if defined(ENABLE_SWIFTSHADER)
+    FilePath eglpath = swiftshader_path_.AppendASCII("libegl.dll");
+    if (!swiftshader_path_.empty() && file_util::PathExists(eglpath))

[Zhenyao Mo, 2011/11/05 00:39:19]

PathExists should only be called on a thread that allows IO (not IO thread, but
say, FileThread).  So you need to make sure of that.  Maybe DCHECK thread in
RegisterSwiftShaderPath()?  Since that's the only caller of this function.

[jbauman, 2011/11/05 00:49:34]

Good point, I can remove this check.

+      software_rendering_ = true;
+#endif
+  }
 }
 
+bool GpuDataManager::IsSoftwareRendering() {
+  return software_rendering_;

[Zhenyao Mo, 2011/11/05 00:39:19]

Accessor functions should match the variable name.

Say, the variable name is is_software_rendering_, the accessor function name
should be is_software_rendering().

[jbauman, 2011/11/05 00:49:34]

Ok.

+}
+
 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
 }