Move base/values.h into the base namespace.

chrome/browser/prefs/pref_model_associator.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_PREFS_PREF_MODEL_ASSOCIATOR_H_
 #define CHROME_BROWSER_PREFS_PREF_MODEL_ASSOCIATOR_H_
 #pragma once
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/threading/non_thread_safe.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/sync/api/syncable_service.h"
 #include "chrome/browser/sync/api/sync_data.h"
 
 namespace sync_pb {
 class PreferenceSpecifics;
 }
 
+namespace base {
 class Value;
+}
 
 // Contains all preference sync related logic.
 // TODO(sync): Merge this into PrefService once we separate the profile
 // PrefService from the local state PrefService.
 class PrefModelAssociator
     : public SyncableService,
       public base::NonThreadSafe {
  public:
   explicit PrefModelAssociator(PrefService* pref_service);
   virtual ~PrefModelAssociator();
@@ skipping 24 matching lines @@
 
   // Process a local preference change. This can trigger new SyncChanges being
   // sent to the syncer.
   virtual void ProcessPrefChange(const std::string& name);
 
   // Merges the value of local_pref into the supplied server_value and returns
   // the result (caller takes ownership). If there is a conflict, the server
   // value always takes precedence. Note that only certain preferences will
   // actually be merged, all others will return a copy of the server value. See
   // the method's implementation for details.
-  static Value* MergePreference(const PrefService::Preference& local_pref,
-                                const Value& server_value);
+  static base::Value* MergePreference(
+      const PrefService::Preference& local_pref,
+      const base::Value& server_value);
 
   // Fills |sync_data| with a sync representation of the preference data
   // provided.
   static bool CreatePrefSyncData(const std::string& name,
-                                 const Value& value,
+                                 const base::Value& value,
                                  SyncData* sync_data);
 
   // Extract preference value and name from sync specifics.
-  Value* ReadPreferenceSpecifics(
+  base::Value* ReadPreferenceSpecifics(
       const sync_pb::PreferenceSpecifics& specifics,
       std::string* name);
 
  protected:
   friend class ProfileSyncServicePreferenceTest;
 
   typedef std::map<std::string, SyncData> SyncDataMap;
 
   // For testing.
   PrefModelAssociator();
 
   // Create an association for a given preference. If |sync_pref| is valid,
   // signifying that sync has data for this preference, we reconcile their data
   // with ours and append a new UPDATE SyncChange to |sync_changes|. If
   // sync_pref is not set, we append an ADD SyncChange to |sync_changes| with
   // the current preference data.
   // Note: We do not modify the sync data for preferences that are either
   // controlled by policy (are not user modifiable) or have their default value
   // (are not user controlled).
   void InitPrefAndAssociate(const SyncData& sync_pref,
                             const std::string& pref_name,
                             SyncChangeList* sync_changes);
 
   // Perform any additional local operations that need to happen after a
   // preference has been updated.
   void SendUpdateNotificationsIfNecessary(const std::string& pref_name);
 
-  static Value* MergeListValues(const Value& from_value, const Value& to_value);
-  static Value* MergeDictionaryValues(const Value& from_value,
-                                      const Value& to_value);
+  static base::Value* MergeListValues(
+      const base::Value& from_value, const base::Value& to_value);
+  static base::Value* MergeDictionaryValues(const base::Value& from_value,
+                                            const base::Value& to_value);
 
   // Do we have an active association between the preferences and sync models?
   // Set when start syncing, reset in StopSyncing. While this is not set, we
   // ignore any local preference changes (when we start syncing we will look
   // up the most recent values anyways).
   bool models_associated_;
 
   // Whether we're currently processing changes from the syncer. While this is
   // true, we ignore any local preference changes, since we triggered them.
   bool processing_syncer_changes_;
@@ skipping 16 matching lines @@
   // The PrefService we are syncing to.
   PrefService* pref_service_;
 
   // Sync's SyncChange handler. We push all our changes through this.
   SyncChangeProcessor* sync_processor_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefModelAssociator);
 };
 
 #endif  // CHROME_BROWSER_PREFS_PREF_MODEL_ASSOCIATOR_H_