Move gpu blacklist data file 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/string_piece.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 "grit/content_resources.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"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 using content::BrowserThread;
 using content::GpuDataManagerObserver;
 using content::GpuFeatureType;
 using content::GpuSwitchingOption;
 
+namespace {
+
+// Strip out the non-digital info; if after that, we get an empty string,
+// return "0".
+std::string ProcessVersionString(const std::string& raw_string) {
+  const std::string valid_set = "0123456789.";
+  size_t start_pos = raw_string.find_first_of(valid_set);
+  if (start_pos == std::string::npos)
+    return "0";
+  size_t end_pos = raw_string.find_first_not_of(raw_string, start_pos);
+  std::string version_string = raw_string.substr(
+      start_pos, end_pos - start_pos);
+  if (version_string.empty())
+    return "0";
+  return version_string;
+}
+
+}  // namespace anonymous
+
 // 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))
     BlacklistCard();
 }
 
-void GpuDataManagerImpl::Initialize(
-    const std::string& browser_version_string,
-    const std::string& gpu_blacklist_json) {
+void GpuDataManagerImpl::Initialize() {
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kSkipGpuDataLoading))
+    return;
+
   content::GPUInfo gpu_info;
   gpu_info_collector::CollectPreliminaryGraphicsInfo(&gpu_info);
 #if defined(ARCH_CPU_X86_FAMILY)
   if (!gpu_info.gpu.vendor_id || !gpu_info.gpu.device_id)
     gpu_info.finalized = true;
 #endif
 
-  Initialize(browser_version_string, gpu_blacklist_json, gpu_info);
+  std::string gpu_blacklist_string;
+  if (!command_line->HasSwitch(switches::kIgnoreGpuBlacklist)) {
+    const base::StringPiece gpu_blacklist_json =
+        content::GetContentClient()->GetDataResource(
+            IDR_GPU_BLACKLIST, ui::SCALE_FACTOR_NONE);
+    gpu_blacklist_string = gpu_blacklist_json.as_string();
+  }
+
+  InitializeImpl(gpu_blacklist_string, gpu_info);
 }
 
-void GpuDataManagerImpl::Initialize(
-    const std::string& browser_version_string,
+void GpuDataManagerImpl::InitializeForTesting(
+    const std::string& gpu_blacklist_json,
+    const content::GPUInfo& gpu_info) {
+  // This function is for testing only, so disable histograms.
+  update_histograms_ = false;
+
+  InitializeImpl(gpu_blacklist_json, gpu_info);
+}
+
+void GpuDataManagerImpl::InitializeImpl(
     const std::string& gpu_blacklist_json,
     const content::GPUInfo& gpu_info) {
   {
     // This function should only be called in testing.
     // We need clean up the gpu_info_ for a clean initialization.
     const content::GPUInfo empty_gpu_info;
     base::AutoLock auto_lock(gpu_info_lock_);
     gpu_info_ = empty_gpu_info;
   }
 
-  // This function is for testing only, so disable histograms.
-  update_histograms_ = false;
-
   if (!gpu_blacklist_json.empty()) {
+    std::string browser_version_string = ProcessVersionString(
+        content::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);
   }
 
   UpdateGpuInfo(gpu_info);
@@ skipping 322 matching lines @@
 
 void GpuDataManagerImpl::BlacklistCard() {
   card_blacklisted_ = true;
 
   gpu_feature_type_ = content::GPU_FEATURE_TYPE_ALL;
 
   EnableSoftwareRenderingIfNecessary();
   NotifyGpuInfoUpdate();
 }