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

chrome/browser/media_galleries/media_galleries_preferences.cc

 // Copyright (c) 2012 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/media_galleries/media_galleries_preferences.h"
 
 #include "base/base_paths_posix.h"
 #include "base/callback.h"
 #include "base/i18n/time_formatting.h"
 #include "base/path_service.h"
@@ skipping 76 matching lines @@
     if (extensions::PermissionsData::HasAPIPermission(
             *i, extensions::APIPermission::kMediaGalleries) ||
         extensions::PermissionsData::HasAPIPermission(
             *i, extensions::APIPermission::kMediaGalleriesPrivate)) {
       count++;
     }
   }
   return count;
 }
 
-bool GetPrefId(const DictionaryValue& dict, MediaGalleryPrefId* value) {
+bool GetPrefId(const base::DictionaryValue& dict, MediaGalleryPrefId* value) {
   std::string string_id;
   if (!dict.GetString(kMediaGalleriesPrefIdKey, &string_id) ||
       !base::StringToUint64(string_id, value)) {
     return false;
   }
 
   return true;
 }
 
-bool GetType(const DictionaryValue& dict, MediaGalleryPrefInfo::Type* type) {
+bool GetType(const base::DictionaryValue& dict,
+             MediaGalleryPrefInfo::Type* type) {
   std::string string_type;
   if (!dict.GetString(kMediaGalleriesTypeKey, &string_type))
     return false;
 
   if (string_type == kMediaGalleriesTypeAutoDetectedValue) {
     *type = MediaGalleryPrefInfo::kAutoDetected;
     return true;
   }
   if (string_type == kMediaGalleriesTypeUserAddedValue) {
     *type = MediaGalleryPrefInfo::kUserAdded;
     return true;
   }
   if (string_type == kMediaGalleriesTypeBlackListedValue) {
     *type = MediaGalleryPrefInfo::kBlackListed;
     return true;
   }
 
   return false;
 }
 
 bool PopulateGalleryPrefInfoFromDictionary(
-    const DictionaryValue& dict, MediaGalleryPrefInfo* out_gallery_info) {
+    const base::DictionaryValue& dict, MediaGalleryPrefInfo* out_gallery_info) {
   MediaGalleryPrefId pref_id;
   base::string16 display_name;
   std::string device_id;
   base::FilePath::StringType path;
   MediaGalleryPrefInfo::Type type = MediaGalleryPrefInfo::kAutoDetected;
   base::string16 volume_label;
   base::string16 vendor_name;
   base::string16 model_name;
   double total_size_in_bytes = 0.0;
   double last_attach_time = 0.0;
@@ skipping 28 matching lines @@
   out_gallery_info->model_name = model_name;
   out_gallery_info->total_size_in_bytes = total_size_in_bytes;
   out_gallery_info->last_attach_time =
       base::Time::FromInternalValue(last_attach_time);
   out_gallery_info->volume_metadata_valid = volume_metadata_valid;
   out_gallery_info->prefs_version = prefs_version;
 
   return true;
 }
 
-DictionaryValue* CreateGalleryPrefInfoDictionary(
+base::DictionaryValue* CreateGalleryPrefInfoDictionary(
     const MediaGalleryPrefInfo& gallery) {
-  DictionaryValue* dict = new DictionaryValue();
+  base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString(kMediaGalleriesPrefIdKey,
                   base::Uint64ToString(gallery.pref_id));
   if (!gallery.volume_metadata_valid)
     dict->SetString(kMediaGalleriesDisplayNameKey, gallery.display_name);
   dict->SetString(kMediaGalleriesDeviceIdKey, gallery.device_id);
   dict->SetString(kMediaGalleriesPathKey, gallery.path.value());
 
   const char* type = NULL;
   switch (gallery.type) {
     case MediaGalleryPrefInfo::kAutoDetected:
@@ skipping 35 matching lines @@
 bool HasAutoDetectedGalleryPermission(const extensions::Extension& extension) {
   extensions::MediaGalleriesPermission::CheckParam param(
       extensions::MediaGalleriesPermission::kAllAutoDetectedPermission);
   return extensions::PermissionsData::CheckAPIPermissionWithParam(
       &extension, extensions::APIPermission::kMediaGalleries, &param);
 }
 
 // Retrieves the MediaGalleryPermission from the given dictionary; DCHECKs on
 // failure.
 bool GetMediaGalleryPermissionFromDictionary(
-    const DictionaryValue* dict,
+    const base::DictionaryValue* dict,
     MediaGalleryPermission* out_permission) {
   std::string string_id;
   if (dict->GetString(kMediaGalleryIdKey, &string_id) &&
       base::StringToUint64(string_id, &out_permission->pref_id) &&
       dict->GetBoolean(kMediaGalleryHasPermissionKey,
                        &out_permission->has_permission)) {
     return true;
   }
   NOTREACHED();
   return false;
@@ skipping 257 matching lines @@
 
 bool MediaGalleriesPreferences::UpdateDeviceIDForSingletonType(
     const std::string& device_id) {
   StorageInfo::Type singleton_type;
   if (!StorageInfo::CrackDeviceId(device_id, &singleton_type, NULL))
     return false;
 
   PrefService* prefs = profile_->GetPrefs();
   scoped_ptr<ListPrefUpdate> update(new ListPrefUpdate(
       prefs, prefs::kMediaGalleriesRememberedGalleries));
-  ListValue* list = update->Get();
-  for (ListValue::iterator iter = list->begin(); iter != list->end(); ++iter) {
+  base::ListValue* list = update->Get();
+  for (base::ListValue::iterator iter = list->begin();
+       iter != list->end(); ++iter) {
     // All of these calls should succeed, but preferences file can be corrupt.
-    DictionaryValue* dict;
+    base::DictionaryValue* dict;
     if (!(*iter)->GetAsDictionary(&dict))
       continue;
     std::string this_device_id;
     if (!dict->GetString(kMediaGalleriesDeviceIdKey, &this_device_id))
       continue;
     if (this_device_id == device_id)
       return true;  // No update is necessary.
     StorageInfo::Type device_type;
     if (!StorageInfo::CrackDeviceId(this_device_id, &device_type, NULL))
       continue;
@@ skipping 40 matching lines @@
   }
 
   OnInitializationCallbackReturned();
 }
 
 void MediaGalleriesPreferences::InitFromPrefs() {
   known_galleries_.clear();
   device_map_.clear();
 
   PrefService* prefs = profile_->GetPrefs();
-  const ListValue* list = prefs->GetList(
+  const base::ListValue* list = prefs->GetList(
       prefs::kMediaGalleriesRememberedGalleries);
   if (list) {
-    for (ListValue::const_iterator it = list->begin();
+    for (base::ListValue::const_iterator it = list->begin();
          it != list->end(); ++it) {
-      const DictionaryValue* dict = NULL;
+      const base::DictionaryValue* dict = NULL;
       if (!(*it)->GetAsDictionary(&dict))
         continue;
 
       MediaGalleryPrefInfo gallery_info;
       if (!PopulateGalleryPrefInfoFromDictionary(*dict, &gallery_info))
         continue;
 
       known_galleries_[gallery_info.pref_id] = gallery_info;
       device_map_[gallery_info.device_id].insert(gallery_info.pref_id);
     }
@@ skipping 156 matching lines @@
          (existing.total_size_in_bytes != total_size_in_bytes) ||
          (existing.last_attach_time != last_attach_time));
 
     if (!update_gallery_name && !update_gallery_type &&
         !update_gallery_metadata)
       return *pref_id_it;
 
     PrefService* prefs = profile_->GetPrefs();
     scoped_ptr<ListPrefUpdate> update(
         new ListPrefUpdate(prefs, prefs::kMediaGalleriesRememberedGalleries));
-    ListValue* list = update->Get();
+    base::ListValue* list = update->Get();
 
-    for (ListValue::const_iterator list_iter = list->begin();
+    for (base::ListValue::const_iterator list_iter = list->begin();
          list_iter != list->end();
          ++list_iter) {
-      DictionaryValue* dict;
+      base::DictionaryValue* dict;
       MediaGalleryPrefId iter_id;
       if ((*list_iter)->GetAsDictionary(&dict) &&
           GetPrefId(*dict, &iter_id) &&
           *pref_id_it == iter_id) {
         if (update_gallery_type) {
           dict->SetString(kMediaGalleriesTypeKey,
                           kMediaGalleriesTypeAutoDetectedValue);
         }
         if (update_gallery_name)
           dict->SetString(kMediaGalleriesDisplayNameKey, display_name);
@@ skipping 39 matching lines @@
     gallery_info.vendor_name = vendor_name;
     gallery_info.model_name = model_name;
     gallery_info.total_size_in_bytes = total_size_in_bytes;
     gallery_info.last_attach_time = last_attach_time;
   }
   gallery_info.volume_metadata_valid = volume_metadata_valid;
   gallery_info.prefs_version = prefs_version;
 
   {
     ListPrefUpdate update(prefs, prefs::kMediaGalleriesRememberedGalleries);
-    ListValue* list = update.Get();
+    base::ListValue* list = update.Get();
     list->Append(CreateGalleryPrefInfoDictionary(gallery_info));
   }
   InitFromPrefs();
   FOR_EACH_OBSERVER(GalleryChangeObserver,
                     gallery_change_observers_,
                     OnGalleryAdded(this, gallery_info.pref_id));
 
   return gallery_info.pref_id;
 }
 
@@ skipping 16 matching lines @@
                             gallery_info.last_attach_time,
                             gallery_info.volume_metadata_valid,
                             gallery_info.prefs_version);
 }
 
 void MediaGalleriesPreferences::ForgetGalleryById(MediaGalleryPrefId pref_id) {
   DCHECK(IsInitialized());
   PrefService* prefs = profile_->GetPrefs();
   scoped_ptr<ListPrefUpdate> update(new ListPrefUpdate(
       prefs, prefs::kMediaGalleriesRememberedGalleries));
-  ListValue* list = update->Get();
+  base::ListValue* list = update->Get();
 
   if (!ContainsKey(known_galleries_, pref_id))
     return;
 
-  for (ListValue::iterator iter = list->begin(); iter != list->end(); ++iter) {
-    DictionaryValue* dict;
+  for (base::ListValue::iterator iter = list->begin();
+       iter != list->end(); ++iter) {
+    base::DictionaryValue* dict;
     MediaGalleryPrefId iter_id;
     if ((*iter)->GetAsDictionary(&dict) && GetPrefId(*dict, &iter_id) &&
         pref_id == iter_id) {
       RemoveGalleryPermissionsFromPrefs(pref_id);
       MediaGalleryPrefInfo::Type type;
       if (GetType(*dict, &type) &&
           type == MediaGalleryPrefInfo::kAutoDetected) {
         dict->SetString(kMediaGalleriesTypeKey,
                         kMediaGalleriesTypeBlackListedValue);
       } else {
@@ skipping 108 matching lines @@
 }
 
 bool MediaGalleriesPreferences::SetGalleryPermissionInPrefs(
     const std::string& extension_id,
     MediaGalleryPrefId gallery_id,
     bool has_access) {
   DCHECK(IsInitialized());
   ExtensionPrefs::ScopedListUpdate update(GetExtensionPrefs(),
                                           extension_id,
                                           kMediaGalleriesPermissions);
-  ListValue* permissions = update.Get();
+  base::ListValue* permissions = update.Get();
   if (!permissions) {
     permissions = update.Create();
   } else {
     // If the gallery is already in the list, update the permission...
-    for (ListValue::iterator iter = permissions->begin();
+    for (base::ListValue::iterator iter = permissions->begin();
          iter != permissions->end(); ++iter) {
-      DictionaryValue* dict = NULL;
+      base::DictionaryValue* dict = NULL;
       if (!(*iter)->GetAsDictionary(&dict))
         continue;
       MediaGalleryPermission perm;
       if (!GetMediaGalleryPermissionFromDictionary(dict, &perm))
         continue;
       if (perm.pref_id == gallery_id) {
         if (has_access != perm.has_permission) {
           dict->SetBoolean(kMediaGalleryHasPermissionKey, has_access);
           return true;
         } else {
           return false;
         }
       }
     }
   }
   // ...Otherwise, add a new entry for the gallery.
-  DictionaryValue* dict = new DictionaryValue;
+  base::DictionaryValue* dict = new base::DictionaryValue;
   dict->SetString(kMediaGalleryIdKey, base::Uint64ToString(gallery_id));
   dict->SetBoolean(kMediaGalleryHasPermissionKey, has_access);
   permissions->Append(dict);
   return true;
 }
 
 bool MediaGalleriesPreferences::UnsetGalleryPermissionInPrefs(
     const std::string& extension_id,
     MediaGalleryPrefId gallery_id) {
   DCHECK(IsInitialized());
   ExtensionPrefs::ScopedListUpdate update(GetExtensionPrefs(),
                                           extension_id,
                                           kMediaGalleriesPermissions);
-  ListValue* permissions = update.Get();
+  base::ListValue* permissions = update.Get();
   if (!permissions)
     return false;
 
-  for (ListValue::iterator iter = permissions->begin();
+  for (base::ListValue::iterator iter = permissions->begin();
        iter != permissions->end(); ++iter) {
-    const DictionaryValue* dict = NULL;
+    const base::DictionaryValue* dict = NULL;
     if (!(*iter)->GetAsDictionary(&dict))
       continue;
     MediaGalleryPermission perm;
     if (!GetMediaGalleryPermissionFromDictionary(dict, &perm))
       continue;
     if (perm.pref_id == gallery_id) {
       permissions->Erase(iter, NULL);
       return true;
     }
   }
   return false;
 }
 
 std::vector<MediaGalleryPermission>
 MediaGalleriesPreferences::GetGalleryPermissionsFromPrefs(
     const std::string& extension_id) const {
   DCHECK(IsInitialized());
   std::vector<MediaGalleryPermission> result;
-  const ListValue* permissions;
+  const base::ListValue* permissions;
   if (!GetExtensionPrefs()->ReadPrefAsList(extension_id,
                                            kMediaGalleriesPermissions,
                                            &permissions)) {
     return result;
   }
 
-  for (ListValue::const_iterator iter = permissions->begin();
+  for (base::ListValue::const_iterator iter = permissions->begin();
        iter != permissions->end(); ++iter) {
-    DictionaryValue* dict = NULL;
+    base::DictionaryValue* dict = NULL;
     if (!(*iter)->GetAsDictionary(&dict))
       continue;
     MediaGalleryPermission perm;
     if (!GetMediaGalleryPermissionFromDictionary(dict, &perm))
       continue;
     result.push_back(perm);
   }
 
   return result;
 }
 
 void MediaGalleriesPreferences::RemoveGalleryPermissionsFromPrefs(
     MediaGalleryPrefId gallery_id) {
   DCHECK(IsInitialized());
   ExtensionPrefs* prefs = GetExtensionPrefs();
-  const DictionaryValue* extensions =
+  const base::DictionaryValue* extensions =
       prefs->pref_service()->GetDictionary(prefs::kExtensionsPref);
   if (!extensions)
     return;
 
-  for (DictionaryValue::Iterator iter(*extensions); !iter.IsAtEnd();
+  for (base::DictionaryValue::Iterator iter(*extensions); !iter.IsAtEnd();
        iter.Advance()) {
     if (!extensions::Extension::IdIsValid(iter.key())) {
       NOTREACHED();
       continue;
     }
     UnsetGalleryPermissionInPrefs(iter.key(), gallery_id);
   }
 }
 
 ExtensionPrefs* MediaGalleriesPreferences::GetExtensionPrefs() const {
   DCHECK(IsInitialized());
   if (extension_prefs_for_testing_)
     return extension_prefs_for_testing_;
   return extensions::ExtensionPrefs::Get(profile_);
 }
 
 void MediaGalleriesPreferences::SetExtensionPrefsForTesting(
     extensions::ExtensionPrefs* extension_prefs) {
   DCHECK(IsInitialized());
   extension_prefs_for_testing_ = extension_prefs;
 }