Move base/values.h into the base namespace.

chrome/browser/prefs/pref_service.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.
 
 // This provides a way to access the application's current preferences.
 
 #ifndef CHROME_BROWSER_PREFS_PREF_SERVICE_H_
 #define CHROME_BROWSER_PREFS_PREF_SERVICE_H_
 #pragma once
 
@@ skipping 38 matching lines @@
   // A helper class to store all the information associated with a preference.
   class Preference {
    public:
 
     // The type of the preference is determined by the type with which it is
     // registered. This type needs to be a boolean, integer, double, string,
     // dictionary (a branch), or list.  You shouldn't need to construct this on
     // your own; use the PrefService::Register*Pref methods instead.
     Preference(const PrefService* service,
                const char* name,
-               Value::ValueType type);
+               base::Value::ValueType type);
     ~Preference() {}
 
     // Returns the name of the Preference (i.e., the key, e.g.,
     // browser.window_placement).
     const std::string name() const { return name_; }
 
     // Returns the registered type of the preference.
-    Value::ValueType GetType() const;
+    base::Value::ValueType GetType() const;
 
     // Returns the value of the Preference, falling back to the registered
     // default value if no other has been set.
-    const Value* GetValue() const;
+    const base::Value* GetValue() const;
 
     // Returns true if the Preference is managed, i.e. set by an admin policy.
     // Since managed prefs have the highest priority, this also indicates
     // whether the pref is actually being controlled by the policy setting.
     bool IsManaged() const;
 
     // Returns true if the Preference has a value set by an extension, even if
     // that value is being overridden by a higher-priority source.
     bool HasExtensionSetting() const;
 
@@ skipping 26 matching lines @@
 
    private:
     friend class PrefService;
 
     PrefValueStore* pref_value_store() const {
       return pref_service_->pref_value_store_.get();
     }
 
     std::string name_;
 
-    Value::ValueType type_;
+    base::Value::ValueType type_;
 
     // Reference to the PrefService in which this pref was created.
     const PrefService* pref_service_;
 
     DISALLOW_COPY_AND_ASSIGN(Preference);
   };
 
   // Factory method that creates a new instance of a PrefService with the
   // applicable PrefStores. The |pref_filename| points to the user preference
   // file. This is the usual way to create a new PrefService.
@@ skipping 42 matching lines @@
   // TODO(zea): split local state and profile prefs into their own subclasses.
   // ---------- Local state prefs  ----------
   void RegisterBooleanPref(const char* path, bool default_value);
   void RegisterIntegerPref(const char* path, int default_value);
   void RegisterDoublePref(const char* path, double default_value);
   void RegisterStringPref(const char* path, const std::string& default_value);
   void RegisterFilePathPref(const char* path, const FilePath& default_value);
   void RegisterListPref(const char* path);
   void RegisterDictionaryPref(const char* path);
   // These take ownership of the default_value:
-  void RegisterListPref(const char* path, ListValue* default_value);
-  void RegisterDictionaryPref(const char* path, DictionaryValue* default_value);
+  void RegisterListPref(const char* path,
+                        base::ListValue* default_value);
+  void RegisterDictionaryPref(const char* path,
+                              base::DictionaryValue* default_value);
   // These variants use a default value from the locale dll instead.
   void RegisterLocalizedBooleanPref(const char* path,
                                     int locale_default_message_id);
   void RegisterLocalizedIntegerPref(const char* path,
                                     int locale_default_message_id);
   void RegisterLocalizedDoublePref(const char* path,
                                    int locale_default_message_id);
   void RegisterLocalizedStringPref(const char* path,
                                    int locale_default_message_id);
   void RegisterInt64Pref(const char* path, int64 default_value);
@@ skipping 13 matching lines @@
   void RegisterStringPref(const char* path,
                           const std::string& default_value,
                           PrefSyncStatus sync_status);
   void RegisterFilePathPref(const char* path,
                             const FilePath& default_value,
                             PrefSyncStatus sync_status);
   void RegisterListPref(const char* path, PrefSyncStatus sync_status);
   void RegisterDictionaryPref(const char* path, PrefSyncStatus sync_status);
   // These take ownership of the default_value:
   void RegisterListPref(const char* path,
-                        ListValue* default_value,
+                        base::ListValue* default_value,
                         PrefSyncStatus sync_status);
   void RegisterDictionaryPref(const char* path,
-                              DictionaryValue* default_value,
+                              base::DictionaryValue* default_value,
                               PrefSyncStatus sync_status);
   // These variants use a default value from the locale dll instead.
   void RegisterLocalizedBooleanPref(const char* path,
                                     int locale_default_message_id,
                                     PrefSyncStatus sync_status);
   void RegisterLocalizedIntegerPref(const char* path,
                                     int locale_default_message_id,
                                     PrefSyncStatus sync_status);
   void RegisterLocalizedDoublePref(const char* path,
                                    int locale_default_message_id,
@@ skipping 10 matching lines @@
   // value (set when the pref was registered) will be returned.
   bool GetBoolean(const char* path) const;
   int GetInteger(const char* path) const;
   double GetDouble(const char* path) const;
   std::string GetString(const char* path) const;
   FilePath GetFilePath(const char* path) const;
 
   // Returns the branch if it exists, or the registered default value otherwise.
   // Note that |path| must point to a registered preference. In that case, these
   // functions will never return NULL.
-  const DictionaryValue* GetDictionary(const char* path) const;
-  const ListValue* GetList(const char* path) const;
+  const base::DictionaryValue* GetDictionary(const char* path) const;
+  const base::ListValue* GetList(const char* path) const;
 
   // Removes a user pref and restores the pref to its default value.
   void ClearPref(const char* path);
 
   // If the path is valid (i.e., registered), update the pref value in the user
   // prefs.
   // To set the value of dictionary or list values in the pref tree use
   // Set(), but to modify the value of a dictionary or list use either
   // ListPrefUpdate or DictionaryPrefUpdate from scoped_user_pref_update.h.
-  void Set(const char* path, const Value& value);
+  void Set(const char* path, const base::Value& value);
   void SetBoolean(const char* path, bool value);
   void SetInteger(const char* path, int value);
   void SetDouble(const char* path, double value);
   void SetString(const char* path, const std::string& value);
   void SetFilePath(const char* path, const FilePath& value);
 
   // Int64 helper methods that actually store the given value as a string.
   // Note that if obtaining the named value via GetDictionary or GetList, the
   // Value type will be TYPE_STRING.
   void SetInt64(const char* path, int64 value);
   int64 GetInt64(const char* path) const;
 
   // Returns true if a value has been set for the specified path.
   // NOTE: this is NOT the same as FindPreference. In particular
   // FindPreference returns whether RegisterXXX has been invoked, where as
   // this checks if a value exists for the path.
   bool HasPrefPath(const char* path) const;
 
   // Returns a dictionary with effective preference values. The ownership
   // is passed to the caller.
-  DictionaryValue* GetPreferenceValues() const;
+  base::DictionaryValue* GetPreferenceValues() const;
 
   // A helper method to quickly look up a preference.  Returns NULL if the
   // preference is not registered.
   const Preference* FindPreference(const char* pref_name) const;
 
   bool ReadOnly() const;
 
   // SyncableService getter.
   // TODO(zea): Have PrefService implement SyncableService directly.
   SyncableService* GetSyncableService();
@@ skipping 54 matching lines @@
   // directly but rather use a PrefChangeRegistrar to make sure the observer
   // gets cleaned up properly.
   virtual void AddPrefObserver(const char* path, NotificationObserver* obs);
   virtual void RemovePrefObserver(const char* path, NotificationObserver* obs);
 
   // Registers a new preference at |path|. The |default_value| must not be
   // NULL as it determines the preference value's type.
   // RegisterPreference must not be called twice for the same path.
   // This method takes ownership of |default_value|.
   void RegisterPreference(const char* path,
-                          Value* default_value,
+                          base::Value* default_value,
                           PrefSyncStatus sync_status);
 
   // Sets the value for this pref path in the user pref store and informs the
   // PrefNotifier of the change.
-  void SetUserPrefValue(const char* path, Value* new_value);
+  void SetUserPrefValue(const char* path, base::Value* new_value);
 
   // Load preferences from storage, attempting to diagnose and handle errors.
   // This should only be called from the constructor.
   void InitFromStorage(bool async);
 
   // Used to set the value of dictionary or list values in the user pref store.
   // This will create a dictionary or list if one does not exist in the user
   // pref store. This method returns NULL only if you're requesting an
   // unregistered pref or a non-dict/non-list pref.
   // |type| may only be Values::TYPE_DICTIONARY or Values::TYPE_LIST and
   // |path| must point to a registered preference of type |type|.
   // Ownership of the returned value remains at the user pref store.
-  Value* GetMutableUserPref(const char* path, Value::ValueType type);
+  base::Value* GetMutableUserPref(const char* path,
+                                  base::Value::ValueType type);
 
   // The PrefValueStore provides prioritized preference values. It is created
   // and owned by this PrefService. Subclasses may access it for unit testing.
   scoped_ptr<PrefValueStore> pref_value_store_;
 
   // Pref Stores and profile that we passed to the PrefValueStore.
   scoped_refptr<PersistentPrefStore> user_pref_store_;
   scoped_refptr<DefaultPrefStore> default_store_;
 
   // Local cache of registered Preference objects. The default_store_
   // is authoritative with respect to what the types and default values
   // of registered preferences are.
   mutable PreferenceSet prefs_;
 
   // The model associator that maintains the links with the sync db.
   scoped_ptr<PrefModelAssociator> pref_sync_associator_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefService);
 };
 
 #endif  // CHROME_BROWSER_PREFS_PREF_SERVICE_H_