Revert 155218 - 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::Initialize(
-    const std::string& browser_version_string,
-    const std::string& gpu_blacklist_json) {
+void GpuDataManagerImpl::InitializeGpuInfo() {
   content::GPUInfo gpu_info;
-  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);
-  }
-
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSkipGpuDataLoading))
+    gpu_info_collector::CollectPreliminaryGraphicsInfo(&gpu_info);
+  else
+    gpu_info.finalized = true;
   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 133 matching lines @@
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableAcceleratedCompositing)) {
     if (!command_line->HasSwitch(
            switches::kDisableCoreAnimationPlugins))
       command_line->AppendSwitch(
           switches::kDisableCoreAnimationPlugins);
   }
 #endif
 }
 
-void GpuDataManagerImpl::UpdatePreliminaryBlacklistedFeatures() {
+void GpuDataManagerImpl::SetPreliminaryBlacklistedFeatures(
+    GpuFeatureType feature_type) {
+  UpdateBlacklistedFeatures(feature_type);
   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();
 }