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

chrome/browser/extensions/api/notifications/notifications_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.
 
 #include "chrome/browser/extensions/api/notifications/notifications_api.h"
 
 #include "base/callback.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time.h"
@@ skipping 117 matching lines @@
         scoped_id_(CreateScopedIdentifier(extension_id, id)),
         process_id_(-1) {
     DCHECK(api_function_.get());
     if (api_function_->render_view_host())
       process_id_ = api_function->render_view_host()->GetProcess()->GetID();
   }
 
   virtual void Display() OVERRIDE { }
 
   virtual void Error() OVERRIDE {
-    scoped_ptr<ListValue> args(CreateBaseEventArgs());
+    scoped_ptr<base::ListValue> args(CreateBaseEventArgs());
     SendEvent(event_names::kOnNotificationError, args.Pass());
   }
 
   virtual void Close(bool by_user) OVERRIDE {
-    scoped_ptr<ListValue> args(CreateBaseEventArgs());
+    scoped_ptr<base::ListValue> args(CreateBaseEventArgs());
     args->Append(Value::CreateBooleanValue(by_user));
     SendEvent(event_names::kOnNotificationClosed, args.Pass());
   }
 
   virtual void Click() OVERRIDE {
-    scoped_ptr<ListValue> args(CreateBaseEventArgs());
+    scoped_ptr<base::ListValue> args(CreateBaseEventArgs());
     SendEvent(event_names::kOnNotificationClicked, args.Pass());
   }
 
   virtual bool HasClickedListener() OVERRIDE {
     return ExtensionSystem::Get(profile_)->event_router()->HasEventListener(
         event_names::kOnNotificationClicked);
   }
 
   virtual void ButtonClick(int index) OVERRIDE {
-    scoped_ptr<ListValue> args(CreateBaseEventArgs());
+    scoped_ptr<base::ListValue> args(CreateBaseEventArgs());
     args->Append(Value::CreateIntegerValue(index));
     SendEvent(event_names::kOnNotificationButtonClicked, args.Pass());
   }
 
   virtual std::string id() const OVERRIDE {
     return scoped_id_;
   }
 
   virtual int process_id() const OVERRIDE {
     return process_id_;
   }
 
   virtual content::RenderViewHost* GetRenderViewHost() const OVERRIDE {
     // We're holding a reference to api_function_, so we know it'll be valid
     // until ReleaseRVH is called, and api_function_ (as a
     // UIThreadExtensionFunction) will zero out its copy of render_view_host
     // when the RVH goes away.
     if (!api_function_.get())
       return NULL;
     return api_function_->render_view_host();
   }
 
   virtual void ReleaseRenderViewHost() OVERRIDE {
     api_function_ = NULL;
   }
 
  private:
   virtual ~NotificationsApiDelegate() {}
 
-  void SendEvent(const std::string& name, scoped_ptr<ListValue> args) {
+  void SendEvent(const std::string& name, scoped_ptr<base::ListValue> args) {
     scoped_ptr<Event> event(new Event(name, args.Pass()));
     ExtensionSystem::Get(profile_)->event_router()->DispatchEventToExtension(
         extension_id_, event.Pass());
   }
 
-  scoped_ptr<ListValue> CreateBaseEventArgs() {
-    scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> CreateBaseEventArgs() {
+    scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(Value::CreateStringValue(id_));
     return args.Pass();
   }
 
   scoped_refptr<ApiFunction> api_function_;
   Profile* profile_;
   const std::string extension_id_;
   const std::string id_;
   const std::string scoped_id_;
   int process_id_;
@@ skipping 228 matching lines @@
 
 NotificationsGetAllFunction::~NotificationsGetAllFunction() {}
 
 bool NotificationsGetAllFunction::RunNotificationsApi() {
   NotificationUIManager* notification_ui_manager =
       g_browser_process->notification_ui_manager();
   std::set<std::string> notification_ids =
       notification_ui_manager->GetAllIdsByProfileAndSourceOrigin(
           profile_, extension_->url());
 
-  scoped_ptr<DictionaryValue> result(new DictionaryValue());
+  scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
 
   for (std::set<std::string>::iterator iter = notification_ids.begin();
        iter != notification_ids.end(); iter++) {
     result->SetBooleanWithoutPathExpansion(
         StripScopeFromIdentifier(extension_->id(), *iter), true);
   }
 
   SetResult(result.release());
   SendResponse(true);
 
   return true;
 }
 
 }  // namespace extensions