Finish extensions <-> task manager integration

chrome/browser/task_manager_resource_providers.cc

 // Copyright (c) 2006-2008 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_resource_providers.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <atlbase.h>
@@ skipping 119 matching lines @@
     // Can happen if the tab was closed while a network request was being
     // performed.
     return NULL;
 
   return res_iter->second;
 }
 
 void TaskManagerTabContentsResourceProvider::StartUpdating() {
   DCHECK(!updating_);
   updating_ = true;
+
   // Add all the existing TabContents.
-  for (TabContentsIterator iterator; !iterator.done(); iterator++) {
-    TabContents* tab_contents = *iterator;
-    // Don't add dead tabs or tabs that haven't yet connected.
-    // Also ignore tabs which display extension content. We collapse
-    // all of these into one extension row.
-    if (tab_contents->process()->process().handle() &&
-        tab_contents->notify_disconnection() &&
-        !tab_contents->HostsExtension())
-      AddToTaskManager(tab_contents);
-  }
+  for (TabContentsIterator iterator; !iterator.done(); iterator++)
+    Add(*iterator);
+
   // Then we register for notifications to get new tabs.
   registrar_.Add(this, NotificationType::TAB_CONTENTS_CONNECTED,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::TAB_CONTENTS_SWAPPED,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::TAB_CONTENTS_DISCONNECTED,
                  NotificationService::AllSources());
   // TAB_CONTENTS_DISCONNECTED should be enough to know when to remove a
   // resource.  This is an attempt at mitigating a crasher that seem to
   // indicate a resource is still referencing a deleted TabContents
@@ skipping 27 matching lines @@
   TaskManagerTabContentsResource* resource =
       new TaskManagerTabContentsResource(tab_contents);
   resources_[tab_contents] = resource;
   task_manager_->AddResource(resource);
 }
 
 void TaskManagerTabContentsResourceProvider::Add(TabContents* tab_contents) {
   if (!updating_)
     return;
 
-  if (!tab_contents->process()->process().handle()) {
-    // Don't add sad tabs, we would have no information to show for them since
-    // they have no associated process.
+  // Don't add dead tabs or tabs that haven't yet connected.
+  // Also ignore tabs which display extension content. We collapse
+  // all of these into one extension row.
+  if (!tab_contents->process()->process().handle() ||
+      !tab_contents->notify_disconnection() ||
+      tab_contents->HostsExtension()) {
     return;
   }
 
   std::map<TabContents*, TaskManagerTabContentsResource*>::const_iterator
       iter = resources_.find(tab_contents);
   if (iter != resources_.end()) {
     // The case may happen that we have added a TabContents 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 tab and just ignore it.
@@ skipping 313 matching lines @@
       pid_to_resources_.find(origin_pid);
   if (iter != pid_to_resources_.end())
     return iter->second;
   else
     return NULL;
 }
 
 void TaskManagerExtensionProcessResourceProvider::StartUpdating() {
   DCHECK(!updating_);
   updating_ = true;
+
   // Add all the existing ExtensionHosts.
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   for (ProfileManager::const_iterator it = profile_manager->begin();
        it != profile_manager->end(); ++it) {
       ExtensionProcessManager* process_manager =
           (*it)->GetExtensionProcessManager();
       ExtensionProcessManager::const_iterator jt;
       for (jt = process_manager->begin(); jt != process_manager->end(); ++jt)
         AddToTaskManager(*jt);
   }
-  // TODO(phajdan.jr): Also look for TabContents which are displaying
-  // extension content to aggregate network usage.
-  // TODO(phajdan.jr): Register for notifications.
+
+  // Register for notifications to get new extension processes.
+  registrar_.Add(this, NotificationType::EXTENSION_HOST_CREATED,
+                 NotificationService::AllSources());
+  registrar_.Add(this, NotificationType::EXTENSION_HOST_DESTROYED,
+                 NotificationService::AllSources());
 }
 
 void TaskManagerExtensionProcessResourceProvider::StopUpdating() {
   DCHECK(updating_);
   updating_ = false;
 
-  // TODO(phajdan.jr): Unregister notifications.
+  // Unregister for notifications to get new extension processes.
+  registrar_.Remove(this, NotificationType::EXTENSION_HOST_CREATED,
+                    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();
 }
 
+void TaskManagerExtensionProcessResourceProvider::Observe(
+    NotificationType type,
+    const NotificationSource& source,
+    const NotificationDetails& details) {
+  switch (type.value) {
+    case NotificationType::EXTENSION_HOST_CREATED:
+      AddToTaskManager(Details<ExtensionHost>(details).ptr());
+      break;
+    case NotificationType::EXTENSION_HOST_DESTROYED:
+      RemoveFromTaskManager(Details<ExtensionHost>(details).ptr());
+      break;
+    default:
+      NOTREACHED() << "Unexpected notification.";
+      return;
+  }
+}
+
 void TaskManagerExtensionProcessResourceProvider::AddToTaskManager(
     ExtensionHost* extension_host) {
   TaskManagerExtensionProcessResource* resource =
       new TaskManagerExtensionProcessResource(extension_host);
   DCHECK(resources_.find(extension_host) == resources_.end());
   resources_[extension_host] = resource;
   pid_to_resources_[resource->process_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);
+
+  // Finally, delete the resource.
+  delete resource;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerBrowserProcessResource class
 ////////////////////////////////////////////////////////////////////////////////
 
 SkBitmap* TaskManagerBrowserProcessResource::default_icon_ = NULL;
 
 TaskManagerBrowserProcessResource::TaskManagerBrowserProcessResource()
     : network_usage_support_(false),
       title_() {
   pid_ = base::GetCurrentProcId();
@@ skipping 63 matching lines @@
 
   return &resource_;
 }
 
 void TaskManagerBrowserProcessResourceProvider::StartUpdating() {
   task_manager_->AddResource(&resource_);
 }
 
 void TaskManagerBrowserProcessResourceProvider::StopUpdating() {
 }