Move base/values.h into the base namespace.

chrome/browser/extensions/extension_prefs.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 CHROME_BROWSER_EXTENSIONS_EXTENSION_PREFS_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_PREFS_H_
 #pragma once
 
 #include <set>
 #include <string>
@@ skipping 58 matching lines @@
 
   // Does not assume ownership of |prefs| and |incognito_prefs|.
   explicit ExtensionPrefs(PrefService* prefs,
                           const FilePath& root_dir,
                           ExtensionPrefValueMap* extension_pref_value_map);
   virtual ~ExtensionPrefs();
 
   // Returns a copy of the Extensions prefs.
   // TODO(erikkay) Remove this so that external consumers don't need to be
   // aware of the internal structure of the preferences.
-  DictionaryValue* CopyCurrentExtensions();
+  base::DictionaryValue* CopyCurrentExtensions();
 
   // Returns true if the specified external extension was uninstalled by the
   // user.
   bool IsExternalExtensionUninstalled(const std::string& id) const;
 
   // Get the order that toolstrip URLs appear in the shelf.
   typedef std::vector<GURL> URLList;
   URLList GetShelfToolstripOrder();
 
   // Sets the order that toolstrip URLs appear in the shelf.
@@ skipping 200 matching lines @@
                         const std::string& data);
   std::string GetUpdateUrlData(const std::string& extension_id);
 
   // Sets a preference value that is controlled by the extension. In other
   // words, this is not a pref value *about* the extension but something
   // global the extension wants to override.
   // Takes ownership of |value|.
   void SetExtensionControlledPref(const std::string& extension_id,
                                   const std::string& pref_key,
                                   ExtensionPrefsScope scope,
-                                  Value* value);
+                                  base::Value* value);
 
   void RemoveExtensionControlledPref(const std::string& extension_id,
                                      const std::string& pref_key,
                                      ExtensionPrefsScope scope);
 
   // Returns true if currently no extension with higher precedence controls the
   // preference.
   bool CanExtensionControlPref(const std::string& extension_id,
                                const std::string& pref_key,
                                bool incognito);
@@ skipping 35 matching lines @@
   virtual void OnContentSettingChanged(
       const std::string& extension_id,
       bool incognito) OVERRIDE;
 
   // Converts absolute paths in the pref to paths relative to the
   // install_directory_.
   void MakePathsRelative();
 
   // Converts internal relative paths to be absolute. Used for export to
   // consumers who expect full paths.
-  void MakePathsAbsolute(DictionaryValue* dict);
+  void MakePathsAbsolute(base::DictionaryValue* dict);
 
   // Sets the pref |key| for extension |id| to |value|.
   void UpdateExtensionPref(const std::string& id,
                            const std::string& key,
-                           Value* value);
+                           base::Value* value);
 
   // Deletes the pref dictionary for extension |id|.
   void DeleteExtensionPrefs(const std::string& id);
 
   // Reads a boolean pref from |ext| with key |pref_key|.
   // Return false if the value is false or |pref_key| does not exist.
-  static bool ReadBooleanFromPref(const DictionaryValue* ext,
+  static bool ReadBooleanFromPref(const base::DictionaryValue* ext,
                                   const std::string& pref_key);
 
   // Reads a boolean pref |pref_key| from extension with id |extension_id|.
   bool ReadExtensionPrefBoolean(const std::string& extension_id,
                                 const std::string& pref_key);
 
   // Reads an integer pref from |ext| with key |pref_key|.
   // Return false if the value does not exist.
-  static bool ReadIntegerFromPref(const DictionaryValue* ext,
+  static bool ReadIntegerFromPref(const base::DictionaryValue* ext,
                                   const std::string& pref_key,
                                   int* out_value);
 
   // Reads an integer pref |pref_key| from extension with id |extension_id|.
   bool ReadExtensionPrefInteger(const std::string& extension_id,
                                 const std::string& pref_key,
                                 int* out_value);
 
   // Reads a list pref |pref_key| from extension with id |extension_id|.
   bool ReadExtensionPrefList(const std::string& extension_id,
                              const std::string& pref_key,
-                             const ListValue** out_value);
+                             const base::ListValue** out_value);
 
   // Interprets the list pref, |pref_key| in |extension_id|'s preferences, as a
   // URLPatternSet. The |valid_schemes| specify how to parse the URLPatterns.
   bool ReadExtensionPrefURLPatternSet(const std::string& extension_id,
                                       const std::string& pref_key,
                                       URLPatternSet* result,
                                       int valid_schemes);
 
   // Converts |new_value| to a list of strings and sets the |pref_key| pref
   // belonging to |extension_id|.
   void SetExtensionPrefURLPatternSet(const std::string& extension_id,
                                      const std::string& pref_key,
                                      const URLPatternSet& new_value);
 
   // Returns a dictionary for extension |id|'s prefs or NULL if it doesn't
   // exist.
-  const DictionaryValue* GetExtensionPref(const std::string& id) const;
+  const base::DictionaryValue* GetExtensionPref(const std::string& id) const;
 
   // Returns the dictionary of preferences controlled by the specified extension
   // or creates a new one. All entries in the dictionary contain non-expanded
   // paths.
-  const DictionaryValue* GetExtensionControlledPrefs(
+  const base::DictionaryValue* GetExtensionControlledPrefs(
       const std::string& id,
       bool incognito) const;
 
   // Serializes the data and schedules a persistent save via the |PrefService|.
   // TODO(andybons): Fire an EXTENSION_PREF_CHANGED notification to be more
   // granular than PREF_CHANGED.
   void SavePrefs();
 
   // Checks if kPrefBlacklist is set to true in the DictionaryValue.
   // Return false if the value is false or kPrefBlacklist does not exist.
   // This is used to decide if an extension is blacklisted.
-  static bool IsBlacklistBitSet(DictionaryValue* ext);
+  static bool IsBlacklistBitSet(base::DictionaryValue* ext);
 
   // Fix missing preference entries in the extensions that are were introduced
   // in a later Chrome version.
   void FixMissingPrefs(const ExtensionIdSet& extension_ids);
 
   // Installs the persistent extension preferences into |prefs_|'s extension
   // pref store.
   void InitPrefStore();
 
   // Migrates the permissions data in the pref store.
@@ skipping 10 matching lines @@
 
   scoped_refptr<ExtensionContentSettingsStore> content_settings_store_;
 
   // The URLs of all of the toolstrips.
   URLList shelf_order_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefs);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_PREFS_H_