Move gpu blacklist to content side.

content/browser/gpu/gpu_blacklist.h

 // 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.
 
-#ifndef CHROME_BROWSER_GPU_BLACKLIST_H_
-#define CHROME_BROWSER_GPU_BLACKLIST_H_
+#ifndef CONTENT_BROWSER_GPU_GPU_BLACKLIST_H_
+#define CONTENT_BROWSER_GPU_GPU_BLACKLIST_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/memory/singleton.h"
 #include "base/values.h"
-#include "content/public/browser/gpu_data_manager_observer.h"
+#include "build/build_config.h"
+#include "content/common/content_export.h"
 #include "content/public/common/gpu_feature_type.h"
 
 class Version;
 
 namespace content {
 struct GPUInfo;
 }
 
-class GpuBlacklist : public content::GpuDataManagerObserver {
+class CONTENT_EXPORT GpuBlacklist {
  public:
   enum OsType {
     kOsLinux,
     kOsMacosx,
     kOsWin,
     kOsChromeOS,
     kOsAny,
     kOsUnknown
   };
 
   enum OsFilter {
     // In loading, ignore all entries that belong to other OS.
     kCurrentOsOnly,
     // In loading, keep all entries. This is for testing only.
     kAllOs
   };
 
-  // Getter for the singleton. This will return NULL on failure.
-  static GpuBlacklist* GetInstance();
-
+  GpuBlacklist();
   virtual ~GpuBlacklist();
 
   // Loads blacklist information from a json file.
   // If failed, the current GpuBlacklist is un-touched.
-  bool LoadGpuBlacklist(const std::string& json_context,
+  bool LoadGpuBlacklist(const std::string& json_context, OsFilter os_filter);
+  bool LoadGpuBlacklist(const std::string& browser_version_string,
+                        const std::string& json_context,
                         OsFilter os_filter);
 
   // Collects system information and combines them with gpu_info and blacklist
   // information to determine gpu feature flags.
   // If os is kOsAny, use the current OS; if os_version is null, use the
   // current OS version.
   content::GpuFeatureType DetermineGpuFeatureType(
       OsType os, Version* os_version, const content::GPUInfo& gpu_info);
 
-  // Helper function that calls DetermineGpuFeatureType and sets the updated
-  // features on GpuDataManager.
-  void UpdateGpuDataManager();
-
   // Collects the active entries that set the "feature" flag from the last
   // DetermineGpuFeatureType() call.  This tells which entries are responsible
   // for raising a certain flag, i.e, for blacklisting a certain feature.
   // Examples of "feature":
   //   GPU_FEATURE_TYPE_ALL - any of the supported features;
   //   GPU_FEATURE_TYPE_WEBGL - a single feature;
   //   GPU_FEATURE_TYPE_WEBGL | GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING
   //       - two features.
   // If disabled set to true, return entries that are disabled; otherwise,
   // return enabled entries.
@@ skipping 13 matching lines @@
   void GetBlacklistReasons(ListValue* problem_list) const;
 
   // Return the largest entry id.  This is used for histogramming.
   uint32 max_entry_id() const;
 
   // Returns the version of the current blacklist.
   std::string GetVersion() const;
 
  private:
   friend class GpuBlacklistTest;
-  friend struct DefaultSingletonTraits<GpuBlacklist>;
   FRIEND_TEST_ALL_PREFIXES(GpuBlacklistTest, ChromeVersionEntry);
   FRIEND_TEST_ALL_PREFIXES(GpuBlacklistTest, CurrentBlacklistValidation);
   FRIEND_TEST_ALL_PREFIXES(GpuBlacklistTest, UnknownField);
   FRIEND_TEST_ALL_PREFIXES(GpuBlacklistTest, UnknownExceptionField);
   FRIEND_TEST_ALL_PREFIXES(GpuBlacklistTest, UnknownFeature);
 
   enum BrowserVersionSupport {
     kSupported,
     kUnsupported,
     kMalformed
@@ skipping 250 matching lines @@
     scoped_ptr<FloatInfo> perf_overall_info_;
     content::GpuFeatureType feature_type_;
     std::vector<ScopedGpuBlacklistEntry> exceptions_;
     bool contains_unknown_fields_;
     bool contains_unknown_features_;
   };
 
   // Gets the current OS type.
   static OsType GetOsType();
 
-  GpuBlacklist();
-
-  bool LoadGpuBlacklist(const std::string& browser_version_string,
-                        const std::string& json_context,
-                        OsFilter os_filter);
-
   bool LoadGpuBlacklist(const base::DictionaryValue& parsed_json,
                         OsFilter os_filter);
 
   void Clear();
 
   // Check if the entry is supported by the current version of browser.
   // By default, if there is no browser version information in the entry,
   // return kSupported;
   BrowserVersionSupport IsEntrySupportedByCurrentBrowserVersion(
       const base::DictionaryValue* value);
 
-  // GpuDataManager::Observer implementation.
-  virtual void OnGpuInfoUpdate() OVERRIDE;
-  virtual void OnVideoMemoryUsageStatsUpdate(
-      const content::GPUVideoMemoryUsageStats& video_memory) OVERRIDE {}
-
   // Returns the number of entries.  This is only for tests.
   size_t num_entries() const;
 
   // Check if any entries contain unknown fields.  This is only for tests.
   bool contains_unknown_fields() const { return contains_unknown_fields_; }
 
   static NumericOp StringToNumericOp(const std::string& op);
 
   scoped_ptr<Version> version_;
   std::vector<ScopedGpuBlacklistEntry> blacklist_;
 
   scoped_ptr<Version> browser_version_;
 
   // This records all the blacklist entries that are appliable to the current
   // user machine.  It is updated everytime DetermineGpuFeatureType() is
   // called and is used later by GetGpuFeatureTypeEntries().
   std::vector<ScopedGpuBlacklistEntry> active_entries_;
 
   uint32 max_entry_id_;
 
   bool contains_unknown_fields_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuBlacklist);
 };
 
-#endif  // CHROME_BROWSER_GPU_BLACKLIST_H_
+#endif  // CONTENT_BROWSER_GPU_GPU_BLACKLIST_H_
+