Update some uses of Value in chrome/browser to use the base:: namespace.

chrome/browser/managed_mode/managed_user_sync_service.cc

 // Copyright 2013 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.
 
 #include "chrome/browser/managed_mode/managed_user_sync_service.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 44 matching lines @@
   if (!chromeos_avatar.empty())
     specifics.mutable_managed_user()->set_chromeos_avatar(chromeos_avatar);
   if (!master_key.empty())
     specifics.mutable_managed_user()->set_master_key(master_key);
   if (acknowledged)
     specifics.mutable_managed_user()->set_acknowledged(true);
   return SyncData::CreateLocalData(id, name, specifics);
 }
 
 SyncData CreateSyncDataFromDictionaryEntry(
-    const DictionaryValue::Iterator& it) {
-  const DictionaryValue* dict = NULL;
+    const base::DictionaryValue::Iterator& it) {
+  const base::DictionaryValue* dict = NULL;
   bool success = it.value().GetAsDictionary(&dict);
   DCHECK(success);
   bool acknowledged = false;
   dict->GetBoolean(ManagedUserSyncService::kAcknowledged, &acknowledged);
   std::string name;
   dict->GetString(ManagedUserSyncService::kName, &name);
   DCHECK(!name.empty());
   std::string master_key;
   dict->GetString(ManagedUserSyncService::kMasterKey, &master_key);
   std::string chrome_avatar;
@@ skipping 73 matching lines @@
 void ManagedUserSyncService::RemoveObserver(
     ManagedUserSyncServiceObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void ManagedUserSyncService::AddManagedUser(const std::string& id,
                                             const std::string& name,
                                             const std::string& master_key,
                                             int avatar_index) {
   DictionaryPrefUpdate update(prefs_, prefs::kManagedUsers);
-  DictionaryValue* dict = update.Get();
-  DictionaryValue* value = new DictionaryValue;
+  base::DictionaryValue* dict = update.Get();
+  base::DictionaryValue* value = new base::DictionaryValue;
   value->SetString(kName, name);
   value->SetString(kMasterKey, master_key);
   std::string chrome_avatar;
   std::string chromeos_avatar;
 #if defined(OS_CHROMEOS)
   chromeos_avatar = BuildAvatarString(avatar_index);
 #else
   chrome_avatar = BuildAvatarString(avatar_index);
 #endif
   value->SetString(kChromeAvatar, chrome_avatar);
@@ skipping 27 matching lines @@
   SyncChangeList change_list;
   change_list.push_back(SyncChange(
       FROM_HERE,
       SyncChange::ACTION_DELETE,
       SyncData::CreateLocalDelete(id, MANAGED_USERS)));
   SyncError sync_error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
   DCHECK(!sync_error.IsSet());
 }
 
-const DictionaryValue* ManagedUserSyncService::GetManagedUsers() {
+const base::DictionaryValue* ManagedUserSyncService::GetManagedUsers() {
   DCHECK(sync_processor_);
   return prefs_->GetDictionary(prefs::kManagedUsers);
 }
 
 bool ManagedUserSyncService::UpdateManagedUserAvatarIfNeeded(
     const std::string& id,
     int avatar_index) {
   DictionaryPrefUpdate update(prefs_, prefs::kManagedUsers);
-  DictionaryValue* dict = update.Get();
+  base::DictionaryValue* dict = update.Get();
   DCHECK(dict->HasKey(id));
-  DictionaryValue* value = NULL;
+  base::DictionaryValue* value = NULL;
   bool success = dict->GetDictionaryWithoutPathExpansion(id, &value);
   DCHECK(success);
 
   bool acknowledged = false;
   value->GetBoolean(ManagedUserSyncService::kAcknowledged, &acknowledged);
   std::string name;
   value->GetString(ManagedUserSyncService::kName, &name);
   std::string master_key;
   value->GetString(ManagedUserSyncService::kMasterKey, &master_key);
   std::string chromeos_avatar;
@@ skipping 62 matching lines @@
     scoped_ptr<SyncChangeProcessor> sync_processor,
     scoped_ptr<SyncErrorFactory> error_handler) {
   DCHECK_EQ(MANAGED_USERS, type);
   sync_processor_ = sync_processor.Pass();
   error_handler_ = error_handler.Pass();
 
   SyncChangeList change_list;
   SyncMergeResult result(MANAGED_USERS);
 
   DictionaryPrefUpdate update(prefs_, prefs::kManagedUsers);
-  DictionaryValue* dict = update.Get();
+  base::DictionaryValue* dict = update.Get();
   result.set_num_items_before_association(dict->size());
   std::set<std::string> seen_ids;
   int num_items_added = 0;
   int num_items_modified = 0;
   for (SyncDataList::const_iterator it = initial_sync_data.begin();
        it != initial_sync_data.end(); ++it) {
     DCHECK_EQ(MANAGED_USERS, it->GetDataType());
     const ManagedUserSpecifics& managed_user =
         it->GetSpecifics().managed_user();
-    DictionaryValue* value = new DictionaryValue();
+    base::DictionaryValue* value = new base::DictionaryValue();
     value->SetString(kName, managed_user.name());
     value->SetBoolean(kAcknowledged, managed_user.acknowledged());
     value->SetString(kMasterKey, managed_user.master_key());
     value->SetString(kChromeAvatar, managed_user.chrome_avatar());
     value->SetString(kChromeOsAvatar, managed_user.chromeos_avatar());
     if (dict->HasKey(managed_user.id()))
       num_items_modified++;
     else
       num_items_added++;
     dict->SetWithoutPathExpansion(managed_user.id(), value);
     seen_ids.insert(managed_user.id());
   }
 
-  for (DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
+  for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     if (seen_ids.find(it.key()) != seen_ids.end())
       continue;
 
     change_list.push_back(SyncChange(FROM_HERE, SyncChange::ACTION_ADD,
                                      CreateSyncDataFromDictionaryEntry(it)));
   }
   result.set_error(sync_processor_->ProcessSyncChanges(FROM_HERE, change_list));
 
   result.set_num_items_modified(num_items_modified);
   result.set_num_items_added(num_items_added);
@@ skipping 10 matching lines @@
   // resetting the |sync_processor_|.
   NotifyManagedUsersSyncingStopped();
   sync_processor_.reset();
   error_handler_.reset();
 }
 
 SyncDataList ManagedUserSyncService::GetAllSyncData(
     ModelType type) const {
   SyncDataList data;
   DictionaryPrefUpdate update(prefs_, prefs::kManagedUsers);
-  DictionaryValue* dict = update.Get();
-  for (DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance())
+  base::DictionaryValue* dict = update.Get();
+  for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance())
     data.push_back(CreateSyncDataFromDictionaryEntry(it));
 
   return data;
 }
 
 SyncError ManagedUserSyncService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const SyncChangeList& change_list) {
   SyncError error;
   DictionaryPrefUpdate update(prefs_, prefs::kManagedUsers);
-  DictionaryValue* dict = update.Get();
+  base::DictionaryValue* dict = update.Get();
   for (SyncChangeList::const_iterator it = change_list.begin();
        it != change_list.end(); ++it) {
     SyncData data = it->sync_data();
     DCHECK_EQ(MANAGED_USERS, data.GetDataType());
     const ManagedUserSpecifics& managed_user =
         data.GetSpecifics().managed_user();
     switch (it->change_type()) {
       case SyncChange::ACTION_ADD:
       case SyncChange::ACTION_UPDATE: {
         // Every item we get from the server should be acknowledged.
         DCHECK(managed_user.acknowledged());
-        const DictionaryValue* old_value = NULL;
+        const base::DictionaryValue* old_value = NULL;
         dict->GetDictionaryWithoutPathExpansion(managed_user.id(), &old_value);
 
         // For an update action, the managed user should already exist, for an
         // add action, it should not.
         DCHECK_EQ(
             old_value ? SyncChange::ACTION_UPDATE : SyncChange::ACTION_ADD,
             it->change_type());
 
         // If the managed user switched from unacknowledged to acknowledged,
         // we might need to continue with a registration.
         if (old_value && !old_value->HasKey(kAcknowledged))
           NotifyManagedUserAcknowledged(managed_user.id());
 
-        DictionaryValue* value = new DictionaryValue;
+        base::DictionaryValue* value = new base::DictionaryValue;
         value->SetString(kName, managed_user.name());
         value->SetBoolean(kAcknowledged, managed_user.acknowledged());
         value->SetString(kMasterKey, managed_user.master_key());
         value->SetString(kChromeAvatar, managed_user.chrome_avatar());
         value->SetString(kChromeOsAvatar, managed_user.chromeos_avatar());
         dict->SetWithoutPathExpansion(managed_user.id(), value);
         break;
       }
       case SyncChange::ACTION_DELETE: {
         DCHECK(dict->HasKey(managed_user.id())) << managed_user.id();
@@ skipping 22 matching lines @@
   FOR_EACH_OBSERVER(ManagedUserSyncServiceObserver, observers_,
                     OnManagedUserAcknowledged(managed_user_id));
 }
 
 void ManagedUserSyncService::NotifyManagedUsersSyncingStopped() {
   FOR_EACH_OBSERVER(ManagedUserSyncServiceObserver, observers_,
                     OnManagedUsersSyncingStopped());
 }
 
 void ManagedUserSyncService::DispatchCallbacks() {
-  const DictionaryValue* managed_users =
+  const base::DictionaryValue* managed_users =
       prefs_->GetDictionary(prefs::kManagedUsers);
   for (std::vector<ManagedUsersCallback>::iterator it = callbacks_.begin();
        it != callbacks_.end(); ++it) {
     it->Run(managed_users);
   }
   callbacks_.clear();
 }