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

chrome/browser/extensions/api/messaging/message_service.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/extensions/api/messaging/message_service.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_writer.h"
@@ skipping 52 matching lines @@
     "Native Messaging is not supported on this platform.";
 }
 
 struct MessageService::MessageChannel {
   scoped_ptr<MessagePort> opener;
   scoped_ptr<MessagePort> receiver;
 };
 
 struct MessageService::OpenChannelParams {
   content::RenderProcessHost* source;
-  DictionaryValue source_tab;
+  base::DictionaryValue source_tab;
   scoped_ptr<MessagePort> receiver;
   int receiver_port_id;
   std::string source_extension_id;
   std::string target_extension_id;
   GURL source_url;
   std::string channel_name;
 
   // Takes ownership of receiver.
   OpenChannelParams(content::RenderProcessHost* source,
-                    scoped_ptr<DictionaryValue> source_tab,
+                    scoped_ptr<base::DictionaryValue> source_tab,
                     MessagePort* receiver,
                     int receiver_port_id,
                     const std::string& source_extension_id,
                     const std::string& target_extension_id,
                     const GURL& source_url,
                     const std::string& channel_name)
       : source(source),
         receiver(receiver),
         receiver_port_id(receiver_port_id),
         source_extension_id(source_extension_id),
@@ skipping 139 matching lines @@
   // Note: we use the source's profile here. If the source is an incognito
   // process, we will use the incognito EPM to find the right extension process,
   // which depends on whether the extension uses spanning or split mode.
   MessagePort* receiver = new ExtensionMessagePort(
       GetExtensionProcess(profile, target_extension_id), MSG_ROUTING_CONTROL,
       target_extension_id);
   WebContents* source_contents = tab_util::GetWebContentsByID(
       source_process_id, source_routing_id);
 
   // Include info about the opener's tab (if it was a tab).
-  scoped_ptr<DictionaryValue> source_tab;
+  scoped_ptr<base::DictionaryValue> source_tab;
   GURL source_url_for_tab;
 
   if (source_contents && ExtensionTabUtil::GetTabId(source_contents) >= 0) {
     // Platform apps can be sent messages, but don't have a Tab concept.
     if (!target_extension->is_platform_app())
       source_tab.reset(ExtensionTabUtil::CreateTabValue(source_contents));
     source_url_for_tab = source_url;
   }
 
   OpenChannelParams* params = new OpenChannelParams(source,
@@ skipping 94 matching lines @@
 
   if (contents && contents->GetController().NeedsReload()) {
     // The tab isn't loaded yet. Don't attempt to connect.
     DispatchOnDisconnect(
         source, receiver_port_id, kReceivingEndDoesntExistError);
     return;
   }
 
   scoped_ptr<OpenChannelParams> params(new OpenChannelParams(
         source,
-        scoped_ptr<DictionaryValue>(),  // Source tab doesn't make sense for
-                                        // opening to tabs.
+        scoped_ptr<base::DictionaryValue>(),  // Source tab doesn't make sense
+                                              // for opening to tabs.
         receiver.release(),
         receiver_port_id,
         extension_id,
         extension_id,
         GURL(),  // Source URL doesn't make sense for opening to tabs.
         channel_name));
   OpenChannelImpl(params.Pass());
 }
 
 bool MessageService::OpenChannelImpl(scoped_ptr<OpenChannelParams> params) {
@@ skipping 205 matching lines @@
 }
 
 void MessageService::DispatchOnDisconnect(content::RenderProcessHost* source,
                                           int port_id,
                                           const std::string& error_message) {
   ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, "");
   port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(port_id), error_message);
 }
 
 }  // namespace extensions