Make TaskManager not use ChildProcessInfo. After this change, I will make BrowserChildProcessHost...

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 728 matching lines @@
       return;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerChildProcessResource class
 ////////////////////////////////////////////////////////////////////////////////
 SkBitmap* TaskManagerChildProcessResource::default_icon_ = NULL;
 
 TaskManagerChildProcessResource::TaskManagerChildProcessResource(
-    const ChildProcessInfo& child_proc)
-    : child_process_(child_proc),
-      title_(),
+    content::ProcessType type,
+    const string16& name,
+    base::ProcessHandle handle)
+    : type_(type),
+      name_(name),
+      handle_(handle),
       network_usage_support_(false) {
   // We cache the process id because it's not cheap to calculate, and it won't
   // be available when we get the plugin disconnected notification.
-  pid_ = child_proc.pid();
+  pid_ = base::GetProcId(handle);
   if (!default_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     default_icon_ = rb.GetBitmapNamed(IDR_PLUGIN);
     // TODO(jabdelmalek): use different icon for web workers.
   }
 }
 
 TaskManagerChildProcessResource::~TaskManagerChildProcessResource() {
 }
 
 // TaskManagerResource methods:
 string16 TaskManagerChildProcessResource::GetTitle() const {
   if (title_.empty())
     title_ = GetLocalizedTitle();
 
   return title_;
 }
 
 string16 TaskManagerChildProcessResource::GetProfileName() const {
   return string16();
 }
 
 SkBitmap TaskManagerChildProcessResource::GetIcon() const {
   return *default_icon_;
 }
 
 base::ProcessHandle TaskManagerChildProcessResource::GetProcess() const {
-  return child_process_.handle();
+  return handle_;
 }
 
 TaskManager::Resource::Type TaskManagerChildProcessResource::GetType() const {
   // Translate types to TaskManager::ResourceType, since ChildProcessInfo's type
   // is not available for all TaskManager resources.
-  switch (child_process_.type()) {
+  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:
       return TaskManager::Resource::UTILITY;
     case content::PROCESS_TYPE_PROFILE_IMPORT:
@@ skipping 11 matching lines @@
 
 bool TaskManagerChildProcessResource::SupportNetworkUsage() const {
   return network_usage_support_;
 }
 
 void TaskManagerChildProcessResource::SetSupportNetworkUsage() {
   network_usage_support_ = true;
 }
 
 string16 TaskManagerChildProcessResource::GetLocalizedTitle() const {
-  string16 title = child_process_.name();
+  string16 title = name_;
   if (title.empty()) {
-    switch (child_process_.type()) {
+    switch (type_) {
       case content::PROCESS_TYPE_PLUGIN:
       case content::PROCESS_TYPE_PPAPI_PLUGIN:
       case content::PROCESS_TYPE_PPAPI_BROKER:
         title = l10n_util::GetStringUTF16(IDS_TASK_MANAGER_UNKNOWN_PLUGIN_NAME);
         break;
       default:
         // Nothing to do for non-plugin processes.
         break;
     }
   }
 
   // Explicitly mark name as LTR if there is no strong RTL character,
   // to avoid the wrong concatenation result similar to "!Yahoo Mail: the
   // best web-based Email: NIGULP", in which "NIGULP" stands for the Hebrew
   // or Arabic word for "plugin".
   base::i18n::AdjustStringForLocaleDirection(&title);
 
-  switch (child_process_.type()) {
+  switch (type_) {
     case content::PROCESS_TYPE_UTILITY:
       return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_UTILITY_PREFIX);
 
     case content::PROCESS_TYPE_PROFILE_IMPORT:
       return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_UTILITY_PREFIX);
 
     case content::PROCESS_TYPE_GPU:
       return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_GPU_PREFIX);
 
     case content::PROCESS_TYPE_NACL_BROKER:
       return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NACL_BROKER_PREFIX);
 
     case content::PROCESS_TYPE_PLUGIN:
     case content::PROCESS_TYPE_PPAPI_PLUGIN:
-      return l10n_util::GetStringFUTF16(
-          IDS_TASK_MANAGER_PLUGIN_PREFIX, title, child_process_.version());
+      return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_PLUGIN_PREFIX, title);
 
     case content::PROCESS_TYPE_PPAPI_BROKER:
       return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_PLUGIN_BROKER_PREFIX,
-                                        title, child_process_.version());
+                                        title);
 
     case content::PROCESS_TYPE_NACL_LOADER:
       return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_NACL_PREFIX, title);
 
     // These types don't need display names or get them from elsewhere.
     case content::PROCESS_TYPE_BROWSER:
     case content::PROCESS_TYPE_RENDERER:
     case content::PROCESS_TYPE_ZYGOTE:
     case content::PROCESS_TYPE_SANDBOX_HELPER:
     case content::PROCESS_TYPE_MAX:
@@ skipping 10 matching lines @@
 
   return title;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerChildProcessResourceProvider class
 ////////////////////////////////////////////////////////////////////////////////
 
 TaskManagerChildProcessResourceProvider::
     TaskManagerChildProcessResourceProvider(TaskManager* task_manager)
-    : updating_(false),
-      task_manager_(task_manager) {
+    : task_manager_(task_manager),
+      updating_(false) {
 }
 
 TaskManagerChildProcessResourceProvider::
     ~TaskManagerChildProcessResourceProvider() {
 }
 
 TaskManager::Resource* TaskManagerChildProcessResourceProvider::GetResource(
     int origin_pid,
     int render_process_host_id,
     int routing_id) {
-  std::map<int, TaskManagerChildProcessResource*>::iterator iter =
-      pid_to_resources_.find(origin_pid);
+  PidResourceMap::iterator iter = pid_to_resources_.find(origin_pid);
   if (iter != pid_to_resources_.end())
     return iter->second;
   else
     return NULL;
 }
 
 void TaskManagerChildProcessResourceProvider::StartUpdating() {
   DCHECK(!updating_);
   updating_ = true;
 
@@ skipping 22 matching lines @@
   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();
-  existing_child_process_info_.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();
   switch (type) {
     case content::NOTIFICATION_CHILD_PROCESS_HOST_CONNECTED:
-      Add(*content::Details<ChildProcessInfo>(details).ptr());
+      Add(data);
       break;
     case content::NOTIFICATION_CHILD_PROCESS_HOST_DISCONNECTED:
-      Remove(*content::Details<ChildProcessInfo>(details).ptr());
+      Remove(data);
       break;
     default:
       NOTREACHED() << "Unexpected notification.";
       return;
   }
 }
 
 void TaskManagerChildProcessResourceProvider::Add(
-    const ChildProcessInfo& child_process_info) {
+    const ChildProcessData& child_process_data) {
   if (!updating_)
     return;
   // Workers are handled by TaskManagerWorkerResourceProvider.
-  if (child_process_info.type() == content::PROCESS_TYPE_WORKER)
+  if (child_process_data.type == content::PROCESS_TYPE_WORKER)
     return;
-  std::map<ChildProcessInfo, TaskManagerChildProcessResource*>::
-      const_iterator iter = resources_.find(child_process_info);
-  if (iter != resources_.end()) {
+  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_info);
+  AddToTaskManager(child_process_data);
 }
 
 void TaskManagerChildProcessResourceProvider::Remove(
-    const ChildProcessInfo& child_process_info) {
+    const ChildProcessData& child_process_data) {
   if (!updating_)
     return;
-  if (child_process_info.type() == content::PROCESS_TYPE_WORKER)
+  if (child_process_data.type == content::PROCESS_TYPE_WORKER)
     return;
-  std::map<ChildProcessInfo, TaskManagerChildProcessResource*>
-      ::iterator iter = resources_.find(child_process_info);
+  ChildProcessMap::iterator iter = resources_.find(child_process_data.handle);
   if (iter == resources_.end()) {
     // ChildProcessInfo 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.
-  std::map<int, TaskManagerChildProcessResource*>::iterator pid_iter =
+  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 ChildProcessInfo& child_process_info) {
+    const ChildProcessData& child_process_data) {
   TaskManagerChildProcessResource* resource =
-      new TaskManagerChildProcessResource(child_process_info);
-  resources_[child_process_info] = 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;
   for (BrowserChildProcessHost::Iterator iter; !iter.Done(); ++iter) {
     // Only add processes which are already started, since we need their handle.
-    if ((*iter)->handle() != base::kNullProcessHandle)
-      existing_child_process_info_.push_back(**iter);
+    if ((*iter)->handle() == base::kNullProcessHandle)
+      continue;
+    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,
-          this));
+          this, child_processes));
 }
 
 // This is called on the UI thread.
-void TaskManagerChildProcessResourceProvider::ChildProcessInfoRetreived() {
-  std::vector<ChildProcessInfo>::const_iterator iter;
-  for (iter = existing_child_process_info_.begin();
-       iter != existing_child_process_info_.end(); ++iter) {
-    Add(*iter);
-  }
-  existing_child_process_info_.clear();
+void TaskManagerChildProcessResourceProvider::ChildProcessInfoRetreived(
+    const std::vector<ChildProcessData>& child_processes) {
+  for (size_t i = 0; i < child_processes.size(); ++i)
+    Add(child_processes[i]);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerExtensionProcessResource class
 ////////////////////////////////////////////////////////////////////////////////
 
 SkBitmap* TaskManagerExtensionProcessResource::default_icon_ = NULL;
 
 TaskManagerExtensionProcessResource::TaskManagerExtensionProcessResource(
     ExtensionHost* extension_host)
@@ skipping 332 matching lines @@
 
   return &resource_;
 }
 
 void TaskManagerBrowserProcessResourceProvider::StartUpdating() {
   task_manager_->AddResource(&resource_);
 }
 
 void TaskManagerBrowserProcessResourceProvider::StopUpdating() {
 }