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

chrome/browser/extensions/api/processes/processes_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/processes/processes_api.h"
 
 #include "base/callback.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop.h"
@@ skipping 26 matching lines @@
 
 namespace extensions {
 
 namespace keys = processes_api_constants;
 namespace errors = processes_api_constants;
 
 namespace {
 
 #if defined(ENABLE_TASK_MANAGER)
 
-DictionaryValue* CreateCacheData(
+base::DictionaryValue* CreateCacheData(
     const WebKit::WebCache::ResourceTypeStat& stat) {
 
-  DictionaryValue* cache = new DictionaryValue();
+  base::DictionaryValue* cache = new base::DictionaryValue();
   cache->SetDouble(keys::kCacheSize, static_cast<double>(stat.size));
   cache->SetDouble(keys::kCacheLiveSize, static_cast<double>(stat.liveSize));
   return cache;
 }
 
-void SetProcessType(DictionaryValue* result,
+void SetProcessType(base::DictionaryValue* result,
                     TaskManagerModel* model,
                     int index) {
   // Determine process type.
   std::string type = keys::kProcessTypeOther;
   task_manager::Resource::Type resource_type = model->GetResourceType(index);
   switch (resource_type) {
     case task_manager::Resource::BROWSER:
       type = keys::kProcessTypeBrowser;
       break;
     case task_manager::Resource::RENDERER:
@@ skipping 25 matching lines @@
     case task_manager::Resource::SANDBOX_HELPER:
     case task_manager::Resource::UNKNOWN:
       type = keys::kProcessTypeOther;
       break;
     default:
       NOTREACHED() << "Unknown resource type.";
   }
   result->SetString(keys::kTypeKey, type);
 }
 
-ListValue* GetTabsForProcess(int process_id) {
-  ListValue* tabs_list = new ListValue();
+base::ListValue* GetTabsForProcess(int process_id) {
+  base::ListValue* tabs_list = new base::ListValue();
 
   // The tabs list only makes sense for render processes, so if we don't find
   // one, just return the empty list.
   content::RenderProcessHost* rph =
       content::RenderProcessHost::FromID(process_id);
   if (rph == NULL)
     return tabs_list;
 
   int tab_id = -1;
   // We need to loop through all the RVHs to ensure we collect the set of all
@@ skipping 16 matching lines @@
         tabs_list->Append(Value::CreateIntegerValue(tab_id));
     }
   }
 
   return tabs_list;
 }
 
 // This function creates a Process object to be returned to the extensions
 // using these APIs. For memory details, which are not added by this function,
 // the callers need to use AddMemoryDetails.
-DictionaryValue* CreateProcessFromModel(int process_id,
-                                        TaskManagerModel* model,
-                                        int index,
-                                        bool include_optional) {
-  DictionaryValue* result = new DictionaryValue();
+base::DictionaryValue* CreateProcessFromModel(int process_id,
+                                              TaskManagerModel* model,
+                                              int index,
+                                              bool include_optional) {
+  base::DictionaryValue* result = new base::DictionaryValue();
   size_t mem;
 
   result->SetInteger(keys::kIdKey, process_id);
   result->SetInteger(keys::kOsProcessIdKey, model->GetProcessId(index));
   SetProcessType(result, model, index);
   result->SetString(keys::kProfileKey,
       model->GetResourceProfileName(index));
 
   result->Set(keys::kTabsListKey, GetTabsForProcess(process_id));
 
@@ skipping 38 matching lines @@
   }
   result->SetDouble(keys::kFPSKey, static_cast<double>(fps));
   result->SetDouble(keys::kNetworkKey, static_cast<double>(net));
 
   return result;
 }
 
 // Since memory details are expensive to gather, we don't do it by default.
 // This function is a helper to add memory details data to an existing
 // Process object representation.
-void AddMemoryDetails(DictionaryValue* result,
+void AddMemoryDetails(base::DictionaryValue* result,
                       TaskManagerModel* model,
                       int index) {
   size_t mem;
   int64 pr_mem = model->GetPrivateMemory(index, &mem) ?
       static_cast<int64>(mem) : -1;
   result->SetDouble(keys::kPrivateMemoryKey, static_cast<double>(pr_mem));
 }
 
 #endif  // defined(ENABLE_TASK_MANAGER)
 
@@ skipping 86 matching lines @@
   std::string event(keys::kOnCreated);
   if (!HasEventListeners(event))
     return;
 
   // If the item being added is not the first one in the group, find the base
   // index and use it for retrieving the process data.
   if (!model_->IsResourceFirstInGroup(start)) {
     index = model_->GetGroupIndexForResource(start);
   }
 
-  scoped_ptr<ListValue> args(new ListValue());
-  DictionaryValue* process = CreateProcessFromModel(
+  scoped_ptr<base::ListValue> args(new base::ListValue());
+  base::DictionaryValue* process = CreateProcessFromModel(
       model_->GetUniqueChildProcessId(index), model_, index, false);
   DCHECK(process != NULL);
 
   if (process == NULL)
     return;
 
   args->Append(process);
 
   DispatchEvent(keys::kOnCreated, args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
@@ skipping 10 matching lines @@
 
   // We need to know which type of onUpdated events to fire and whether to
   // collect memory or not.
   std::string updated_event(keys::kOnUpdated);
   std::string updated_event_memory(keys::kOnUpdatedWithMemory);
   bool updated = HasEventListeners(updated_event);
   bool updated_memory = HasEventListeners(updated_event_memory);
 
   DCHECK(updated || updated_memory);
 
-  IDMap<DictionaryValue> processes_map;
+  IDMap<base::DictionaryValue> processes_map;
   for (int i = start; i < start + length; i++) {
     if (model_->IsResourceFirstInGroup(i)) {
       int id = model_->GetUniqueChildProcessId(i);
-      DictionaryValue* process = CreateProcessFromModel(id, model_, i, true);
+      base::DictionaryValue* process = CreateProcessFromModel(id, model_, i, true);
       processes_map.AddWithID(process, i);
     }
   }
 
   int id;
   std::string idkey(keys::kIdKey);
-  DictionaryValue* processes = new DictionaryValue();
+  base::DictionaryValue* processes = new base::DictionaryValue();
 
   if (updated) {
-    IDMap<DictionaryValue>::iterator it(&processes_map);
+    IDMap<base::DictionaryValue>::iterator it(&processes_map);
     for (; !it.IsAtEnd(); it.Advance()) {
       if (!it.GetCurrentValue()->GetInteger(idkey, &id))
         continue;
 
       // Store each process indexed by the string version of its id.
       processes->Set(base::IntToString(id), it.GetCurrentValue());
     }
 
-    scoped_ptr<ListValue> args(new ListValue());
+    scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(processes);
     DispatchEvent(keys::kOnUpdated, args.Pass());
   }
 
   if (updated_memory) {
-    IDMap<DictionaryValue>::iterator it(&processes_map);
+    IDMap<base::DictionaryValue>::iterator it(&processes_map);
     for (; !it.IsAtEnd(); it.Advance()) {
       if (!it.GetCurrentValue()->GetInteger(idkey, &id))
         continue;
 
       AddMemoryDetails(it.GetCurrentValue(), model_, it.GetCurrentKey());
 
       // Store each process indexed by the string version of its id if we didn't
       // already insert it as part of the onUpdated processing above.
       if (!updated)
         processes->Set(base::IntToString(id), it.GetCurrentValue());
     }
 
-    scoped_ptr<ListValue> args(new ListValue());
+    scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(processes);
     DispatchEvent(keys::kOnUpdatedWithMemory, args.Pass());
   }
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::OnItemsToBeRemoved(int start, int length) {
 #if defined(ENABLE_TASK_MANAGER)
   DCHECK_EQ(length, 1);
 
   // Process exit for renderer processes has the data about exit code and
   // termination status, therefore we will rely on notifications and not on
   // the Task Manager data. We do use the rest of this method for non-renderer
   // processes.
   if (model_->GetResourceType(start) == task_manager::Resource::RENDERER)
     return;
 
   // The callback function parameters.
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
 
   // First arg: The id of the process that was closed.
   args->Append(Value::CreateIntegerValue(
       model_->GetUniqueChildProcessId(start)));
 
   // Second arg: The exit type for the process.
   args->Append(Value::CreateIntegerValue(0));
 
   // Third arg: The exit code for the process.
   args->Append(Value::CreateIntegerValue(0));
 
   DispatchEvent(keys::kOnExited, args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::ProcessHangEvent(content::RenderWidgetHost* widget) {
 #if defined(ENABLE_TASK_MANAGER)
   std::string event(keys::kOnUnresponsive);
   if (!HasEventListeners(event))
     return;
 
-  DictionaryValue* process = NULL;
+  base::DictionaryValue* process = NULL;
   int count = model_->ResourceCount();
   int id = widget->GetProcess()->GetID();
 
   for (int i = 0; i < count; ++i) {
     if (model_->IsResourceFirstInGroup(i)) {
       if (id == model_->GetUniqueChildProcessId(i)) {
         process = CreateProcessFromModel(id, model_, i, false);
         break;
       }
     }
   }
 
   DCHECK(process);
   if (process == NULL)
     return;
 
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(process);
 
   DispatchEvent(keys::kOnUnresponsive, args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::ProcessClosedEvent(
     content::RenderProcessHost* rph,
     content::RenderProcessHost::RendererClosedDetails* details) {
 #if defined(ENABLE_TASK_MANAGER)
   // The callback function parameters.
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
 
   // First arg: The id of the process that was closed.
   args->Append(Value::CreateIntegerValue(rph->GetID()));
 
   // Second arg: The exit type for the process.
   args->Append(Value::CreateIntegerValue(details->status));
 
   // Third arg: The exit code for the process.
   args->Append(Value::CreateIntegerValue(details->exit_code));
 
   DispatchEvent(keys::kOnExited, args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
-void ProcessesEventRouter::DispatchEvent(const char* event_name,
-                                         scoped_ptr<ListValue> event_args) {
+void ProcessesEventRouter::DispatchEvent(
+    const char* event_name,
+    scoped_ptr<base::ListValue> event_args) {
   if (extensions::ExtensionSystem::Get(profile_)->event_router()) {
     scoped_ptr<extensions::Event> event(new extensions::Event(
         event_name, event_args.Pass()));
     extensions::ExtensionSystem::Get(profile_)->event_router()->
         BroadcastEvent(event.Pass());
   }
 }
 
 bool ProcessesEventRouter::HasEventListeners(const std::string& event_name) {
   extensions::EventRouter* router =
@@ skipping 244 matching lines @@
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(type, chrome::NOTIFICATION_TASK_MANAGER_CHILD_PROCESSES_DATA_READY);
   registrar_.RemoveAll();
   GatherProcessInfo();
 }
 
 void GetProcessInfoFunction::GatherProcessInfo() {
 #if defined(ENABLE_TASK_MANAGER)
   TaskManagerModel* model = TaskManager::GetInstance()->model();
-  DictionaryValue* processes = new DictionaryValue();
+  base::DictionaryValue* processes = new base::DictionaryValue();
 
   // If there are no process IDs specified, it means we need to return all of
   // the ones we know of.
   if (process_ids_.size() == 0) {
     int resources = model->ResourceCount();
     for (int i = 0; i < resources; ++i) {
       if (model->IsResourceFirstInGroup(i)) {
         int id = model->GetUniqueChildProcessId(i);
-        DictionaryValue* d = CreateProcessFromModel(id, model, i, false);
+        base::DictionaryValue* d = CreateProcessFromModel(id, model, i, false);
         if (memory_)
           AddMemoryDetails(d, model, i);
         processes->Set(base::IntToString(id), d);
       }
     }
   } else {
     int resources = model->ResourceCount();
     for (int i = 0; i < resources; ++i) {
       if (model->IsResourceFirstInGroup(i)) {
         int id = model->GetUniqueChildProcessId(i);
         std::vector<int>::iterator proc_id = std::find(process_ids_.begin(),
                                                        process_ids_.end(), id);
         if (proc_id != process_ids_.end()) {
-          DictionaryValue* d = CreateProcessFromModel(id, model, i, false);
+          base::DictionaryValue* d =
+              CreateProcessFromModel(id, model, i, false);
           if (memory_)
             AddMemoryDetails(d, model, i);
           processes->Set(base::IntToString(id), d);
 
           process_ids_.erase(proc_id);
           if (process_ids_.size() == 0)
             break;
         }
       }
     }
     DCHECK_EQ(process_ids_.size(), 0U);
   }
 
   SetResult(processes);
   SendResponse(true);
 
   // Balance the AddRef in the RunImpl.
   Release();
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 }  // namespace extensions