Move gpu blacklist to content side.

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"
 #include "base/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/values.h"
 #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_switches.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_switches.h"
 #include "webkit/plugins/plugin_switches.h"
@@ skipping 25 matching lines @@
       card_blacklisted_(false) {
   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))
     BlacklistCard();
 }
 
-void GpuDataManagerImpl::InitializeGpuInfo() {
+void GpuDataManagerImpl::Initialize(
+    const std::string& browser_version_string,
+    const std::string& gpu_blacklist_json) {
   content::GPUInfo gpu_info;
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kSkipGpuDataLoading))

[jbates, 2012/09/06 00:50:41]

Just making sure you meant to remove the kSkipGpuDataLoading feature?

[Zhenyao Mo, 2012/09/06 00:59:45]

Yes, it's taken care of from the caller side.

-    gpu_info_collector::CollectPreliminaryGraphicsInfo(&gpu_info);
-  else
-    gpu_info.finalized = true;
+  gpu_info_collector::CollectPreliminaryGraphicsInfo(&gpu_info);
+
+  if (!gpu_blacklist_json.empty()) {
+    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);
+  }
+
   UpdateGpuInfo(gpu_info);
+  UpdatePreliminaryBlacklistedFeatures();
 }
 
 GpuDataManagerImpl::~GpuDataManagerImpl() {
 }
 
 void GpuDataManagerImpl::RequestCompleteGpuInfoIfNeeded() {
   if (complete_gpu_info_already_requested_ || gpu_info_.finalized)
     return;
   complete_gpu_info_already_requested_ = true;
 
   GpuProcessHost::SendOnIO(
       GpuProcessHost::GPU_PROCESS_KIND_UNSANDBOXED,
       content::CAUSE_FOR_GPU_LAUNCH_GPUDATAMANAGER_REQUESTCOMPLETEGPUINFOIFNEEDED,
       new GpuMsg_CollectGraphicsInfo());
 }
 
 bool GpuDataManagerImpl::IsCompleteGpuInfoAvailable() const {
   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,
+        GpuDataManager::GetInstance()->GetGPUInfo());
+    gpu_util::UpdateStats(gpu_blacklist_.get(), feature_type);
+    UpdateBlacklistedFeatures(feature_type);
+  }
+
   {
     base::AutoLock auto_lock(gpu_info_lock_);
     gpu_info_ = gpu_info;
 #if defined(ARCH_CPU_X86_FAMILY)
     if (!gpu_info.gpu.vendor_id || !gpu_info.gpu.device_id)
       gpu_info_.finalized = true;
 #endif
     complete_gpu_info_already_requested_ =
         complete_gpu_info_already_requested_ || gpu_info_.finalized;
   }
@@ skipping 30 matching lines @@
 
 base::ListValue* GpuDataManagerImpl::GetLogMessages() const {
   base::ListValue* value;
   {
     base::AutoLock auto_lock(log_messages_lock_);
     value = log_messages_.DeepCopy();
   }
   return value;
 }
 
+std::string GpuDataManagerImpl::GetBlacklistVersion() const {
+  if (gpu_blacklist_.get())
+    return gpu_blacklist_->GetVersion();
+  return "0";
+}
+
 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 = content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS;
     return flags;
   }
 
   return gpu_feature_type_;
 }
 
+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;
 
   if (!gpu_info_.gpu_accessible)
     return false;
 
   if (card_blacklisted_)
     return false;
 
@@ skipping 130 matching lines @@
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableAcceleratedCompositing)) {
     if (!command_line->HasSwitch(
            switches::kDisableCoreAnimationPlugins))
       command_line->AppendSwitch(
           switches::kDisableCoreAnimationPlugins);
   }
 #endif
 }
 
-void GpuDataManagerImpl::SetPreliminaryBlacklistedFeatures(
-    GpuFeatureType feature_type) {
-  UpdateBlacklistedFeatures(feature_type);
+void GpuDataManagerImpl::UpdatePreliminaryBlacklistedFeatures() {
   preliminary_gpu_feature_type_ = gpu_feature_type_;
 }
 
 void GpuDataManagerImpl::NotifyGpuInfoUpdate() {
   observer_list_->Notify(&GpuDataManagerObserver::OnGpuInfoUpdate);
 }
 
 void GpuDataManagerImpl::UpdateVideoMemoryUsageStats(
     const content::GPUVideoMemoryUsageStats& video_memory_usage_stats) {
   observer_list_->Notify(&GpuDataManagerObserver::OnVideoMemoryUsageStatsUpdate,
@@ skipping 43 matching lines @@
 
 void GpuDataManagerImpl::BlacklistCard() {
   card_blacklisted_ = true;
 
   gpu_feature_type_ = content::GPU_FEATURE_TYPE_ALL;
 
   EnableSoftwareRenderingIfNecessary();
   NotifyGpuInfoUpdate();
 }