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

chrome/browser/extensions/event_router_forwarder_unittest.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/event_router_forwarder.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/test/thread_test_helper.h"
@@ skipping 29 matching lines @@
                              restrict_to_profile, event_url);
   }
 
  protected:
   virtual ~MockEventRouterForwarder() {}
 };
 
 static void BroadcastEventToRenderers(EventRouterForwarder* event_router,
                                       const std::string& event_name,
                                       const GURL& url) {
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   event_router->BroadcastEventToRenderers(event_name, args.Pass(), url);
 }
 
 static void DispatchEventToRenderers(EventRouterForwarder* event_router,
                                      const std::string& event_name,
                                      void* profile,
                                      bool use_profile_to_restrict_events,
                                      const GURL& url) {
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   event_router->DispatchEventToRenderers(event_name, args.Pass(), profile,
                                          use_profile_to_restrict_events, url);
 }
 
 static void BroadcastEventToExtension(EventRouterForwarder* event_router,
                                       const std::string& extension,
                                       const std::string& event_name,
                                       const GURL& url) {
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   event_router->BroadcastEventToExtension(extension, event_name, args.Pass(),
                                           url);
 }
 
 static void DispatchEventToExtension(EventRouterForwarder* event_router,
                                      const std::string& extension,
                                      const std::string& event_name,
                                      void* profile,
                                      bool use_profile_to_restrict_events,
                                      const GURL& url) {
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   event_router->DispatchEventToExtension(
       extension, event_name, args.Pass(), profile,
       use_profile_to_restrict_events, url);
 }
 
 }  // namespace
 
 class EventRouterForwarderTest : public testing::Test {
  protected:
   EventRouterForwarderTest()
@@ skipping 189 matching lines @@
   GURL url;
   EXPECT_CALL(*event_router.get(),
               CallEventRouter(profile1_, kExt, kEventName, NULL, url));
   EXPECT_CALL(*event_router.get(), CallEventRouter(profile2_, _, _, _, _))
       .Times(0);
   DispatchEventToExtension(event_router.get(), kExt, kEventName, profile1_,
                            false, url);
 }
 
 }  // namespace extensions