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

chrome/browser/devtools/devtools_file_helper.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/devtools/devtools_file_helper.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 167 matching lines @@
   std::string root_url = fileapi::GetIsolatedFileSystemRootURIString(
       origin,
       file_system_id,
       registered_name);
   return DevToolsFileHelper::FileSystem(file_system_name,
                                         root_url,
                                         file_system_path);
 }
 
 set<std::string> GetAddedFileSystemPaths(Profile* profile) {
-  const DictionaryValue* file_systems_paths_value =
+  const base::DictionaryValue* file_systems_paths_value =
       profile->GetPrefs()->GetDictionary(prefs::kDevToolsFileSystemPaths);
   set<std::string> result;
-  for (DictionaryValue::Iterator it(*file_systems_paths_value); !it.IsAtEnd();
-       it.Advance()) {
+  for (base::DictionaryValue::Iterator it(*file_systems_paths_value);
+       !it.IsAtEnd(); it.Advance()) {
     result.insert(it.key());
   }
   return result;
 }
 
 }  // namespace
 
 DevToolsFileHelper::FileSystem::FileSystem() {
 }
 
@@ skipping 19 matching lines @@
                               const std::string& content,
                               bool save_as,
                               const SaveCallback& saveCallback,
                               const SaveCallback& cancelCallback) {
   PathsMap::iterator it = saved_files_.find(url);
   if (it != saved_files_.end() && !save_as) {
     SaveAsFileSelected(url, content, saveCallback, it->second);
     return;
   }
 
-  const DictionaryValue* file_map =
+  const base::DictionaryValue* file_map =
       profile_->GetPrefs()->GetDictionary(prefs::kDevToolsEditedFiles);
   base::FilePath initial_path;
 
-  const Value* path_value;
+  const base::Value* path_value;
   if (file_map->Get(base::MD5String(url), &path_value))
     base::GetValueAsFilePath(*path_value, &initial_path);
 
   if (initial_path.empty()) {
     GURL gurl(url);
     std::string suggested_file_name = gurl.is_valid() ?
         gurl.ExtractFileName() : url;
 
     if (suggested_file_name.length() > 64)
       suggested_file_name = suggested_file_name.substr(0, 64);
@@ skipping 35 matching lines @@
 
 void DevToolsFileHelper::SaveAsFileSelected(const std::string& url,
                                             const std::string& content,
                                             const SaveCallback& callback,
                                             const base::FilePath& path) {
   *g_last_save_path.Pointer() = path;
   saved_files_[url] = path;
 
   DictionaryPrefUpdate update(profile_->GetPrefs(),
                               prefs::kDevToolsEditedFiles);
-  DictionaryValue* files_map = update.Get();
+  base::DictionaryValue* files_map = update.Get();
   files_map->SetWithoutPathExpansion(base::MD5String(url),
                                      base::CreateFilePathValue(path));
   callback.Run();
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           Bind(&WriteToFile, path, content));
 }
 
 void DevToolsFileHelper::SaveAsFileSelectionCanceled(
     const SaveCallback& callback) {
   callback.Run();
@@ skipping 33 matching lines @@
   for (; it != mount_points.end(); ++it)
     InnerAddFileSystem(callback, show_info_bar_callback, it->path);
 }
 
 void DevToolsFileHelper::InnerAddFileSystem(
     const AddFileSystemCallback& callback,
     const ShowInfoBarCallback& show_info_bar_callback,
     const base::FilePath& path) {
   std::string file_system_path = path.AsUTF8Unsafe();
 
-  const DictionaryValue* file_systems_paths_value =
+  const base::DictionaryValue* file_systems_paths_value =
       profile_->GetPrefs()->GetDictionary(prefs::kDevToolsFileSystemPaths);
   if (file_systems_paths_value->HasKey(file_system_path)) {
     callback.Run(FileSystem());
     return;
   }
 
   std::string path_display_name = path.AsEndingWithSeparator().AsUTF8Unsafe();
   base::string16 message = l10n_util::GetStringFUTF16(
       IDS_DEV_TOOLS_CONFIRM_ADD_FILE_SYSTEM_MESSAGE,
       UTF8ToUTF16(path_display_name));
@@ skipping 13 matching lines @@
     return;
   }
   std::string registered_name;
   std::string file_system_id = RegisterFileSystem(web_contents_,
                                                   path,
                                                   &registered_name);
   std::string file_system_path = path.AsUTF8Unsafe();
 
   DictionaryPrefUpdate update(profile_->GetPrefs(),
                               prefs::kDevToolsFileSystemPaths);
-  DictionaryValue* file_systems_paths_value = update.Get();
-  file_systems_paths_value->SetWithoutPathExpansion(file_system_path,
-                                                    Value::CreateNullValue());
+  base::DictionaryValue* file_systems_paths_value = update.Get();
+  file_systems_paths_value->SetWithoutPathExpansion(
+      file_system_path, base::Value::CreateNullValue());
 
   FileSystem filesystem = CreateFileSystemStruct(web_contents_,
                                                  file_system_id,
                                                  registered_name,
                                                  file_system_path);
   callback.Run(filesystem);
 }
 
 void DevToolsFileHelper::RequestFileSystems(
     const RequestFileSystemsCallback& callback) {
@@ skipping 17 matching lines @@
   callback.Run(file_systems);
 }
 
 void DevToolsFileHelper::RemoveFileSystem(const std::string& file_system_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::FilePath path = base::FilePath::FromUTF8Unsafe(file_system_path);
   isolated_context()->RevokeFileSystemByPath(path);
 
   DictionaryPrefUpdate update(profile_->GetPrefs(),
                               prefs::kDevToolsFileSystemPaths);
-  DictionaryValue* file_systems_paths_value = update.Get();
+  base::DictionaryValue* file_systems_paths_value = update.Get();
   file_systems_paths_value->RemoveWithoutPathExpansion(file_system_path, NULL);
 }
 
 bool DevToolsFileHelper::IsFileSystemAdded(
     const std::string& file_system_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   set<std::string> file_system_paths = GetAddedFileSystemPaths(profile_);
   return file_system_paths.find(file_system_path) != file_system_paths.end();
 }