Remove EPM:all_hosts_ and use all_extension_views_ instead.

chrome/browser/task_manager/task_manager_resource_providers.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/task_manager/task_manager_resource_providers.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_version_info.h"
 #include "base/i18n/rtl.h"
 #include "base/process_util.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/background/background_contents_service.h"
 #include "chrome/browser/background/background_contents_service_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/instant/instant_controller.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/tab_contents/background_contents.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_view_type.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_child_process_host_iterator.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_view_host_delegate.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/process_type.h"
+#include "content/public/common/view_type.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "third_party/sqlite/sqlite3.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "v8/include/v8.h"
 
 #if defined(OS_MACOSX)
 #include "skia/ext/skia_utils_mac.h"
@@ skipping 1048 matching lines @@
     Add(child_processes[i]);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerExtensionProcessResource class
 ////////////////////////////////////////////////////////////////////////////////
 
 SkBitmap* TaskManagerExtensionProcessResource::default_icon_ = NULL;
 
 TaskManagerExtensionProcessResource::TaskManagerExtensionProcessResource(
-    ExtensionHost* extension_host)
-    : extension_host_(extension_host) {
+    content::RenderViewHost* render_view_host)
+    : render_view_host_(render_view_host) {
   if (!default_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     default_icon_ = rb.GetBitmapNamed(IDR_PLUGIN);
   }
-  process_handle_ = extension_host_->render_process_host()->GetHandle();
-  unique_process_id_ = extension_host_->render_process_host()->GetID();
+  process_handle_ = render_view_host_->GetProcess()->GetHandle();
+  unique_process_id_ = render_view_host->GetProcess()->GetID();
   pid_ = base::GetProcId(process_handle_);
   string16 extension_name = UTF8ToUTF16(GetExtension()->name());
   DCHECK(!extension_name.empty());
 
+  Profile* profile = Profile::FromBrowserContext(
+      render_view_host->GetProcess()->GetBrowserContext());
   int message_id = GetMessagePrefixID(GetExtension()->is_app(), true,
-      extension_host_->profile()->IsOffTheRecord(), false, false);
+      profile->IsOffTheRecord(), false, false);
   title_ = l10n_util::GetStringFUTF16(message_id, extension_name);
 }
 
 TaskManagerExtensionProcessResource::~TaskManagerExtensionProcessResource() {
 }
 
 string16 TaskManagerExtensionProcessResource::GetTitle() const {
   return title_;
 }
 
 string16 TaskManagerExtensionProcessResource::GetProfileName() const {
   ProfileInfoCache& cache =
       g_browser_process->profile_manager()->GetProfileInfoCache();
-  Profile* profile = extension_host_->profile()->GetOriginalProfile();
+  Profile* profile = Profile::FromBrowserContext(
+      render_view_host_->GetProcess()->GetBrowserContext());
+  profile = profile->GetOriginalProfile();
   size_t index = cache.GetIndexOfProfileWithPath(profile->GetPath());
   if (index == std::string::npos)
     return string16();
   else
     return cache.GetNameOfProfileAtIndex(index);
 }
 
 SkBitmap TaskManagerExtensionProcessResource::GetIcon() const {
   return *default_icon_;
 }
 
 base::ProcessHandle TaskManagerExtensionProcessResource::GetProcess() const {
   return process_handle_;
 }
 
 int TaskManagerExtensionProcessResource::GetUniqueChildProcessId() const {
   return unique_process_id_;
 }
 
 TaskManager::Resource::Type
 TaskManagerExtensionProcessResource::GetType() const {
   return EXTENSION;
 }
 
 bool TaskManagerExtensionProcessResource::CanInspect() const {
   return true;
 }
 
 void TaskManagerExtensionProcessResource::Inspect() const {
-  DevToolsWindow::OpenDevToolsWindow(extension_host_->render_view_host());
+  DevToolsWindow::OpenDevToolsWindow(render_view_host_);
 }
 
 bool TaskManagerExtensionProcessResource::SupportNetworkUsage() const {
   return true;
 }
 
 void TaskManagerExtensionProcessResource::SetSupportNetworkUsage() {
   NOTREACHED();
 }
 
 const Extension* TaskManagerExtensionProcessResource::GetExtension() const {
-  return extension_host_->extension();
+  Profile* profile = Profile::FromBrowserContext(
+      render_view_host_->GetProcess()->GetBrowserContext());
+  ExtensionProcessManager* process_manager =
+      ExtensionSystem::Get(profile)->process_manager();
+  return process_manager->GetExtensionForRenderViewHost(render_view_host_);
 }
 
 bool TaskManagerExtensionProcessResource::IsBackground() const {
-  return extension_host_->extension_host_type() ==
+  return render_view_host_->GetDelegate()->GetRenderViewType() ==
       chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerExtensionProcessResourceProvider class
 ////////////////////////////////////////////////////////////////////////////////
 
 TaskManagerExtensionProcessResourceProvider::
     TaskManagerExtensionProcessResourceProvider(TaskManager* task_manager)
     : task_manager_(task_manager),
@@ skipping 13 matching lines @@
   if (iter != pid_to_resources_.end())
     return iter->second;
   else
     return NULL;
 }
 
 void TaskManagerExtensionProcessResourceProvider::StartUpdating() {
   DCHECK(!updating_);
   updating_ = true;
 
-  // Add all the existing ExtensionHosts from all Profiles, including those from
-  // incognito split mode.
+  // Add all the existing extension views from all Profiles, including those
+  // from incognito split mode.
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   std::vector<Profile*> profiles(profile_manager->GetLoadedProfiles());
   size_t num_default_profiles = profiles.size();
   for (size_t i = 0; i < num_default_profiles; ++i) {
     if (profiles[i]->HasOffTheRecordProfile()) {
       profiles.push_back(profiles[i]->GetOffTheRecordProfile());
     }
   }
+
   for (size_t i = 0; i < profiles.size(); ++i) {
     ExtensionProcessManager* process_manager =
         profiles[i]->GetExtensionProcessManager();
     if (process_manager) {
-      ExtensionProcessManager::const_iterator jt;
-      for (jt = process_manager->begin(); jt != process_manager->end(); ++jt) {
+      const ExtensionProcessManager::ViewSet all_views =
+          process_manager->GetAllViews();
+      ExtensionProcessManager::ViewSet::const_iterator jt = all_views.begin();
+      for (; jt != all_views.end(); ++jt) {
+        content::RenderViewHost* rvh = *jt;
         // Don't add dead extension processes.
-        if ((*jt)->IsRenderViewLive())
-          AddToTaskManager(*jt);
+        if (!rvh->IsRenderViewLive())
+          continue;
+
+        // Don't add WebContents (those are handled by
+        // TaskManagerTabContentsResourceProvider) or background contents
+        // (handled by TaskManagerBackgroundResourceProvider).
+        // TODO(benwells): create specific chrome::VIEW_TYPE_TAB_CONTENTS for
+        // tab contents, as VIEW_TYPE_WEB_CONTENTS is the default.
+        content::ViewType view_type = rvh->GetDelegate()->GetRenderViewType();
+        if (view_type == content::VIEW_TYPE_WEB_CONTENTS ||
+            view_type == chrome::VIEW_TYPE_BACKGROUND_CONTENTS) {
+          continue;
+        }
+
+        AddToTaskManager(rvh);
       }
     }
   }
 
   // Register for notifications about extension process changes.
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_CREATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
@@ skipping 21 matching lines @@
   resources_.clear();
   pid_to_resources_.clear();
 }
 
 void TaskManagerExtensionProcessResourceProvider::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_HOST_CREATED:
-      AddToTaskManager(content::Details<ExtensionHost>(details).ptr());
+      AddToTaskManager(
+          content::Details<ExtensionHost>(details).ptr()->render_view_host());
       break;
     case chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED:
     case chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED:
-      RemoveFromTaskManager(content::Details<ExtensionHost>(details).ptr());
+      RemoveFromTaskManager(
+          content::Details<ExtensionHost>(details).ptr()->render_view_host());
       break;
     default:
       NOTREACHED() << "Unexpected notification.";
       return;
   }
 }
 
 void TaskManagerExtensionProcessResourceProvider::AddToTaskManager(
-    ExtensionHost* extension_host) {
+    content::RenderViewHost* render_view_host) {
   TaskManagerExtensionProcessResource* resource =
-      new TaskManagerExtensionProcessResource(extension_host);
-  DCHECK(resources_.find(extension_host) == resources_.end());
-  resources_[extension_host] = resource;
+      new TaskManagerExtensionProcessResource(render_view_host);
+  DCHECK(resources_.find(render_view_host) == resources_.end());
+  resources_[render_view_host] = resource;
   pid_to_resources_[resource->process_id()] = resource;
   task_manager_->AddResource(resource);
 }
 
 void TaskManagerExtensionProcessResourceProvider::RemoveFromTaskManager(
-    ExtensionHost* extension_host) {
+    content::RenderViewHost* render_view_host) {
   if (!updating_)
     return;
-  std::map<ExtensionHost*, TaskManagerExtensionProcessResource*>
-      ::iterator iter = resources_.find(extension_host);
+  std::map<content::RenderViewHost*, TaskManagerExtensionProcessResource*>
+      ::iterator iter = resources_.find(render_view_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);
 
@@ skipping 137 matching lines @@
 
   return &resource_;
 }
 
 void TaskManagerBrowserProcessResourceProvider::StartUpdating() {
   task_manager_->AddResource(&resource_);
 }
 
 void TaskManagerBrowserProcessResourceProvider::StopUpdating() {
 }