Get rid of the ChildProcessInfo class. It was carrying unnecessary data, and the fact that some p...

chrome/browser/task_manager/task_manager_resource_providers.cc

 // Copyright (c) 2011 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/task_manager/task_manager_resource_providers.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 769 matching lines @@
 
 SkBitmap TaskManagerChildProcessResource::GetIcon() const {
   return *default_icon_;
 }
 
 base::ProcessHandle TaskManagerChildProcessResource::GetProcess() const {
   return handle_;
 }
 
 TaskManager::Resource::Type TaskManagerChildProcessResource::GetType() const {
-  // Translate types to TaskManager::ResourceType, since ChildProcessInfo's type
+  // Translate types to TaskManager::ResourceType, since ChildProcessData's type
   // is not available for all TaskManager resources.
   switch (type_) {
     case content::PROCESS_TYPE_PLUGIN:
     case content::PROCESS_TYPE_PPAPI_PLUGIN:
     case content::PROCESS_TYPE_PPAPI_BROKER:
       return TaskManager::Resource::PLUGIN;
     case content::PROCESS_TYPE_NACL_LOADER:
     case content::PROCESS_TYPE_NACL_BROKER:
       return TaskManager::Resource::NACL;
     case content::PROCESS_TYPE_UTILITY:
@@ skipping 116 matching lines @@
   // Register for notifications to get new child processes.
   registrar_.Add(this, content::NOTIFICATION_CHILD_PROCESS_HOST_CONNECTED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_CHILD_PROCESS_HOST_DISCONNECTED,
                  content::NotificationService::AllBrowserContextsAndSources());
 
   // Get the existing child processes.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
-          &TaskManagerChildProcessResourceProvider::RetrieveChildProcessInfo,
+          &TaskManagerChildProcessResourceProvider::RetrieveChildProcessData,
           this));
 }
 
 void TaskManagerChildProcessResourceProvider::StopUpdating() {
   DCHECK(updating_);
   updating_ = false;
 
   // Unregister for notifications to get new plugin processes.
   registrar_.Remove(
       this, content::NOTIFICATION_CHILD_PROCESS_HOST_CONNECTED,
       content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Remove(
       this,
       content::NOTIFICATION_CHILD_PROCESS_HOST_DISCONNECTED,
       content::NotificationService::AllBrowserContextsAndSources());
 
   // Delete all the resources.
   STLDeleteContainerPairSecondPointers(resources_.begin(), resources_.end());
 
   resources_.clear();
   pid_to_resources_.clear();
 }
 
 void TaskManagerChildProcessResourceProvider::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  content::Details<ChildProcessInfo> child_details(details);
-      ChildProcessData data;
-      data.type = child_details->type();
-      data.name = child_details->name();
-      data.handle = child_details->handle();
+  content::ChildProcessData data =
+      *content::Details<content::ChildProcessData>(details).ptr();
   switch (type) {
     case content::NOTIFICATION_CHILD_PROCESS_HOST_CONNECTED:
       Add(data);
       break;
     case content::NOTIFICATION_CHILD_PROCESS_HOST_DISCONNECTED:
       Remove(data);
       break;
     default:
       NOTREACHED() << "Unexpected notification.";
       return;
   }
 }
 
 void TaskManagerChildProcessResourceProvider::Add(
-    const ChildProcessData& child_process_data) {
+    const content::ChildProcessData& child_process_data) {
   if (!updating_)
     return;
   // Workers are handled by TaskManagerWorkerResourceProvider.
   if (child_process_data.type == content::PROCESS_TYPE_WORKER)
     return;
   if (resources_.count(child_process_data.handle)) {
     // The case may happen that we have added a child_process_info as part of
     // the iteration performed during StartUpdating() call but the notification
     // that it has connected was not fired yet. So when the notification
     // happens, we already know about this plugin and just ignore it.
     return;
   }
   AddToTaskManager(child_process_data);
 }
 
 void TaskManagerChildProcessResourceProvider::Remove(
-    const ChildProcessData& child_process_data) {
+    const content::ChildProcessData& child_process_data) {
   if (!updating_)
     return;
   if (child_process_data.type == content::PROCESS_TYPE_WORKER)
     return;
   ChildProcessMap::iterator iter = resources_.find(child_process_data.handle);
   if (iter == resources_.end()) {
-    // ChildProcessInfo disconnection notifications are asynchronous, so we
+    // ChildProcessData disconnection notifications are asynchronous, so we
     // might be notified for a plugin we don't know anything about (if it was
     // closed before the task manager was shown and destroyed after that).
     return;
   }
   // Remove the resource from the Task Manager.
   TaskManagerChildProcessResource* resource = iter->second;
   task_manager_->RemoveResource(resource);
   // Remove it from the provider.
   resources_.erase(iter);
   // Remove it from our pid map.
   PidResourceMap::iterator pid_iter =
       pid_to_resources_.find(resource->process_id());
   DCHECK(pid_iter != pid_to_resources_.end());
   if (pid_iter != pid_to_resources_.end())
     pid_to_resources_.erase(pid_iter);
 
   // Finally, delete the resource.
   delete resource;
 }
 
 void TaskManagerChildProcessResourceProvider::AddToTaskManager(
-    const ChildProcessData& child_process_data) {
+    const content::ChildProcessData& child_process_data) {
   TaskManagerChildProcessResource* resource =
       new TaskManagerChildProcessResource(
           child_process_data.type,
           child_process_data.name,
           child_process_data.handle);
   resources_[child_process_data.handle] = resource;
   pid_to_resources_[resource->process_id()] = resource;
   task_manager_->AddResource(resource);
 }
 
-// The ChildProcessInfo::Iterator has to be used from the IO thread.
-void TaskManagerChildProcessResourceProvider::RetrieveChildProcessInfo() {
-  std::vector<ChildProcessData> child_processes;
+// The ChildProcessData::Iterator has to be used from the IO thread.
+void TaskManagerChildProcessResourceProvider::RetrieveChildProcessData() {
+  std::vector<content::ChildProcessData> child_processes;
   for (BrowserChildProcessHost::Iterator iter; !iter.Done(); ++iter) {
     // Only add processes which are already started, since we need their handle.
     if ((*iter)->handle() == base::kNullProcessHandle)
       continue;
-    ChildProcessData data;
+    content::ChildProcessData data;
     data.type = (*iter)->type();
     data.name = (*iter)->name();
     data.handle = (*iter)->handle();
     child_processes.push_back(data);
   }
   // Now notify the UI thread that we have retrieved information about child
   // processes.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
-          &TaskManagerChildProcessResourceProvider::ChildProcessInfoRetreived,
+          &TaskManagerChildProcessResourceProvider::ChildProcessDataRetreived,
           this, child_processes));
 }
 
 // This is called on the UI thread.
-void TaskManagerChildProcessResourceProvider::ChildProcessInfoRetreived(
-    const std::vector<ChildProcessData>& child_processes) {
+void TaskManagerChildProcessResourceProvider::ChildProcessDataRetreived(
+    const std::vector<content::ChildProcessData>& child_processes) {
   for (size_t i = 0; i < child_processes.size(); ++i)
     Add(child_processes[i]);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerExtensionProcessResource class
 ////////////////////////////////////////////////////////////////////////////////
 
 SkBitmap* TaskManagerExtensionProcessResource::default_icon_ = NULL;
 
@@ skipping 334 matching lines @@
 
   return &resource_;
 }
 
 void TaskManagerBrowserProcessResourceProvider::StartUpdating() {
   task_manager_->AddResource(&resource_);
 }
 
 void TaskManagerBrowserProcessResourceProvider::StopUpdating() {
 }