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

chrome/browser/devtools/devtools_window.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_window.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
@@ skipping 232 matching lines @@
 
 std::string SkColorToRGBAString(SkColor color) {
   // We avoid StringPrintf because it will use locale specific formatters for
   // the double (e.g. ',' instead of '.' in German).
   return "rgba(" + base::IntToString(SkColorGetR(color)) + "," +
       base::IntToString(SkColorGetG(color)) + "," +
       base::IntToString(SkColorGetB(color)) + "," +
       base::DoubleToString(SkColorGetA(color) / 255.0) + ")";
 }
 
-DictionaryValue* CreateFileSystemValue(
+base::DictionaryValue* CreateFileSystemValue(
     DevToolsFileHelper::FileSystem file_system) {
-  DictionaryValue* file_system_value = new DictionaryValue();
+  base::DictionaryValue* file_system_value = new base::DictionaryValue();
   file_system_value->SetString("fileSystemName", file_system.file_system_name);
   file_system_value->SetString("rootURL", file_system.root_url);
   file_system_value->SetString("fileSystemPath", file_system.file_system_path);
   return file_system_value;
 }
 
 }  // namespace
 
 const char DevToolsWindow::kDevToolsApp[] = "DevToolsApp";
 
@@ skipping 852 matching lines @@
   CHECK(web_contents_->GetURL().SchemeIs(chrome::kChromeDevToolsScheme));
   file_helper_->AddFileSystem(
       base::Bind(&DevToolsWindow::FileSystemAdded, weak_factory_.GetWeakPtr()),
       base::Bind(&DevToolsWindow::ShowDevToolsConfirmInfoBar,
                  weak_factory_.GetWeakPtr()));
 }
 
 void DevToolsWindow::RemoveFileSystem(const std::string& file_system_path) {
   CHECK(web_contents_->GetURL().SchemeIs(chrome::kChromeDevToolsScheme));
   file_helper_->RemoveFileSystem(file_system_path);
-  StringValue file_system_path_value(file_system_path);
+  base::StringValue file_system_path_value(file_system_path);
   CallClientFunction("InspectorFrontendAPI.fileSystemRemoved",
                      &file_system_path_value, NULL, NULL);
 }
 
 void DevToolsWindow::UpgradeDraggedFileSystemPermissions(
     const std::string& file_system_url) {
   CHECK(web_contents_->GetURL().SchemeIs(chrome::kChromeDevToolsScheme));
   file_helper_->UpgradeDraggedFileSystemPermissions(
       file_system_url,
       base::Bind(&DevToolsWindow::FileSystemAdded, weak_factory_.GetWeakPtr()),
@@ skipping 47 matching lines @@
   }
   file_system_indexer_->SearchInPath(file_system_path,
                                      query,
                                      Bind(&DevToolsWindow::SearchCompleted,
                                           weak_factory_.GetWeakPtr(),
                                           request_id,
                                           file_system_path));
 }
 
 void DevToolsWindow::FileSavedAs(const std::string& url) {
-  StringValue url_value(url);
+  base::StringValue url_value(url);
   CallClientFunction("InspectorFrontendAPI.savedURL", &url_value, NULL, NULL);
 }
 
 void DevToolsWindow::CanceledFileSaveAs(const std::string& url) {
-  StringValue url_value(url);
+  base::StringValue url_value(url);
   CallClientFunction("InspectorFrontendAPI.canceledSaveURL",
                      &url_value, NULL, NULL);
 }
 
 void DevToolsWindow::AppendedTo(const std::string& url) {
-  StringValue url_value(url);
+  base::StringValue url_value(url);
   CallClientFunction("InspectorFrontendAPI.appendedToURL", &url_value, NULL,
                      NULL);
 }
 
 void DevToolsWindow::FileSystemsLoaded(
     const std::vector<DevToolsFileHelper::FileSystem>& file_systems) {
-  ListValue file_systems_value;
+  base::ListValue file_systems_value;
   for (size_t i = 0; i < file_systems.size(); ++i)
     file_systems_value.Append(CreateFileSystemValue(file_systems[i]));
   CallClientFunction("InspectorFrontendAPI.fileSystemsLoaded",
                      &file_systems_value, NULL, NULL);
 }
 
 void DevToolsWindow::FileSystemAdded(
     const DevToolsFileHelper::FileSystem& file_system) {
   scoped_ptr<base::StringValue> error_string_value(
       new base::StringValue(std::string()));
   scoped_ptr<base::DictionaryValue> file_system_value;
   if (!file_system.file_system_path.empty())
     file_system_value.reset(CreateFileSystemValue(file_system));
   CallClientFunction("InspectorFrontendAPI.fileSystemAdded",
                      error_string_value.get(), file_system_value.get(), NULL);
 }
 
 void DevToolsWindow::IndexingTotalWorkCalculated(
     int request_id,
     const std::string& file_system_path,
     int total_work) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::FundamentalValue request_id_value(request_id);
-  StringValue file_system_path_value(file_system_path);
+  base::StringValue file_system_path_value(file_system_path);
   base::FundamentalValue total_work_value(total_work);
   CallClientFunction("InspectorFrontendAPI.indexingTotalWorkCalculated",
                      &request_id_value, &file_system_path_value,
                      &total_work_value);
 }
 
 void DevToolsWindow::IndexingWorked(int request_id,
                                     const std::string& file_system_path,
                                     int worked) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::FundamentalValue request_id_value(request_id);
-  StringValue file_system_path_value(file_system_path);
+  base::StringValue file_system_path_value(file_system_path);
   base::FundamentalValue worked_value(worked);
   CallClientFunction("InspectorFrontendAPI.indexingWorked", &request_id_value,
                      &file_system_path_value, &worked_value);
 }
 
 void DevToolsWindow::IndexingDone(int request_id,
                                   const std::string& file_system_path) {
   indexing_jobs_.erase(request_id);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::FundamentalValue request_id_value(request_id);
-  StringValue file_system_path_value(file_system_path);
+  base::StringValue file_system_path_value(file_system_path);
   CallClientFunction("InspectorFrontendAPI.indexingDone", &request_id_value,
                      &file_system_path_value, NULL);
 }
 
 void DevToolsWindow::SearchCompleted(
     int request_id,
     const std::string& file_system_path,
     const std::vector<std::string>& file_paths) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  ListValue file_paths_value;
+  base::ListValue file_paths_value;
   for (std::vector<std::string>::const_iterator it(file_paths.begin());
        it != file_paths.end(); ++it) {
     file_paths_value.AppendString(*it);
   }
   base::FundamentalValue request_id_value(request_id);
-  StringValue file_system_path_value(file_system_path);
+  base::StringValue file_system_path_value(file_system_path);
   CallClientFunction("InspectorFrontendAPI.searchCompleted", &request_id_value,
                      &file_system_path_value, &file_paths_value);
 }
 
 void DevToolsWindow::ShowDevToolsConfirmInfoBar(
     const base::string16& message,
     const InfoBarCallback& callback) {
   DevToolsConfirmInfoBarDelegate::Create(
       IsDocked() ?
           InfoBarService::FromWebContents(GetInspectedWebContents()) :
           InfoBarService::FromWebContents(web_contents_),
       callback, message);
 }
 
 void DevToolsWindow::CreateDevToolsBrowser() {
   std::string wp_key = GetDevToolsWindowPlacementPrefKey();
   PrefService* prefs = profile_->GetPrefs();
-  const DictionaryValue* wp_pref = prefs->GetDictionary(wp_key.c_str());
+  const base::DictionaryValue* wp_pref = prefs->GetDictionary(wp_key.c_str());
   if (!wp_pref || wp_pref->empty()) {
     DictionaryPrefUpdate update(prefs, wp_key.c_str());
-    DictionaryValue* defaults = update.Get();
+    base::DictionaryValue* defaults = update.Get();
     defaults->SetInteger("left", 100);
     defaults->SetInteger("top", 100);
     defaults->SetInteger("right", 740);
     defaults->SetInteger("bottom", 740);
     defaults->SetBoolean("maximized", false);
     defaults->SetBoolean("always_on_top", false);
   }
 
   browser_ = new Browser(Browser::CreateParams::CreateForDevTools(
       profile_,
@@ skipping 117 matching lines @@
   }
 
   Profile* profile =
       Profile::FromBrowserContext(web_contents_->GetBrowserContext());
   const ExtensionService* extension_service = extensions::ExtensionSystem::Get(
       profile->GetOriginalProfile())->extension_service();
   if (!extension_service)
     return;
   const extensions::ExtensionSet* extensions = extension_service->extensions();
 
-  ListValue results;
+  base::ListValue results;
   for (extensions::ExtensionSet::const_iterator extension(extensions->begin());
        extension != extensions->end(); ++extension) {
     if (extensions::ManifestURL::GetDevToolsPage(extension->get()).is_empty())
       continue;
-    DictionaryValue* extension_info = new DictionaryValue();
+    base::DictionaryValue* extension_info = new base::DictionaryValue();
     extension_info->Set(
         "startPage",
-        new StringValue(
+        new base::StringValue(
             extensions::ManifestURL::GetDevToolsPage(extension->get()).spec()));
-    extension_info->Set("name", new StringValue((*extension)->name()));
+    extension_info->Set("name", new base::StringValue((*extension)->name()));
     extension_info->Set(
         "exposeExperimentalAPIs",
         new base::FundamentalValue((*extension)->HasAPIPermission(
             extensions::APIPermission::kExperimental)));
     results.Append(extension_info);
   }
   CallClientFunction("WebInspector.addExtensions", &results, NULL, NULL);
 }
 
 void DevToolsWindow::CallClientFunction(const std::string& function_name,
-                                        const Value* arg1,
-                                        const Value* arg2,
-                                        const Value* arg3) {
+                                        const base::Value* arg1,
+                                        const base::Value* arg2,
+                                        const base::Value* arg3) {
   std::string params;
   if (arg1) {
     std::string json;
     base::JSONWriter::Write(arg1, &json);
     params.append(json);
     if (arg2) {
       base::JSONWriter::Write(arg2, &json);
       params.append(", " + json);
       if (arg3) {
         base::JSONWriter::Write(arg3, &json);
@@ skipping 25 matching lines @@
   return inspected_contents_observer_ ?
       inspected_contents_observer_->web_contents() : NULL;
 }
 
 void DevToolsWindow::DocumentOnLoadCompletedInMainFrame() {
   is_loaded_ = true;
   UpdateTheme();
   DoAction();
   AddDevToolsExtensionsToClient();
 }