Fix Task Manager to correctly display network usage of plug-in processes.

chrome/browser/task_manager/task_manager_resource_providers.cc

 // Copyright (c) 2010 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 "build/build_config.h"
 
 #include "base/basictypes.h"
 #include "base/file_version_info.h"
@@ skipping 62 matching lines @@
 // TaskManagerRendererResource class
 ////////////////////////////////////////////////////////////////////////////////
 TaskManagerRendererResource::TaskManagerRendererResource(
     base::ProcessHandle process, RenderViewHost* render_view_host)
     : process_(process),
       render_view_host_(render_view_host),
       pending_stats_update_(false),
       v8_memory_allocated_(0),
       v8_memory_used_(0),
       pending_v8_memory_allocated_update_(false) {
-  // We cache the process and pid as when a Tab/BackgroundContents is closed the
-  // process reference becomes NULL and the TaskManager still needs it.
-  pid_ = base::GetProcId(process_);
   stats_.images.size = 0;
   stats_.cssStyleSheets.size = 0;
   stats_.scripts.size = 0;
   stats_.xslStyleSheets.size = 0;
   stats_.fonts.size = 0;
 }
 
 TaskManagerRendererResource::~TaskManagerRendererResource() {
 }
 
@@ skipping 128 matching lines @@
     TaskManagerTabContentsResourceProvider(TaskManager* task_manager)
     :  updating_(false),
        task_manager_(task_manager) {
 }
 
 TaskManagerTabContentsResourceProvider::
     ~TaskManagerTabContentsResourceProvider() {
 }
 
 TaskManager::Resource* TaskManagerTabContentsResourceProvider::GetResource(
-    int origin_pid,
+    int origin_child_id,
     int render_process_host_id,
     int routing_id) {
+  if (origin_child_id != render_process_host_id)
+    return NULL;
 
   TabContents* tab_contents =
       tab_util::GetTabContentsByID(render_process_host_id, routing_id);
   if (!tab_contents)  // Not one of our resource.
     return NULL;
 
-  base::ProcessHandle process_handle =
-      tab_contents->GetRenderProcessHost()->GetHandle();
-  if (!process_handle) {
-    // We should not be holding on to a dead tab (it should have been removed
-    // through the NOTIFY_TAB_CONTENTS_DISCONNECTED notification.
-    NOTREACHED();
-    return NULL;
-  }
-
-  int pid = base::GetProcId(process_handle);
-  if (pid != origin_pid)
-    return NULL;
-
   std::map<TabContents*, TaskManagerTabContentsResource*>::iterator
       res_iter = resources_.find(tab_contents);
   if (res_iter == resources_.end()) {
     // Can happen if the tab was closed while a network request was being
     // performed.
     return NULL;
   }
   return res_iter->second;
 }
 
@@ skipping 178 matching lines @@
     : updating_(false),
       task_manager_(task_manager) {
 }
 
 TaskManagerBackgroundContentsResourceProvider::
     ~TaskManagerBackgroundContentsResourceProvider() {
 }
 
 TaskManager::Resource*
 TaskManagerBackgroundContentsResourceProvider::GetResource(
-    int origin_pid,
+    int origin_child_id,
     int render_process_host_id,
     int routing_id) {
+  if (origin_child_id != render_process_host_id)
+    return NULL;
 
   BackgroundContents* contents = BackgroundContents::GetBackgroundContentsByID(
       render_process_host_id, routing_id);
   if (!contents)  // This resource no longer exists.
     return NULL;
 
-  base::ProcessHandle process_handle =
-      contents->render_view_host()->process()->GetHandle();
-  if (!process_handle) // Process crashed.
-    return NULL;
-
-  int pid = base::GetProcId(process_handle);
-  if (pid != origin_pid)
-    return NULL;
-
   std::map<BackgroundContents*,
       TaskManagerBackgroundContentsResource*>::iterator res_iter =
       resources_.find(contents);
   if (res_iter == resources_.end())
     // Can happen if the page went away while a network request was being
     // performed.
     return NULL;
 
   return res_iter->second;
 }
@@ skipping 152 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerChildProcessResource class
 ////////////////////////////////////////////////////////////////////////////////
 SkBitmap* TaskManagerChildProcessResource::default_icon_ = NULL;
 
 TaskManagerChildProcessResource::TaskManagerChildProcessResource(
     const ChildProcessInfo& child_proc)
     : child_process_(child_proc),
       title_(),
       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.id();
   if (!default_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     default_icon_ = rb.GetBitmapNamed(IDR_PLUGIN);
     // TODO(jabdelmalek): use different icon for web workers.
   }
 }
 
 TaskManagerChildProcessResource::~TaskManagerChildProcessResource() {
 }
 
@@ skipping 59 matching lines @@
     TaskManagerChildProcessResourceProvider(TaskManager* task_manager)
     : updating_(false),
       task_manager_(task_manager) {
 }
 
 TaskManagerChildProcessResourceProvider::
     ~TaskManagerChildProcessResourceProvider() {
 }
 
 TaskManager::Resource* TaskManagerChildProcessResourceProvider::GetResource(
-    int origin_pid,
+    int origin_child_id,
     int render_process_host_id,
     int routing_id) {
   std::map<int, TaskManagerChildProcessResource*>::iterator iter =
-      pid_to_resources_.find(origin_pid);
-  if (iter != pid_to_resources_.end())
+      child_id_to_resources_.find(origin_child_id);
+  if (iter != child_id_to_resources_.end())
     return iter->second;
   else
     return NULL;
 }
 
 void TaskManagerChildProcessResourceProvider::StartUpdating() {
   DCHECK(!updating_);
   updating_ = true;
 
   // Register for notifications to get new child processes.
@@ skipping 18 matching lines @@
   registrar_.Remove(this, NotificationType::CHILD_PROCESS_HOST_CONNECTED,
                     NotificationService::AllSources());
   registrar_.Remove(this,
                     NotificationType::CHILD_PROCESS_HOST_DISCONNECTED,
                     NotificationService::AllSources());
 
   // Delete all the resources.
   STLDeleteContainerPairSecondPointers(resources_.begin(), resources_.end());
 
   resources_.clear();
-  pid_to_resources_.clear();
+  child_id_to_resources_.clear();
   existing_child_process_info_.clear();
 }
 
 void TaskManagerChildProcessResourceProvider::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::CHILD_PROCESS_HOST_CONNECTED:
       Add(*Details<ChildProcessInfo>(details).ptr());
@@ skipping 33 matching lines @@
     // 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 =
-      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);
+  // Remove it from our child ID map.
+  std::map<int, TaskManagerChildProcessResource*>::iterator id_iter =
+      child_id_to_resources_.find(resource->id());
+  DCHECK(id_iter != child_id_to_resources_.end());
+  if (id_iter != child_id_to_resources_.end())
+    child_id_to_resources_.erase(id_iter);
 
   // Finally, delete the resource.
   delete resource;
 }
 
 void TaskManagerChildProcessResourceProvider::AddToTaskManager(
     const ChildProcessInfo& child_process_info) {
   TaskManagerChildProcessResource* resource =
       new TaskManagerChildProcessResource(child_process_info);
   resources_[child_process_info] = resource;
-  pid_to_resources_[resource->process_id()] = resource;
+  child_id_to_resources_[resource->id()] = resource;
   task_manager_->AddResource(resource);
 }
 
 // The ChildProcessInfo::Iterator has to be used from the IO thread.
 void TaskManagerChildProcessResourceProvider::RetrieveChildProcessInfo() {
   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);
   }
@@ skipping 22 matching lines @@
 SkBitmap* TaskManagerExtensionProcessResource::default_icon_ = NULL;
 
 TaskManagerExtensionProcessResource::TaskManagerExtensionProcessResource(
     ExtensionHost* extension_host)
     : extension_host_(extension_host) {
   if (!default_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     default_icon_ = rb.GetBitmapNamed(IDR_PLUGIN);
   }
   process_handle_ = extension_host_->render_process_host()->GetHandle();
-  pid_ = base::GetProcId(process_handle_);
   string16 extension_name = UTF8ToUTF16(GetExtension()->name());
   DCHECK(!extension_name.empty());
 
   int message_id = GetMessagePrefixID(GetExtension()->is_app(), true,
       extension_host_->profile()->IsOffTheRecord());
   title_ = UTF16ToWideHack(l10n_util::GetStringFUTF16(message_id,
                                                       extension_name));
+  id_ = extension_host->render_process_host()->id();
 }
 
 TaskManagerExtensionProcessResource::~TaskManagerExtensionProcessResource() {
 }
 
 std::wstring TaskManagerExtensionProcessResource::GetTitle() const {
   return title_;
 }
 
 SkBitmap TaskManagerExtensionProcessResource::GetIcon() const {
@@ skipping 34 matching lines @@
     TaskManagerExtensionProcessResourceProvider(TaskManager* task_manager)
     : task_manager_(task_manager),
       updating_(false) {
 }
 
 TaskManagerExtensionProcessResourceProvider::
     ~TaskManagerExtensionProcessResourceProvider() {
 }
 
 TaskManager::Resource* TaskManagerExtensionProcessResourceProvider::GetResource(
-    int origin_pid,
+    int origin_child_id,
     int render_process_host_id,
     int routing_id) {
   std::map<int, TaskManagerExtensionProcessResource*>::iterator iter =
-      pid_to_resources_.find(origin_pid);
-  if (iter != pid_to_resources_.end())
+      child_id_to_resources_.find(origin_child_id);
+  if (iter != child_id_to_resources_.end())
     return iter->second;
   else
     return NULL;
 }
 
 void TaskManagerExtensionProcessResourceProvider::StartUpdating() {
   DCHECK(!updating_);
   updating_ = true;
 
   // Add all the existing ExtensionHosts.
@@ skipping 39 matching lines @@
                     NotificationService::AllSources());
   registrar_.Remove(this, NotificationType::EXTENSION_PROCESS_TERMINATED,
                     NotificationService::AllSources());
   registrar_.Remove(this, NotificationType::EXTENSION_HOST_DESTROYED,
                     NotificationService::AllSources());
 
   // Delete all the resources.
   STLDeleteContainerPairSecondPointers(resources_.begin(), resources_.end());
 
   resources_.clear();
-  pid_to_resources_.clear();
+  child_id_to_resources_.clear();
 }
 
 void TaskManagerExtensionProcessResourceProvider::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::EXTENSION_PROCESS_CREATED:
       AddToTaskManager(Details<ExtensionHost>(details).ptr());
       break;
@@ skipping 10 matching lines @@
 void TaskManagerExtensionProcessResourceProvider::AddToTaskManager(
     ExtensionHost* extension_host) {
   // Don't add dead extension processes.
   if (!extension_host->IsRenderViewLive())
     return;
 
   TaskManagerExtensionProcessResource* resource =
       new TaskManagerExtensionProcessResource(extension_host);
   DCHECK(resources_.find(extension_host) == resources_.end());
   resources_[extension_host] = resource;
-  pid_to_resources_[resource->process_id()] = resource;
+  child_id_to_resources_[resource->id()] = resource;
   task_manager_->AddResource(resource);
 }
 
 void TaskManagerExtensionProcessResourceProvider::RemoveFromTaskManager(
     ExtensionHost* extension_host) {
   if (!updating_)
     return;
   std::map<ExtensionHost*, TaskManagerExtensionProcessResource*>
       ::iterator iter = resources_.find(extension_host);
   if (iter == resources_.end())
     return;
 
   // Remove the resource from the Task Manager.
   TaskManagerExtensionProcessResource* resource = iter->second;
   task_manager_->RemoveResource(resource);
 
   // Remove it from the provider.
   resources_.erase(iter);
 
-  // Remove it from our pid map.
-  std::map<int, TaskManagerExtensionProcessResource*>::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);
+  // Remove it from our child ID map.
+  std::map<int, TaskManagerExtensionProcessResource*>::iterator id_iter =
+      child_id_to_resources_.find(resource->id());
+  DCHECK(id_iter != child_id_to_resources_.end());
+  if (id_iter != child_id_to_resources_.end())
+    child_id_to_resources_.erase(id_iter);
 
   // Finally, delete the resource.
   delete resource;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerNotificationResource class
 ////////////////////////////////////////////////////////////////////////////////
 
 SkBitmap* TaskManagerNotificationResource::default_icon_ = NULL;
 
 TaskManagerNotificationResource::TaskManagerNotificationResource(
     BalloonHost* balloon_host)
     : balloon_host_(balloon_host) {
   if (!default_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     default_icon_ = rb.GetBitmapNamed(IDR_PLUGIN);
   }
   process_handle_ = balloon_host_->render_view_host()->process()->GetHandle();
-  pid_ = base::GetProcId(process_handle_);
   title_ = UTF16ToWide(l10n_util::GetStringFUTF16(
       IDS_TASK_MANAGER_NOTIFICATION_PREFIX,
       balloon_host_->GetSource()));
 }
 
 TaskManagerNotificationResource::~TaskManagerNotificationResource() {
 }
 
 std::wstring TaskManagerNotificationResource::GetTitle() const {
   return title_;
@@ skipping 23 matching lines @@
     TaskManagerNotificationResourceProvider(TaskManager* task_manager)
     : task_manager_(task_manager),
       updating_(false) {
 }
 
 TaskManagerNotificationResourceProvider::
     ~TaskManagerNotificationResourceProvider() {
 }
 
 TaskManager::Resource* TaskManagerNotificationResourceProvider::GetResource(
-    int origin_pid,
+    int origin_child_id,
     int render_process_host_id,
     int routing_id) {
-  // TODO(johnnyg): provide resources by pid if necessary.
+  // TODO(johnnyg): provide resources by child ID if necessary.
   return NULL;
 }
 
 void TaskManagerNotificationResourceProvider::StartUpdating() {
   DCHECK(!updating_);
   updating_ = true;
 
   // Add all the existing BalloonHosts.
   BalloonCollection* collection =
       g_browser_process->notification_ui_manager()->balloon_collection();
@@ skipping 72 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerBrowserProcessResource class
 ////////////////////////////////////////////////////////////////////////////////
 
 SkBitmap* TaskManagerBrowserProcessResource::default_icon_ = NULL;
 
 TaskManagerBrowserProcessResource::TaskManagerBrowserProcessResource()
     : title_() {
-  pid_ = base::GetCurrentProcId();
-  bool success = base::OpenPrivilegedProcessHandle(pid_, &process_);
+  int pid = base::GetCurrentProcId();
+  bool success = base::OpenPrivilegedProcessHandle(pid, &process_);
   DCHECK(success);
 #if defined(OS_WIN)
   if (!default_icon_) {
     HICON icon = GetAppIcon();
     if (icon) {
       ICONINFO icon_info = {0};
       BITMAP bitmap_info = {0};
 
       GetIconInfo(icon, &icon_info);
       GetObject(icon_info.hbmMask, sizeof(bitmap_info), &bitmap_info);
@@ skipping 68 matching lines @@
     TaskManagerBrowserProcessResourceProvider(TaskManager* task_manager)
     : updating_(false),
       task_manager_(task_manager) {
 }
 
 TaskManagerBrowserProcessResourceProvider::
     ~TaskManagerBrowserProcessResourceProvider() {
 }
 
 TaskManager::Resource* TaskManagerBrowserProcessResourceProvider::GetResource(
-    int origin_pid,
+    int origin_child_id,
     int render_process_host_id,
     int routing_id) {
-  if (origin_pid != resource_.process_id()) {
+  if (origin_child_id != (-1)) // Match "unknown" child ID for now!
     return NULL;
-  }
 
   return &resource_;
 }
 
 void TaskManagerBrowserProcessResourceProvider::StartUpdating() {
   task_manager_->AddResource(&resource_);
 }
 
 void TaskManagerBrowserProcessResourceProvider::StopUpdating() {
 }