adds WARP support to Chromium, for Metro mode only, on Windows 8

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 253 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_) {
+  if (use_swiftshader_ || gpu_info_.use_warp) {
     // 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);
 }
 
 bool GpuDataManagerImplPrivate::IsDriverBugWorkaroundActive(int feature) const {
   return (gpu_driver_bugs_.count(feature) == 1);
 }
 
 size_t GpuDataManagerImplPrivate::GetBlacklistedFeatureCount() const {
-  if (use_swiftshader_)
+  if (use_swiftshader_ || gpu_info_.use_warp)
     return 1;
   return blacklisted_features_.size();
 }
 
 void GpuDataManagerImplPrivate::SetDisplayCount(unsigned int display_count) {
   display_count_ = display_count;
 }
 
 unsigned int GpuDataManagerImplPrivate::GetDisplayCount() const {
   return display_count_;
 }
 
 gpu::GPUInfo GpuDataManagerImplPrivate::GetGPUInfo() const {
   return gpu_info_;
 }
 
 void GpuDataManagerImplPrivate::GetGpuProcessHandles(
     const GpuDataManager::GetGpuProcessHandlesCallback& callback) const {
   GpuProcessHost::GetProcessHandles(callback);
 }
 
 bool GpuDataManagerImplPrivate::GpuAccessAllowed(
     std::string* reason) const {
-  if (use_swiftshader_)
+  if (use_swiftshader_ || gpu_info_.use_warp)
     return true;
 
   if (!gpu_process_accessible_) {
     if (reason) {
       *reason = "GPU process launch failed.";
     }
     return false;
   }
 
   if (card_blacklisted_) {
@@ skipping 139 matching lines @@
 void GpuDataManagerImplPrivate::GetGLStrings(std::string* gl_vendor,
                                              std::string* gl_renderer,
                                              std::string* gl_version) {
   DCHECK(gl_vendor && gl_renderer && gl_version);
 
   *gl_vendor = gpu_info_.gl_vendor;
   *gl_renderer = gpu_info_.gl_renderer;
   *gl_version = gpu_info_.gl_version;
 }
 
+void GpuDataManagerImplPrivate::SetShouldUseWarp(bool use_warp) {
+  gpu_info_.use_warp = use_warp;

[Zhenyao Mo, 2014/08/20 21:02:09]

This is incorrect.  gpu_info_ could be updated multiple times during chrome
lifetime and this state will be lost.

You need a separate use_warp_ variable outside gpu_info_.

[luken, 2014/08/27 20:43:46]

Deprecated code.

+  // Let the observers know, particularly the GpuPrefManager, so it can update
+  // its persistent state about using warp or not.
+  NotifyGpuInfoUpdate();
+}
+
+bool GpuDataManagerImplPrivate::ShouldUseWarp() const {
+  return gpu_info_.use_warp ||
+      base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kUseWarp);
+}
+
 void GpuDataManagerImplPrivate::Initialize() {
   TRACE_EVENT0("startup", "GpuDataManagerImpl::Initialize");
   if (finalized_) {
     DVLOG(0) << "GpuDataManagerImpl marked as finalized; skipping Initialize";
     return;
   }
 
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kSkipGpuDataLoading))
@@ skipping 54 matching lines @@
   }
   gpu::GpuDriverBugList::AppendWorkaroundsFromCommandLine(
       &gpu_driver_bugs_, *base::CommandLine::ForCurrentProcess());
 
   // We have to update GpuFeatureType before notify all the observers.
   NotifyGpuInfoUpdate();
 }
 
 void GpuDataManagerImplPrivate::UpdateGpuInfo(const gpu::GPUInfo& gpu_info) {
   // No further update of gpu_info if falling back to SwiftShader.
-  if (use_swiftshader_)
+  if (use_swiftshader_ || gpu_info_.use_warp)
     return;
 
   gpu::MergeGPUInfo(&gpu_info_, gpu_info);
   complete_gpu_info_already_requested_ =
       complete_gpu_info_already_requested_ || gpu_info_.finalized;
 
   UpdateGpuInfoHelper();
 }
 
 void GpuDataManagerImplPrivate::UpdateVideoMemoryUsageStats(
@@ skipping 79 matching lines @@
   // 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));
   command_line->AppendSwitchASCII(switches::kGpuDriverVendor,
       gpu_info_.driver_vendor);
   command_line->AppendSwitchASCII(switches::kGpuDriverVersion,
       gpu_info_.driver_version);
+
+  if (ShouldUseWarp())
+    command_line->AppendSwitch(switches::kUseWarp);
 }
 
 void GpuDataManagerImplPrivate::AppendPluginCommandLine(
     base::CommandLine* command_line) const {
   DCHECK(command_line);
 
 #if defined(OS_MACOSX)
   // TODO(jbauman): Add proper blacklist support for core animation plugins so
   // special-casing this video card won't be necessary. See
   // http://crbug.com/134015
@@ skipping 154 matching lines @@
         gpu_info_.secondary_gpus[ii].active = false;
       }
     }
     gpu_info_.gpu.active = false;
   }
   UpdateGpuInfoHelper();
   return true;
 }
 
 bool GpuDataManagerImplPrivate::CanUseGpuBrowserCompositor() const {
+  if (gpu_info_.use_warp)

[Zhenyao Mo, 2014/08/20 21:02:09]

You should use ShouldUseWarp() here to be consistent.

[luken, 2014/08/27 20:43:46]

Done.

+    return true;
   if (ShouldUseSwiftShader())
     return false;
   if (IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_GPU_COMPOSITING))
     return false;
   return true;
 }
 
 void GpuDataManagerImplPrivate::BlockDomainFrom3DAPIs(
     const GURL& url, GpuDataManagerImpl::DomainGuilt guilt) {
   BlockDomainFrom3DAPIsAtTime(url, guilt, base::Time::Now());
@@ skipping 247 matching lines @@
 
 void GpuDataManagerImplPrivate::OnGpuProcessInitFailure() {
   gpu_process_accessible_ = false;
   gpu_info_.finalized = true;
   complete_gpu_info_already_requested_ = true;
   // Some observers might be waiting.
   NotifyGpuInfoUpdate();
 }
 
 }  // namespace content