Update some uses of Value in chrome/browser to use the base:: namespace.

chrome/browser/automation/automation_provider_observers.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/automation/automation_provider_observers.h"
 
 #include <deque>
 #include <string>
 #include <vector>
 
@@ skipping 163 matching lines @@
         break;
     }
   } else {
     NOTREACHED();
   }
 
   if (finished_tabs_.size() + crashed_tab_count_ >= outstanding_tab_count_)
     ConditionMet();
 }
 
-DictionaryValue* InitialLoadObserver::GetTimingInformation() const {
-  ListValue* items = new ListValue;
+base::DictionaryValue* InitialLoadObserver::GetTimingInformation() const {
+  base::ListValue* items = new base::ListValue;
   for (TabTimeMap::const_iterator it = loading_tabs_.begin();
        it != loading_tabs_.end();
        ++it) {
-    DictionaryValue* item = new DictionaryValue;
+    base::DictionaryValue* item = new base::DictionaryValue;
     base::TimeDelta delta_start = it->second.start_time() - init_time_;
 
     item->SetDouble("load_start_ms", delta_start.InMillisecondsF());
     if (it->second.stop_time().is_null()) {
-      item->Set("load_stop_ms", Value::CreateNullValue());
+      item->Set("load_stop_ms", base::Value::CreateNullValue());
     } else {
       base::TimeDelta delta_stop = it->second.stop_time() - init_time_;
       item->SetDouble("load_stop_ms", delta_stop.InMillisecondsF());
     }
     items->Append(item);
   }
-  DictionaryValue* return_value = new DictionaryValue;
+  base::DictionaryValue* return_value = new base::DictionaryValue;
   return_value->Set("tabs", items);
   return return_value;
 }
 
 void InitialLoadObserver::ConditionMet() {
   registrar_.RemoveAll();
   if (automation_.get())
     automation_->OnInitialTabLoadsComplete();
 }
 
@@ skipping 110 matching lines @@
   } else {
     NOTREACHED();
   }
 }
 
 void NavigationNotificationObserver::ConditionMet(
     AutomationMsg_NavigationResponseValues navigation_result) {
   if (automation_.get()) {
     if (use_json_interface_) {
       if (navigation_result == AUTOMATION_MSG_NAVIGATION_SUCCESS) {
-        DictionaryValue dict;
+        base::DictionaryValue dict;
         dict.SetInteger("result", navigation_result);
         AutomationJSONReply(automation_.get(), reply_message_.release())
             .SendSuccess(&dict);
       } else {
         AutomationJSONReply(automation_.get(), reply_message_.release())
             .SendError(base::StringPrintf(
                  "Navigation failed with error code=%d.", navigation_result));
       }
     } else {
       IPC::ParamTraits<int>::Write(
@@ skipping 189 matching lines @@
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (!automation_.get()) {
     delete this;
     return;
   }
 
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_UNINSTALLED: {
       if (id_ == content::Details<extensions::Extension>(details).ptr()->id()) {
-        scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+        scoped_ptr<base::DictionaryValue> return_value(
+            new base::DictionaryValue);
         return_value->SetBoolean("success", true);
         AutomationJSONReply(automation_.get(), reply_message_.release())
             .SendSuccess(return_value.get());
         delete this;
         return;
       }
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_UNINSTALL_NOT_ALLOWED: {
       const extensions::Extension* extension =
           content::Details<extensions::Extension>(details).ptr();
       if (id_ == extension->id()) {
-        scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+        scoped_ptr<base::DictionaryValue> return_value(
+            new base::DictionaryValue);
         return_value->SetBoolean("success", false);
         AutomationJSONReply(automation_.get(), reply_message_.release())
             .SendSuccess(return_value.get());
         delete this;
         return;
       }
       break;
     }
 
     default:
@@ skipping 66 matching lines @@
     case chrome::NOTIFICATION_EXTENSION_LOAD_ERROR:
     case chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED:
       break;
     default:
       NOTREACHED();
       break;
   }
 
   AutomationJSONReply reply(automation_.get(), reply_message_.release());
   if (extension_) {
-    DictionaryValue dict;
+    base::DictionaryValue dict;
     dict.SetString("id", extension_->id());
     reply.SendSuccess(&dict);
   } else {
     reply.SendError("Extension could not be installed");
   }
   delete this;
 }
 
 ExtensionUnloadNotificationObserver::ExtensionUnloadNotificationObserver()
     : did_receive_unload_notification_(false) {
@@ skipping 390 matching lines @@
 
   if (!automation_.get()) {
     delete this;
     return;
   }
 
   // We get multiple responses and one of those will contain the ordinal.
   // This message comes to us before the final update is sent.
   if (find_details->request_id() == kFindInPageRequestId) {
     if (reply_with_json_) {
-      scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+      scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
       return_value->SetInteger("match_count",
           find_details->number_of_matches());
       gfx::Rect rect = find_details->selection_rect();
       // If MatchCount is > 0, then rect should not be Empty.
       // We dont guard it here because we want to let the test
       // code catch this invalid case if needed.
       if (!rect.IsEmpty()) {
         return_value->SetInteger("match_left", rect.x());
         return_value->SetInteger("match_top", rect.y());
         return_value->SetInteger("match_right", rect.right());
@@ skipping 60 matching lines @@
       reply_message_(reply_message),
       use_json_interface_(use_json_interface) {
 }
 
 DomOperationMessageSender::~DomOperationMessageSender() {}
 
 void DomOperationMessageSender::OnDomOperationCompleted(
     const std::string& json) {
   if (automation_.get()) {
     if (use_json_interface_) {
-      DictionaryValue dict;
+      base::DictionaryValue dict;
       dict.SetString("result", json);
       AutomationJSONReply(automation_.get(), reply_message_.release())
           .SendSuccess(&dict);
     } else {
       AutomationMsg_DomOperation::WriteReplyParams(reply_message_.get(), json);
       automation_->Send(reply_message_.release());
     }
   }
   delete this;
 }
@@ skipping 140 matching lines @@
 void AutomationProviderDownloadUpdatedObserver::OnDownloadUpdated(
     DownloadItem* download) {
   // If this observer is watching for open, only send the reply if the download
   // has been auto-opened.
   if (wait_for_open_ && !download->GetAutoOpened())
     return;
 
   download->RemoveObserver(this);
 
   if (provider_.get()) {
-    scoped_ptr<DictionaryValue> return_value(
+    scoped_ptr<base::DictionaryValue> return_value(
         provider_->GetDictionaryFromDownloadItem(download, incognito_));
     AutomationJSONReply(provider_.get(), reply_message_.release())
         .SendSuccess(return_value.get());
   }
   delete this;
 }
 
 void AutomationProviderDownloadUpdatedObserver::OnDownloadOpened(
     DownloadItem* download) {
   download->RemoveObserver(this);
 
   if (provider_.get()) {
-    scoped_ptr<DictionaryValue> return_value(
+    scoped_ptr<base::DictionaryValue> return_value(
         provider_->GetDictionaryFromDownloadItem(download, incognito_));
     AutomationJSONReply(provider_.get(), reply_message_.release())
         .SendSuccess(return_value.get());
   }
   delete this;
 }
 
 AutomationProviderDownloadModelChangedObserver::
 AutomationProviderDownloadModelChangedObserver(
     AutomationProvider* provider,
@@ skipping 21 matching lines @@
 
 void AutomationProviderDownloadModelChangedObserver::OnDownloadRemoved(
     DownloadManager* manager, DownloadItem* item) {
   ModelChanged();
 }
 
 AllDownloadsCompleteObserver::AllDownloadsCompleteObserver(
     AutomationProvider* provider,
     IPC::Message* reply_message,
     DownloadManager* download_manager,
-    ListValue* pre_download_ids)
+    base::ListValue* pre_download_ids)
     : provider_(provider->AsWeakPtr()),
       reply_message_(reply_message),
       download_manager_(download_manager) {
-  for (ListValue::iterator it = pre_download_ids->begin();
+  for (base::ListValue::iterator it = pre_download_ids->begin();
        it != pre_download_ids->end(); ++it) {
     int val = 0;
     if ((*it)->GetAsInteger(&val)) {
       pre_download_ids_.insert(val);
     } else {
       AutomationJSONReply(provider_.get(), reply_message_.release())
           .SendError("Cannot convert ID of prior download to integer.");
       delete this;
       return;
     }
@@ skipping 90 matching lines @@
 AutomationProviderHistoryObserver::~AutomationProviderHistoryObserver() {}
 
 void AutomationProviderHistoryObserver::HistoryQueryComplete(
     HistoryService::Handle request_handle,
     history::QueryResults* results) {
   if (!provider_.get()) {
     delete this;
     return;
   }
 
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
 
-  ListValue* history_list = new ListValue;
+  base::ListValue* history_list = new base::ListValue;
   for (size_t i = 0; i < results->size(); ++i) {
-    DictionaryValue* page_value = new DictionaryValue;
+    base::DictionaryValue* page_value = new base::DictionaryValue;
     history::URLResult const &page = (*results)[i];
     page_value->SetString("title", page.title());
     page_value->SetString("url", page.url().spec());
     page_value->SetDouble("time",
                           static_cast<double>(page.visit_time().ToDoubleT()));
     page_value->SetString("snippet", page.snippet().text());
     page_value->SetBoolean(
         "starred",
         BookmarkModelFactory::GetForProfile(
             provider_->profile())->IsBookmarked(page.url()));
@@ skipping 47 matching lines @@
     ~AutomationProviderGetPasswordsObserver() {}
 
 void AutomationProviderGetPasswordsObserver::OnPasswordStoreRequestDone(
     CancelableRequestProvider::Handle handle,
     const std::vector<autofill::PasswordForm*>& result) {
   if (!provider_.get()) {
     delete this;
     return;
   }
 
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
 
-  ListValue* passwords = new ListValue;
+  base::ListValue* passwords = new base::ListValue;
   for (std::vector<autofill::PasswordForm*>::const_iterator it =
            result.begin(); it != result.end(); ++it) {
-    DictionaryValue* password_val = new DictionaryValue;
+    base::DictionaryValue* password_val = new base::DictionaryValue;
     autofill::PasswordForm* password_form = *it;
     password_val->SetString("username_value", password_form->username_value);
     password_val->SetString("password_value", password_form->password_value);
     password_val->SetString("signon_realm", password_form->signon_realm);
     password_val->SetDouble(
         "time", static_cast<double>(password_form->date_created.ToDoubleT()));
     password_val->SetString("origin_url", password_form->origin.spec());
     password_val->SetString("username_element",
                             password_form->username_element);
     password_val->SetString("password_element",
@@ skipping 80 matching lines @@
       base::Bind(&PasswordStoreLoginsChangedObserver::IndicateDone, this));
 }
 
 void PasswordStoreLoginsChangedObserver::IndicateDone() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (automation_.get()) {
     if (result_key_.empty()) {
       AutomationJSONReply(automation_.get(), reply_message_.release())
           .SendSuccess(NULL);
     } else {
-      scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+      scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
       return_value->SetBoolean(result_key_, true);
       AutomationJSONReply(automation_.get(), reply_message_.release())
           .SendSuccess(return_value.get());
     }
   }
   Release();
 }
 
 void PasswordStoreLoginsChangedObserver::IndicateError(
     const std::string& error) {
@@ skipping 62 matching lines @@
 void SavePackageNotificationObserver::ManagerGoingDown(
     content::DownloadManager* manager) {
   delete this;
 }
 
 namespace {
 
 // Returns a vector of dictionaries containing information about installed apps,
 // as identified from a given list of extensions.  The caller takes ownership
 // of the created vector.
-std::vector<DictionaryValue*>* GetAppInfoFromExtensions(
+std::vector<base::DictionaryValue*>* GetAppInfoFromExtensions(
     const extensions::ExtensionSet* extensions,
     ExtensionService* ext_service) {
-  std::vector<DictionaryValue*>* apps_list =
-      new std::vector<DictionaryValue*>();
+  std::vector<base::DictionaryValue*>* apps_list =
+      new std::vector<base::DictionaryValue*>();
   for (extensions::ExtensionSet::const_iterator ext = extensions->begin();
        ext != extensions->end(); ++ext) {
     // Only return information about extensions that are actually apps.
     if ((*ext)->is_app()) {
-      DictionaryValue* app_info = new DictionaryValue();
+      base::DictionaryValue* app_info = new base::DictionaryValue();
       AppLauncherHandler::CreateAppInfo(ext->get(), ext_service, app_info);
       app_info->SetBoolean(
           "is_component_extension",
           (*ext)->location() == extensions::Manifest::COMPONENT);
 
       // Convert the launch_type integer into a more descriptive string.
       int launch_type;
       const char* kLaunchType = "launch_type";
       if (!app_info->GetInteger(kLaunchType, &launch_type)) {
         NOTREACHED() << "Can't get integer from key " << kLaunchType;
@@ skipping 17 matching lines @@
   return apps_list;
 }
 
 }  // namespace
 
 NTPInfoObserver::NTPInfoObserver(AutomationProvider* automation,
                                  IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       request_(0),
-      ntp_info_(new DictionaryValue) {
+      ntp_info_(new base::DictionaryValue) {
   top_sites_ = automation_->profile()->GetTopSites();
   if (!top_sites_) {
     AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendError("Profile does not have service for querying the top sites.");
     return;
   }
   TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(automation_->profile());
   if (!service) {
     AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendError("No TabRestoreService.");
     return;
   }
 
   // Collect information about the apps in the new tab page.
   ExtensionService* ext_service = extensions::ExtensionSystem::Get(
       automation_->profile())->extension_service();
   if (!ext_service) {
     AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendError("No ExtensionService.");
     return;
   }
   // Process enabled extensions.
-  ListValue* apps_list = new ListValue();
+  base::ListValue* apps_list = new base::ListValue();
   const extensions::ExtensionSet* extensions = ext_service->extensions();
-  std::vector<DictionaryValue*>* enabled_apps = GetAppInfoFromExtensions(
+  std::vector<base::DictionaryValue*>* enabled_apps = GetAppInfoFromExtensions(
       extensions, ext_service);
-  for (std::vector<DictionaryValue*>::const_iterator app =
+  for (std::vector<base::DictionaryValue*>::const_iterator app =
        enabled_apps->begin(); app != enabled_apps->end(); ++app) {
     (*app)->SetBoolean("is_disabled", false);
     apps_list->Append(*app);
   }
   delete enabled_apps;
   // Process disabled extensions.
   const extensions::ExtensionSet* disabled_extensions =
       ext_service->disabled_extensions();
-  std::vector<DictionaryValue*>* disabled_apps = GetAppInfoFromExtensions(
+  std::vector<base::DictionaryValue*>* disabled_apps = GetAppInfoFromExtensions(
       disabled_extensions, ext_service);
-  for (std::vector<DictionaryValue*>::const_iterator app =
+  for (std::vector<base::DictionaryValue*>::const_iterator app =
        disabled_apps->begin(); app != disabled_apps->end(); ++app) {
     (*app)->SetBoolean("is_disabled", true);
     apps_list->Append(*app);
   }
   delete disabled_apps;
   // Process terminated extensions.
   const extensions::ExtensionSet* terminated_extensions =
       ext_service->terminated_extensions();
-  std::vector<DictionaryValue*>* terminated_apps = GetAppInfoFromExtensions(
-      terminated_extensions, ext_service);
-  for (std::vector<DictionaryValue*>::const_iterator app =
+  std::vector<base::DictionaryValue*>* terminated_apps =
+      GetAppInfoFromExtensions(terminated_extensions, ext_service);
+  for (std::vector<base::DictionaryValue*>::const_iterator app =
        terminated_apps->begin(); app != terminated_apps->end(); ++app) {
     (*app)->SetBoolean("is_disabled", true);
     apps_list->Append(*app);
   }
   delete terminated_apps;
   ntp_info_->Set("apps", apps_list);
 
   // Get the info that would be displayed in the recently closed section.
-  ListValue* recently_closed_list = new ListValue;
+  base::ListValue* recently_closed_list = new base::ListValue;
   RecentlyClosedTabsHandler::CreateRecentlyClosedValues(service->entries(),
                                                         recently_closed_list);
   ntp_info_->Set("recently_closed", recently_closed_list);
 
   // Add default site URLs.
-  ListValue* default_sites_list = new ListValue;
+  base::ListValue* default_sites_list = new base::ListValue;
   history::MostVisitedURLList urls = top_sites_->GetPrepopulatePages();
   for (size_t i = 0; i < urls.size(); ++i) {
-    default_sites_list->Append(Value::CreateStringValue(
+    default_sites_list->Append(base::Value::CreateStringValue(
         urls[i].url.possibly_invalid_spec()));
   }
   ntp_info_->Set("default_sites", default_sites_list);
 
   registrar_.Add(this, chrome::NOTIFICATION_TOP_SITES_UPDATED,
                  content::Source<history::TopSites>(top_sites_));
   if (top_sites_->loaded()) {
     OnTopSitesLoaded();
   } else {
     registrar_.Add(this, chrome::NOTIFICATION_TOP_SITES_LOADED,
@@ skipping 23 matching lines @@
   request_ = top_sites_->StartQueryForMostVisited();
 }
 
 void NTPInfoObserver::OnTopSitesReceived(
     const history::MostVisitedURLList& visited_list) {
   if (!automation_.get()) {
     delete this;
     return;
   }
 
-  ListValue* list_value = new ListValue;
+  base::ListValue* list_value = new base::ListValue;
   for (size_t i = 0; i < visited_list.size(); ++i) {
     const history::MostVisitedURL& visited = visited_list[i];
     if (visited.url.spec().empty())
       break;  // This is the signal that there are no more real visited sites.
-    DictionaryValue* dict = new DictionaryValue;
+    base::DictionaryValue* dict = new base::DictionaryValue;
     dict->SetString("url", visited.url.spec());
     dict->SetString("title", visited.title);
     list_value->Append(dict);
   }
   ntp_info_->Set("most_visited", list_value);
   AutomationJSONReply(automation_.get(), reply_message_.release())
       .SendSuccess(ntp_info_.get());
   delete this;
 }
 
@@ skipping 86 matching lines @@
   if (!automation_.get()) {
     delete this;
     return;
   }
   if (AreActiveNotificationProcessesReady())
     SendMessage();
 }
 
 base::DictionaryValue* GetAllNotificationsObserver::NotificationToJson(
     const Notification* note) {
-  DictionaryValue* dict = new base::DictionaryValue();
+  base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("content_url", note->content_url().spec());
   dict->SetString("origin_url", note->origin_url().spec());
   dict->SetString("display_source", note->display_source());
   dict->SetString("id", note->notification_id());
   return dict;
 }
 
 void GetAllNotificationsObserver::SendMessage() {
   BalloonNotificationUIManager* manager =
       BalloonNotificationUIManager::GetInstanceForTesting();
   const BalloonCollection::Balloons& balloons =
       manager->balloon_collection()->GetActiveBalloons();
-  DictionaryValue return_value;
-  ListValue* list = new ListValue;
+  base::DictionaryValue return_value;
+  base::ListValue* list = new base::ListValue;
   return_value.Set("notifications", list);
   BalloonCollection::Balloons::const_iterator balloon_iter;
   for (balloon_iter = balloons.begin(); balloon_iter != balloons.end();
        ++balloon_iter) {
     base::DictionaryValue* note = NotificationToJson(
         &(*balloon_iter)->notification());
     BalloonHost* balloon_host = (*balloon_iter)->balloon_view()->GetHost();
     if (balloon_host) {
       int pid = base::GetProcId(balloon_host->web_contents()->
                                 GetRenderViewHost()->GetProcess()->GetHandle());
@@ skipping 263 matching lines @@
 
 ProcessInfoObserver::ProcessInfoObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message) {}
 
 ProcessInfoObserver::~ProcessInfoObserver() {}
 
 void ProcessInfoObserver::OnDetailsAvailable() {
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
-  ListValue* browser_proc_list = new ListValue();
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
+  base::ListValue* browser_proc_list = new base::ListValue();
   const std::vector<ProcessData>& all_processes = processes();
   for (size_t index = 0; index < all_processes.size(); ++index) {
-    DictionaryValue* browser_data = new DictionaryValue();
+    base::DictionaryValue* browser_data = new base::DictionaryValue();
     browser_data->SetString("name", all_processes[index].name);
     browser_data->SetString("process_name", all_processes[index].process_name);
 
-    ListValue* proc_list = new ListValue();
+    base::ListValue* proc_list = new base::ListValue();
     for (ProcessMemoryInformationList::const_iterator iterator =
              all_processes[index].processes.begin();
          iterator != all_processes[index].processes.end(); ++iterator) {
-      DictionaryValue* proc_data = new DictionaryValue();
+      base::DictionaryValue* proc_data = new base::DictionaryValue();
 
       proc_data->SetInteger("pid", iterator->pid);
 
       // Working set (resident) memory usage, in KBytes.
-      DictionaryValue* working_set = new DictionaryValue();
+      base::DictionaryValue* working_set = new base::DictionaryValue();
       working_set->SetInteger("priv", iterator->working_set.priv);
       working_set->SetInteger("shareable", iterator->working_set.shareable);
       working_set->SetInteger("shared", iterator->working_set.shared);
       proc_data->Set("working_set_mem", working_set);
 
       // Committed (resident + paged) memory usage, in KBytes.
-      DictionaryValue* committed = new DictionaryValue();
+      base::DictionaryValue* committed = new base::DictionaryValue();
       committed->SetInteger("priv", iterator->committed.priv);
       committed->SetInteger("mapped", iterator->committed.mapped);
       committed->SetInteger("image", iterator->committed.image);
       proc_data->Set("committed_mem", committed);
 
       proc_data->SetString("version", iterator->version);
       proc_data->SetString("product_name", iterator->product_name);
       proc_data->SetInteger("num_processes", iterator->num_processes);
       proc_data->SetBoolean("is_diagnostics", iterator->is_diagnostics);
 
@@ skipping 10 matching lines @@
       // Renderer type, if this is a renderer process.
       std::string renderer_type = "Unknown";
       if (iterator->renderer_type !=
           ProcessMemoryInformation::RENDERER_UNKNOWN) {
         renderer_type = ProcessMemoryInformation::GetRendererTypeNameInEnglish(
             iterator->renderer_type);
       }
       proc_data->SetString("renderer_type", renderer_type);
 
       // Titles associated with this process.
-      ListValue* titles = new ListValue();
+      base::ListValue* titles = new base::ListValue();
       for (size_t title_index = 0; title_index < iterator->titles.size();
-           ++title_index)
-        titles->Append(Value::CreateStringValue(iterator->titles[title_index]));
+           ++title_index) {
+        titles->Append(
+            base::Value::CreateStringValue(iterator->titles[title_index]));
+      }
       proc_data->Set("titles", titles);
 
       proc_list->Append(proc_data);
     }
     browser_data->Set("processes", proc_list);
 
     browser_proc_list->Append(browser_data);
   }
   return_value->Set("browsers", browser_proc_list);
 
@@ skipping 26 matching lines @@
 
   base::ProcessId updated_renderer_id =
       *(content::Source<base::ProcessId>(source).ptr());
   // Only return information for the renderer ID we're interested in.
   if (renderer_id_ != updated_renderer_id)
     return;
 
   ChromeRenderMessageFilter::V8HeapStatsDetails* v8_heap_details =
       content::Details<ChromeRenderMessageFilter::V8HeapStatsDetails>(details)
           .ptr();
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
   return_value->SetInteger("renderer_id", updated_renderer_id);
   return_value->SetInteger("v8_memory_allocated",
                            v8_heap_details->v8_memory_allocated());
   return_value->SetInteger("v8_memory_used",
                            v8_heap_details->v8_memory_used());
 
   if (automation_.get()) {
     AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendSuccess(return_value.get());
   }
@@ skipping 29 matching lines @@
   if (renderer_id_ != updated_renderer_id)
     return;
 
   ChromeRenderMessageFilter::FPSDetails* fps_details =
       content::Details<ChromeRenderMessageFilter::FPSDetails>(details).ptr();
   // Only return information for the routing id of the host render view we're
   // interested in.
   if (routing_id_ != fps_details->routing_id())
     return;
 
-  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
   return_value->SetInteger("renderer_id", updated_renderer_id);
   return_value->SetInteger("routing_id", fps_details->routing_id());
   return_value->SetDouble("fps", fps_details->fps());
   if (automation_.get()) {
     AutomationJSONReply(automation_.get(), reply_message_.release())
         .SendSuccess(return_value.get());
   }
   delete this;
 }
 
@@ skipping 161 matching lines @@
       if (automation_.get()) {
         AutomationJSONReply(automation_.get(), reply_message_.release())
             .SendSuccess(NULL);
       }
       delete this;
     }
   } else {
     NOTREACHED();
   }
 }