Add capability for GPU blacklist to manage GPU switching.

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"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 14 matching lines @@
 #include "ui/gl/gl_switches.h"
 #include "webkit/plugins/plugin_switches.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 using content::BrowserThread;
 using content::GpuDataManagerObserver;
 using content::GpuFeatureType;
+using content::GpuSwitchingOption;
 
 // static
 content::GpuDataManager* content::GpuDataManager::GetInstance() {
   return GpuDataManagerImpl::GetInstance();
 }
 
 // static
 GpuDataManagerImpl* GpuDataManagerImpl::GetInstance() {
   return Singleton<GpuDataManagerImpl>::get();
 }
 
 GpuDataManagerImpl::GpuDataManagerImpl()
     : complete_gpu_info_already_requested_(false),
       gpu_feature_type_(content::GPU_FEATURE_TYPE_UNKNOWN),
       preliminary_gpu_feature_type_(content::GPU_FEATURE_TYPE_UNKNOWN),
+      gpu_switching_(content::GPU_SWITCHING_AUTOMATIC),
       observer_list_(new GpuDataManagerObserverList),
       software_rendering_(false),
       card_blacklisted_(false),
       update_histograms_(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 60 matching lines @@
   return gpu_info_.finalized;
 }
 
 void GpuDataManagerImpl::UpdateGpuInfo(const content::GPUInfo& gpu_info) {
   if (gpu_info_.finalized)
     return;
 
   content::GetContentClient()->SetGpuInfo(gpu_info);
 
   if (gpu_blacklist_.get()) {
-    GpuFeatureType feature_type = gpu_blacklist_->DetermineGpuFeatureType(
-        GpuBlacklist::kOsAny, NULL, gpu_info);
-    if (update_histograms_)
-      gpu_util::UpdateStats(gpu_blacklist_.get(), feature_type);
-    UpdateBlacklistedFeatures(feature_type);
+    GpuBlacklist::Decision decision =
+        gpu_blacklist_->MakeBlacklistDecision(
+            GpuBlacklist::kOsAny, NULL, gpu_info);
+    if (update_histograms_) {
+      gpu_util::UpdateStats(gpu_blacklist_.get(),
+                            decision.blacklisted_features);
+    }
+    UpdateBlacklistedFeatures(decision.blacklisted_features);
+    gpu_switching_ = decision.gpu_switching;
   }
 
   {
     base::AutoLock auto_lock(gpu_info_lock_);
     gpu_info_ = gpu_info;
     complete_gpu_info_already_requested_ =
         complete_gpu_info_already_requested_ || gpu_info_.finalized;
   }
 
   // We have to update GpuFeatureType before notify all the observers.
@@ skipping 47 matching lines @@
 
     // Skia's software rendering is probably more efficient than going through
     // software emulation of the GPU, so use that.
     flags = content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS;
     return flags;
   }
 
   return gpu_feature_type_;
 }
 
+GpuSwitchingOption GpuDataManagerImpl::GetGpuSwitchingOption() const {
+  return gpu_switching_;
+}
+
 base::ListValue* GpuDataManagerImpl::GetBlacklistReasons() const {
   ListValue* reasons = new ListValue();
   if (gpu_blacklist_.get())
     gpu_blacklist_->GetBlacklistReasons(reasons);
   return reasons;
 }
 
 bool GpuDataManagerImpl::GpuAccessAllowed() const {
   if (software_rendering_)
     return true;
@@ skipping 204 matching lines @@
 
 void GpuDataManagerImpl::BlacklistCard() {
   card_blacklisted_ = true;
 
   gpu_feature_type_ = content::GPU_FEATURE_TYPE_ALL;
 
   EnableSoftwareRenderingIfNecessary();
   NotifyGpuInfoUpdate();
 }