Move gpu blacklist to content side.

content/browser/gpu/gpu_blacklist.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 "chrome/browser/gpu_blacklist.h"
+#include "content/browser/gpu/gpu_blacklist.h"
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/version.h"
-#include "chrome/browser/gpu_util.h"
-#include "chrome/common/chrome_version_info.h"
-#include "content/public/browser/gpu_data_manager.h"
+#include "content/browser/gpu/gpu_util.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/gpu_info.h"
 
-using content::GpuDataManager;
 using content::GpuFeatureType;
 
 namespace {
 
 // Encode a date as Version, where [0] is year, [1] is month, and [2] is day.
 void GetDateFromString(const std::string& date_string, Version* version) {
   // TODO(zmo): verify if in Windows registry, driver dates are always in the
   // format of "mm-dd-yyyy".
   std::vector<std::string> pieces;
   base::SplitString(date_string, '-', &pieces);
@@ skipping 880 matching lines @@
 }
 
 bool GpuBlacklist::GpuBlacklistEntry::disabled() const {
   return disabled_;
 }
 
 GpuFeatureType GpuBlacklist::GpuBlacklistEntry::GetGpuFeatureType() const {
   return feature_type_;
 }
 
-// static
-GpuBlacklist* GpuBlacklist::GetInstance() {
-  return Singleton<GpuBlacklist>::get();
-}
-
 GpuBlacklist::GpuBlacklist()
     : max_entry_id_(0),
       contains_unknown_fields_(false) {
-  GpuDataManager::GetInstance()->AddObserver(this);
 }
 
 GpuBlacklist::~GpuBlacklist() {
   Clear();
-  GpuDataManager::GetInstance()->RemoveObserver(this);
 }
 
 bool GpuBlacklist::LoadGpuBlacklist(
     const std::string& json_context, GpuBlacklist::OsFilter os_filter) {
-  chrome::VersionInfo chrome_version_info;
-  std::string chrome_version_string =
-      chrome_version_info.is_valid() ? chrome_version_info.Version() : "0";
-  return LoadGpuBlacklist(chrome_version_string, json_context, os_filter);
+  const std::string browser_version_string = "0";
+  return LoadGpuBlacklist(browser_version_string, json_context, os_filter);
 }
 
 bool GpuBlacklist::LoadGpuBlacklist(
     const std::string& browser_version_string,
     const std::string& json_context,
     GpuBlacklist::OsFilter os_filter) {
   browser_version_.reset(new Version(browser_version_string));
   DCHECK(browser_version_->IsValid());
 
   scoped_ptr<Value> root;
@@ skipping 89 matching lines @@
   for (size_t i = 0; i < blacklist_.size(); ++i) {
     if (blacklist_[i]->Contains(os, *os_version, gpu_info)) {
       if (!blacklist_[i]->disabled())
         type |= blacklist_[i]->GetGpuFeatureType();
       active_entries_.push_back(blacklist_[i]);
     }
   }
   return static_cast<GpuFeatureType>(type);
 }
 
-void GpuBlacklist::UpdateGpuDataManager() {
-  content::GpuFeatureType feature_type = DetermineGpuFeatureType(
-      GpuBlacklist::kOsAny, NULL, GpuDataManager::GetInstance()->GetGPUInfo());
-  GpuDataManager::GetInstance()->SetPreliminaryBlacklistedFeatures(
-      feature_type);
-  gpu_util::UpdateStats();
-}
-
 void GpuBlacklist::GetGpuFeatureTypeEntries(
     content::GpuFeatureType feature,
     std::vector<uint32>& entry_ids,
     bool disabled) const {
   entry_ids.clear();
   for (size_t i = 0; i < active_entries_.size(); ++i) {
     if (((feature & active_entries_[i]->GetGpuFeatureType()) != 0) &&
         disabled == active_entries_[i]->disabled())
       entry_ids.push_back(active_entries_[i]->id());
   }
@@ skipping 85 matching lines @@
         new VersionInfo(version_op, "", version_string, version_string2));
     if (!browser_version_info->IsValid())
       return kMalformed;
     if (browser_version_info->Contains(*browser_version_))
       return kSupported;
     return kUnsupported;
   }
   return kSupported;
 }
 
-void GpuBlacklist::OnGpuInfoUpdate() {
-  UpdateGpuDataManager();
-}
-
 // static
 GpuBlacklist::NumericOp GpuBlacklist::StringToNumericOp(
     const std::string& op) {
   if (op == "=")
     return kEQ;
   if (op == "<")
     return kLT;
   if (op == "<=")
     return kLE;
   if (op == ">")
     return kGT;
   if (op == ">=")
     return kGE;
   if (op == "any")
     return kAny;
   if (op == "between")
     return kBetween;
   return kUnknown;
 }