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

chrome/browser/extensions/api/runtime/runtime_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/runtime/runtime_api.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_host.h"
@@ skipping 82 matching lines @@
       first_call &&
       system->lazy_background_task_queue()->
           ShouldEnqueueTask(profile, extension)) {
     system->lazy_background_task_queue()->AddPendingTask(
         profile, extension_id,
         base::Bind(&DispatchOnStartupEventImpl,
                    profile, extension_id, false));
     return;
   }
 
-  scoped_ptr<base::ListValue> event_args(new ListValue());
+  scoped_ptr<base::ListValue> event_args(new base::ListValue());
   scoped_ptr<Event> event(new Event(kOnStartupEvent, event_args.Pass()));
   system->event_router()->DispatchEventToExtension(extension_id, event.Pass());
 }
 
 void SetUninstallUrl(ExtensionPrefs* prefs,
                      const std::string& extension_id,
                      const std::string& url_string) {
   prefs->UpdateExtensionPref(extension_id,
                              kUninstallUrl,
                              base::Value::CreateStringValue(url_string));
@@ skipping 22 matching lines @@
     bool chrome_updated) {
   ExtensionSystem* system = ExtensionSystem::Get(profile);
   if (!system)
     return;
 
   // Special case: normally, extensions add their own lazy event listeners.
   // However, since the extension has just been installed, it hasn't had a
   // chance to register for events. So we register on its behalf. If the
   // extension does not actually have a listener, the event will just be
   // ignored.
-  scoped_ptr<base::ListValue> event_args(new ListValue());
+  scoped_ptr<base::ListValue> event_args(new base::ListValue());
   base::DictionaryValue* info = new base::DictionaryValue();
   event_args->Append(info);
   if (old_version.IsValid()) {
     info->SetString(kInstallReason, kInstallReasonUpdate);
     info->SetString(kInstallPreviousVersion, old_version.GetString());
   } else if (chrome_updated) {
     info->SetString(kInstallReason, kInstallReasonChromeUpdate);
   } else {
     info->SetString(kInstallReason, kInstallReasonInstall);
   }
   DCHECK(system->event_router());
   system->event_router()->AddLazyEventListener(kOnInstalledEvent, extension_id);
   scoped_ptr<Event> event(new Event(kOnInstalledEvent, event_args.Pass()));
   system->event_router()->DispatchEventToExtension(extension_id, event.Pass());
   system->event_router()->RemoveLazyEventListener(kOnInstalledEvent,
                                                   extension_id);
 }
 
 // static
 void RuntimeEventRouter::DispatchOnUpdateAvailableEvent(
     Profile* profile,
     const std::string& extension_id,
-    const DictionaryValue* manifest) {
+    const base::DictionaryValue* manifest) {
   ExtensionSystem* system = ExtensionSystem::Get(profile);
   if (!system)
     return;
 
-  scoped_ptr<ListValue> args(new ListValue);
+  scoped_ptr<base::ListValue> args(new base::ListValue);
   args->Append(manifest->DeepCopy());
   DCHECK(system->event_router());
   scoped_ptr<Event> event(new Event(kOnUpdateAvailableEvent, args.Pass()));
   system->event_router()->DispatchEventToExtension(extension_id, event.Pass());
 }
 
 // static
 void RuntimeEventRouter::DispatchOnBrowserUpdateAvailableEvent(
     Profile* profile) {
   ExtensionSystem* system = ExtensionSystem::Get(profile);
   if (!system)
     return;
 
-  scoped_ptr<ListValue> args(new ListValue);
+  scoped_ptr<base::ListValue> args(new base::ListValue);
   DCHECK(system->event_router());
   scoped_ptr<Event> event(new Event(kOnBrowserUpdateAvailableEvent,
                                     args.Pass()));
   system->event_router()->BroadcastEvent(event.Pass());
 }
 
 // static
 void RuntimeEventRouter::OnExtensionUninstalled(
     Profile *profile,
     const std::string& extension_id) {
@@ skipping 203 matching lines @@
       fileapi::kFileSystemTypeNativeLocal, path, &relative_path);
 
   int renderer_id = render_view_host_->GetProcess()->GetID();
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
   policy->GrantReadFileSystem(renderer_id, filesystem_id);
 
   if (!policy->CanReadFile(renderer_id, path))
     policy->GrantReadFile(renderer_id, path);
 
-  DictionaryValue* dict = new DictionaryValue();
+  base::DictionaryValue* dict = new base::DictionaryValue();
   SetResult(dict);
   dict->SetString("fileSystemId", filesystem_id);
   dict->SetString("baseName", relative_path);
   return true;
 }
 
 }   // namespace extensions