Move base/values.h into the base namespace.

content/browser/gpu/gpu_blacklist.h

 // Copyright (c) 2011 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 CONTENT_BROWSER_GPU_GPU_BLACKLIST_H_
 #define CONTENT_BROWSER_GPU_GPU_BLACKLIST_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "content/common/gpu/gpu_feature_flags.h"
 
-class DictionaryValue;
 class Version;
 struct GPUInfo;
 
+namespace base {
+class DictionaryValue;
+}
+
 class GpuBlacklist {
  public:
   enum OsType {
     kOsLinux,
     kOsMacosx,
     kOsWin,
     kOsChromeOS,
     kOsAny,
     kOsUnknown
   };
 
   explicit GpuBlacklist(const std::string& browser_version_string);
   ~GpuBlacklist();
 
   // Loads blacklist information from a json file.
   // current_os_only==true indicates all blacklist entries that don't belong to
   // the current OS are discarded; current_os_only==false should only be used
   // for testing purpose.
   // If failed, the current GpuBlacklist is un-touched.
   bool LoadGpuBlacklist(const std::string& json_context,
                         bool current_os_only);
-  bool LoadGpuBlacklist(const DictionaryValue& parsed_json,
+  bool LoadGpuBlacklist(const base::DictionaryValue& parsed_json,
                         bool current_os_only);
 
   // 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.
   GpuFeatureFlags DetermineGpuFeatureFlags(OsType os,
                                            Version* os_version,
                                            const GPUInfo& gpu_info);
 
@@ skipping 27 matching lines @@
   //    'composting',
   //    'webgl',
   //    'multisampling'
   //
   // Each problems has:
   // {
   //    "description": "Your GPU is too old",
   //    "crBugs": [1234],
   //    "webkitBugs": []
   // }
-  Value* GetFeatureStatus(bool gpu_access_allowed,
-                          bool disable_accelerated_compositing,
-                          bool disable_accelerated_2D_canvas,
-                          bool disable_experimental_webgl,
-                          bool disable_multisampling) const;
+  base::Value* GetFeatureStatus(bool gpu_access_allowed,
+                                bool disable_accelerated_compositing,
+                                bool disable_accelerated_2D_canvas,
+                                bool disable_experimental_webgl,
+                                bool disable_multisampling) const;
 
   // Return the largest entry id.  This is used for histogramming.
   uint32 max_entry_id() const;
 
   // Collects the version of the current blacklist.  Returns false and sets
   // major and minor to 0 on failure.
   bool GetVersion(uint16* major, uint16* monir) const;
 
   // Collects the version of the current blacklist from a parsed json file.
   // Returns false and sets major and minor to 0 on failure.
   static bool GetVersion(
-      const DictionaryValue& parsed_json, uint16* major, uint16* minor);
+      const base::DictionaryValue& parsed_json, uint16* major, uint16* minor);
 
  private:
   class VersionInfo {
    public:
     VersionInfo(const std::string& version_op,
                 const std::string& version_string,
                 const std::string& version_string2);
     ~VersionInfo();
 
     // Determines if a given version is included in the VersionInfo range.
@@ skipping 70 matching lines @@
 
     Op op_;
     std::string value_;
   };
 
   class GpuBlacklistEntry {
    public:
     // Constructs GpuBlacklistEntry from DictionaryValue loaded from json.
     // Top-level entry must have an id number.  Others are exceptions.
     static GpuBlacklistEntry* GetGpuBlacklistEntryFromValue(
-        DictionaryValue* value, bool top_level);
+        base::DictionaryValue* value, bool top_level);
 
     // Determines if a given os/gc/driver is included in the Entry set.
     bool Contains(OsType os_type,
                   const Version& os_version,
                   const GPUInfo& gpu_info) const;
 
     // Returns the OsType.
     OsType GetOsType() const;
 
     // Returns the entry's unique id.  0 is reserved.
@@ skipping 69 matching lines @@
   static OsType GetOsType();
 
   void Clear();
 
   bool IsFeatureBlacklisted(GpuFeatureFlags::GpuFeatureType feature) const;
 
   // 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(
-      DictionaryValue* value);
+      base::DictionaryValue* value);
 
   scoped_ptr<Version> version_;
   std::vector<GpuBlacklistEntry*> blacklist_;
 
   scoped_ptr<Version> browser_version_;
 
   // This records all the blacklist entries that are appliable to the current
   // user machine.  It is updated everytime DetermineGpuFeatureFlags() is
   // called and is used later by GetGpuFeatureFlagEntries().
   std::vector<GpuBlacklistEntry*> active_entries_;
 
   uint32 max_entry_id_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuBlacklist);
 };
 
 #endif  // CONTENT_BROWSER_GPU_GPU_BLACKLIST_H_