Generalzie GpuBlacklist to GpuControlList.

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
 
@@ skipping 10 matching lines @@
 #include "base/version.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 "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/plugins/plugin_switches.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
@@ skipping 53 matching lines @@
 GpuDataManagerImpl* GpuDataManagerImpl::GetInstance() {
   return Singleton<GpuDataManagerImpl>::get();
 }
 
 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, gpu_info);
+  InitializeImpl(gpu_blacklist_json, "", "", gpu_info);
 }
 
 GpuFeatureType GpuDataManagerImpl::GetBlacklistedFeatures() const {
   if (software_rendering_) {
     GpuFeatureType flags;
 
     // Skia's software rendering is probably more efficient than going through
     // software emulation of the GPU, so use that.
     flags = GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS;
     return flags;
@@ skipping 165 matching lines @@
     return;
 
   GPUInfo gpu_info;
   gpu_info_collector::CollectBasicGraphicsInfo(&gpu_info);
 #if defined(ARCH_CPU_X86_FAMILY)
   if (!gpu_info.gpu.vendor_id || !gpu_info.gpu.device_id)
     gpu_info.finalized = true;
 #endif
 
   std::string gpu_blacklist_string;
+  std::string gpu_switching_list_string;
+  std::string gpu_driver_bug_list_string;
   if (!command_line->HasSwitch(switches::kIgnoreGpuBlacklist)) {
     const base::StringPiece gpu_blacklist_json =
         GetContentClient()->GetDataResource(
             IDR_GPU_BLACKLIST, ui::SCALE_FACTOR_NONE);
     gpu_blacklist_string = gpu_blacklist_json.as_string();
+    const base::StringPiece gpu_switching_list_json =
+        GetContentClient()->GetDataResource(
+            IDR_GPU_SWITCHING_LIST, ui::SCALE_FACTOR_NONE);
+    gpu_switching_list_string = gpu_switching_list_json.as_string();
   }
-
-  InitializeImpl(gpu_blacklist_string, gpu_info);
+  if (!command_line->HasSwitch(switches::kDisableGpuDriverBugWorkarounds)) {
+    const base::StringPiece gpu_driver_bug_list_json =
+        GetContentClient()->GetDataResource(
+            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_)
     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_;
   }
 
   GetContentClient()->SetGpuInfo(my_gpu_info);
 
   if (gpu_blacklist_.get()) {
-    GpuBlacklist::Decision decision =
-        gpu_blacklist_->MakeBlacklistDecision(
-            GpuBlacklist::kOsAny, "", my_gpu_info);
+    int features = gpu_blacklist_->MakeDecision(
+        GpuControlList::kOsAny, "", my_gpu_info);
     if (update_histograms_)
-      UpdateStats(gpu_blacklist_.get(), decision.blacklisted_features);
+      UpdateStats(gpu_blacklist_.get(), features);
 
-    UpdateBlacklistedFeatures(decision.blacklisted_features);
-    if (decision.gpu_switching != GPU_SWITCHING_OPTION_UNKNOWN) {
+    UpdateBlacklistedFeatures(static_cast<GpuFeatureType>(features));
+  }
+  if (gpu_switching_list_.get()) {
+    int option = gpu_switching_list_->MakeDecision(
+        GpuControlList::kOsAny, "", my_gpu_info);
+    if (option != GPU_SWITCHING_OPTION_UNKNOWN) {
       // Blacklist decision should not overwrite commandline switch from users.
       CommandLine* command_line = CommandLine::ForCurrentProcess();
       if (!command_line->HasSwitch(switches::kGpuSwitching))
-        gpu_switching_ = decision.gpu_switching;
+        gpu_switching_ = static_cast<GpuSwitchingOption>(option);
     }
   }
+  if (gpu_driver_bug_list_.get())
+    gpu_driver_bugs_ = gpu_driver_bug_list_->MakeDecision(
+        GpuControlList::kOsAny, "", my_gpu_info);
 
   // We have to update GpuFeatureType before notify all the observers.
   NotifyGpuInfoUpdate();
 }
 
 void GpuDataManagerImpl::UpdateVideoMemoryUsageStats(
     const GPUVideoMemoryUsageStats& video_memory_usage_stats) {
   observer_list_->Notify(&GpuDataManagerObserver::OnVideoMemoryUsageStatsUpdate,
                          video_memory_usage_stats);
 }
@@ skipping 153 matching lines @@
 
 std::string GpuDataManagerImpl::GetBlacklistVersion() const {
   if (gpu_blacklist_.get())
     return gpu_blacklist_->GetVersion();
   return "0";
 }
 
 base::ListValue* GpuDataManagerImpl::GetBlacklistReasons() const {
   ListValue* reasons = new ListValue();
   if (gpu_blacklist_.get())
-    gpu_blacklist_->GetBlacklistReasons(reasons);
+    gpu_blacklist_->GetReasons(reasons);
   return reasons;
 }
 
 void GpuDataManagerImpl::AddLogMessage(
     int level, const std::string& header, const std::string& message) {
   base::AutoLock auto_lock(log_messages_lock_);
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger("level", level);
   dict->SetString("header", header);
   dict->SetString("message", message);
@@ skipping 108 matching lines @@
 }
 
 GpuDataManagerImpl::~GpuDataManagerImpl() {
 #if defined(OS_MACOSX)
   CGDisplayRemoveReconfigurationCallback(DisplayReconfigCallback, this);
 #endif
 }
 
 void GpuDataManagerImpl::InitializeImpl(
     const std::string& gpu_blacklist_json,
+    const std::string& gpu_switching_list_json,
+    const std::string& gpu_driver_bug_list_json,
     const GPUInfo& gpu_info) {
+  std::string browser_version_string = ProcessVersionString(
+      GetContentClient()->GetProduct());
+  CHECK(!browser_version_string.empty());
+
   if (!gpu_blacklist_json.empty()) {
-    std::string browser_version_string = ProcessVersionString(
-        GetContentClient()->GetProduct());
-    CHECK(!browser_version_string.empty());
-    gpu_blacklist_.reset(new GpuBlacklist());
-    bool succeed = gpu_blacklist_->LoadGpuBlacklist(
-        browser_version_string,
-        gpu_blacklist_json,
-        GpuBlacklist::kCurrentOsOnly);
-    CHECK(succeed);
+    gpu_blacklist_.reset(GpuBlacklist::Create());
+    gpu_blacklist_->LoadList(
+        browser_version_string, gpu_blacklist_json,
+        GpuControlList::kCurrentOsOnly);
+  }
+  if (!gpu_switching_list_json.empty()) {
+    gpu_switching_list_.reset(GpuSwitchingList::Create());
+    gpu_switching_list_->LoadList(
+        browser_version_string, gpu_switching_list_json,
+        GpuControlList::kCurrentOsOnly);
+  }
+  if (!gpu_driver_bug_list_json.empty()) {
+    gpu_driver_bug_list_.reset(GpuDriverBugList::Create());
+    gpu_driver_bug_list_->LoadList(
+        browser_version_string, gpu_driver_bug_list_json,
+        GpuControlList::kCurrentOsOnly);
   }
 
   {
     base::AutoLock auto_lock(gpu_info_lock_);
     gpu_info_ = gpu_info;
   }
   UpdateGpuInfo(gpu_info);
   UpdateGpuSwitchingManager(gpu_info);
   UpdatePreliminaryBlacklistedFeatures();
 }
@@ skipping 152 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