Convert most of extensions and some other random stuff to using the base namespace for Values.

chrome/browser/extensions/api/debugger/debugger_api.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.
 
 // Implements the Chrome Extensions Debugger API.
 
 #include "chrome/browser/extensions/api/debugger/debugger_api.h"
 
 #include <map>
 #include <set>
@@ skipping 436 matching lines @@
 
 void ExtensionDevToolsClientHost::Close() {
   DevToolsManager::GetInstance()->ClientHostClosing(this);
   delete this;
 }
 
 void ExtensionDevToolsClientHost::SendMessageToBackend(
     DebuggerSendCommandFunction* function,
     const std::string& method,
     SendCommand::Params::CommandParams* command_params) {
-  DictionaryValue protocol_request;
+  base::DictionaryValue protocol_request;
   int request_id = ++last_request_id_;
   pending_requests_[request_id] = function;
   protocol_request.SetInteger("id", request_id);
   protocol_request.SetString("method", method);
   if (command_params) {
     protocol_request.Set("params",
                          command_params->additional_properties.DeepCopy());
   }
 
   std::string json_args;
@@ skipping 42 matching lines @@
 }
 
 void ExtensionDevToolsClientHost::DispatchOnInspectorFrontend(
     const std::string& message) {
   if (!extensions::ExtensionSystem::Get(profile_)->event_router())
     return;
 
   scoped_ptr<Value> result(base::JSONReader::Read(message));
   if (!result->IsType(Value::TYPE_DICTIONARY))
     return;
-  DictionaryValue* dictionary = static_cast<DictionaryValue*>(result.get());
+  base::DictionaryValue* dictionary =
+      static_cast<base::DictionaryValue*>(result.get());
 
   int id;
   if (!dictionary->GetInteger("id", &id)) {
     std::string method_name;
     if (!dictionary->GetString("method", &method_name))
       return;
 
     OnEvent::Params params;
-    DictionaryValue* params_value;
+    base::DictionaryValue* params_value;
     if (dictionary->GetDictionary("params", &params_value))
       params.additional_properties.Swap(params_value);
 
     scoped_ptr<ListValue> args(OnEvent::Create(debuggee_, method_name, params));
     scoped_ptr<extensions::Event> event(new extensions::Event(
         keys::kOnEvent, args.Pass()));
     event->restrict_to_profile = profile_;
     extensions::ExtensionSystem::Get(profile_)->event_router()->
         DispatchEventToExtension(extension_id_, event.Pass());
   } else {
@@ skipping 168 matching lines @@
   CopyDebuggee(debuggee_, params->target);
   if (!InitClientHost())
     return false;
 
   client_host_->SendMessageToBackend(this, params->method,
       params->command_params.get());
   return true;
 }
 
 void DebuggerSendCommandFunction::SendResponseBody(
-    DictionaryValue* response) {
+    base::DictionaryValue* response) {
   Value* error_body;
   if (response->Get("error", &error_body)) {
     base::JSONWriter::Write(error_body, &error_);
     SendResponse(false);
     return;
   }
 
-  DictionaryValue* result_body;
+  base::DictionaryValue* result_body;
   SendCommand::Results::Result result;
   if (response->GetDictionary("result", &result_body))
     result.additional_properties.Swap(result_body);
 
   results_ = SendCommand::Results::Create(result);
   SendResponse(true);
 }
 
 
 // DebuggerGetTargetsFunction -------------------------------------------------
@@ skipping 31 matching lines @@
       WorkerService::GetInstance()->GetWorkers();
 
   for (size_t i = 0; i < worker_info.size(); ++i)
     list->Append(SerializeWorkerInfo(worker_info[i]));
 }
 
 void DebuggerGetTargetsFunction::SendTargetList(base::ListValue* list) {
   SetResult(list);
   SendResponse(true);
 }