Make TaskManagerTabContentsResource explicitly handle prerendering and instant pages.

chrome/browser/task_manager/task_manager_resource_providers.cc

 // Copyright 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"
@@ skipping 18 matching lines @@
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/favicon/favicon_tab_helper.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.h"
+#include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_instant_controller.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
 #include "chrome/browser/view_type_utils.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
@@ skipping 91 matching lines @@
     // might be wrong. For example, http://mail.yahoo.com, whose title is
     // "Yahoo! Mail: The best web-based Email!", without setting it explicitly
     // as LTR format, the concatenated result will be "!Yahoo! Mail: The best
     // web-based Email :BAT", in which the capital letters "BAT" stands for
     // the Hebrew word for "tab".
     base::i18n::AdjustStringForLocaleDirection(&title);
   }
   return title;
 }
 
+bool IsContentsPrerendering(WebContents* web_contents) {
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents->GetBrowserContext());
+  prerender::PrerenderManager* prerender_manager =
+      prerender::PrerenderManagerFactory::GetForProfile(profile);
+  return prerender_manager &&
+         prerender_manager->IsWebContentsPrerendering(web_contents, NULL);
+}
+
+bool IsContentsInstant(WebContents* web_contents) {
+  for (BrowserList::const_iterator i = BrowserList::begin();
+       i != BrowserList::end(); ++i) {
+    if ((*i)->instant_controller() &&
+        (*i)->instant_controller()->instant()->
+            GetPreviewContents() == web_contents) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerRendererResource class
 ////////////////////////////////////////////////////////////////////////////////
 TaskManagerRendererResource::TaskManagerRendererResource(
     base::ProcessHandle process, content::RenderViewHost* render_view_host)
     : process_(process),
       render_view_host_(render_view_host),
       pending_stats_update_(false),
@@ skipping 104 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerTabContentsResource class
 ////////////////////////////////////////////////////////////////////////////////
 
 // static
 gfx::ImageSkia* TaskManagerTabContentsResource::prerender_icon_ = NULL;
 
 TaskManagerTabContentsResource::TaskManagerTabContentsResource(
-    TabContents* tab_contents)
+    WebContents* web_contents)
     : TaskManagerRendererResource(
-          tab_contents->web_contents()->GetRenderProcessHost()->GetHandle(),
-          tab_contents->web_contents()->GetRenderViewHost()),
-      tab_contents_(tab_contents),
-      is_instant_preview_(false) {
+          web_contents->GetRenderProcessHost()->GetHandle(),
+          web_contents->GetRenderViewHost()),
+      web_contents_(web_contents),
+      profile_(Profile::FromBrowserContext(web_contents->GetBrowserContext())),
+      is_instant_preview_(IsContentsInstant(web_contents)) {
   if (!prerender_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     prerender_icon_ = rb.GetImageSkiaNamed(IDR_PRERENDER);
   }
-  for (BrowserList::const_iterator i = BrowserList::begin();
-       i != BrowserList::end(); ++i) {
-    if ((*i)->instant_controller() &&
-        (*i)->instant_controller()->instant()->GetPreviewContents() ==
-            tab_contents_->web_contents()) {
-      is_instant_preview_ = true;
-      break;
-    }
-  }
 }
 
 TaskManagerTabContentsResource::~TaskManagerTabContentsResource() {
 }
 
 void TaskManagerTabContentsResource::InstantCommitted() {
   DCHECK(is_instant_preview_);
   is_instant_preview_ = false;
 }
 
-bool TaskManagerTabContentsResource::IsPrerendering() const {
-  prerender::PrerenderManager* prerender_manager =
-      prerender::PrerenderManagerFactory::GetForProfile(
-          tab_contents_->profile());
-  return prerender_manager &&
-         prerender_manager->IsWebContentsPrerendering(
-             tab_contents_->web_contents(), NULL);
-}
-
 bool TaskManagerTabContentsResource::HostsExtension() const {
-  return tab_contents_->web_contents()->GetURL().SchemeIs(
-      extensions::kExtensionScheme);
+  return web_contents_->GetURL().SchemeIs(extensions::kExtensionScheme);
 }
 
 TaskManager::Resource::Type TaskManagerTabContentsResource::GetType() const {
   return HostsExtension() ? EXTENSION : RENDERER;
 }
 
 string16 TaskManagerTabContentsResource::GetTitle() const {
   // Fall back on the URL if there's no title.
-  WebContents* contents = tab_contents_->web_contents();
-  GURL url = contents->GetURL();
-  string16 tab_title = GetTitleFromWebContents(contents);
+  GURL url = web_contents_->GetURL();
+  string16 tab_title = GetTitleFromWebContents(web_contents_);
 
   // Only classify as an app if the URL is an app and the tab is hosting an
   // extension process.  (It's possible to be showing the URL from before it
   // was installed as an app.)
-  ExtensionService* extension_service =
-      tab_contents_->profile()->GetExtensionService();
+  ExtensionService* extension_service = profile_->GetExtensionService();
   extensions::ProcessMap* process_map = extension_service->process_map();
   bool is_app = extension_service->IsInstalledApp(url) &&
-      process_map->Contains(contents->GetRenderProcessHost()->GetID());
+      process_map->Contains(web_contents_->GetRenderProcessHost()->GetID());
 
   int message_id = GetMessagePrefixID(
       is_app,
       HostsExtension(),
-      tab_contents_->profile()->IsOffTheRecord(),
-      IsPrerendering(),
+      profile_->IsOffTheRecord(),
+      IsContentsPrerendering(web_contents_),
       is_instant_preview_,
       false);
   return l10n_util::GetStringFUTF16(message_id, tab_title);
 }
 
 string16 TaskManagerTabContentsResource::GetProfileName() const {
-  return GetProfileNameFromInfoCache(tab_contents_->profile());
+  return GetProfileNameFromInfoCache(profile_);
 }
 
 gfx::ImageSkia TaskManagerTabContentsResource::GetIcon() const {
-  if (IsPrerendering())
+  if (IsContentsPrerendering(web_contents_))
     return *prerender_icon_;
-  return FaviconTabHelper::FromWebContents(tab_contents_->web_contents())->
+  return FaviconTabHelper::FromWebContents(web_contents_)->
       GetFavicon().AsImageSkia();
 }
 
 WebContents* TaskManagerTabContentsResource::GetWebContents() const {
-  return tab_contents_->web_contents();
+  return web_contents_;
 }
 
 const Extension* TaskManagerTabContentsResource::GetExtension() const {
   if (HostsExtension()) {
-    ExtensionService* extension_service =
-        tab_contents_->profile()->GetExtensionService();
+    ExtensionService* extension_service = profile_->GetExtensionService();
     return extension_service->extensions()->GetByID(
-        tab_contents_->web_contents()->GetURL().host());
+        web_contents_->GetURL().host());
   }
 
   return NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerTabContentsResourceProvider class
 ////////////////////////////////////////////////////////////////////////////////
 
 TaskManagerTabContentsResourceProvider::
@@ skipping 13 matching lines @@
   WebContents* web_contents =
       tab_util::GetWebContentsByID(render_process_host_id, routing_id);
   if (!web_contents)  // Not one of our resource.
     return NULL;
 
   // If an origin PID was specified then the request originated in a plugin
   // working on the WebContents's behalf, so ignore it.
   if (origin_pid)
     return NULL;
 
-  TabContents* tab_contents = TabContents::FromWebContents(web_contents);
-  std::map<TabContents*, TaskManagerTabContentsResource*>::iterator
-      res_iter = resources_.find(tab_contents);
+  std::map<WebContents*, TaskManagerTabContentsResource*>::iterator
+      res_iter = resources_.find(web_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;
 }
 
 void TaskManagerTabContentsResourceProvider::StartUpdating() {
   DCHECK(!updating_);
   updating_ = true;
 
-  // Add all the existing TabContentses.
+  // The contents that are tracked by this resource provider are those that
+  // are tab contents (WebContents serving as a tab in a Browser), instant
+  // pages, and prerender pages.
+
+  // Add all the existing tab contents.
   for (TabContentsIterator iterator; !iterator.done(); ++iterator)
-    Add(*iterator);
+    Add(iterator->web_contents());
 
-  // Then we register for notifications to get new tabs.
+  // Add all the instant pages.
+  for (BrowserList::const_iterator i = BrowserList::begin();
+       i != BrowserList::end(); ++i) {
+    if ((*i)->instant_controller() &&
+        (*i)->instant_controller()->instant()->GetPreviewContents()) {
+      Add((*i)->instant_controller()->instant()->GetPreviewContents());
+    }
+  }
+
+  // Add all the prerender pages.
+  std::vector<Profile*> profiles(
+      g_browser_process->profile_manager()->GetLoadedProfiles());
+  for (size_t i = 0; i < profiles.size(); ++i) {
+    prerender::PrerenderManager* prerender_manager =
+        prerender::PrerenderManagerFactory::GetForProfile(profiles[i]);
+    const std::vector<content::WebContents*> contentses =
+        prerender_manager->GetAllPrerenderingContents();
+    for (size_t j = 0; j < contentses.size(); ++j)
+      Add(contentses[j]);
+  }
+
+  // Then we register for notifications to get new web contents.
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_CONNECTED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_SWAPPED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, chrome::NOTIFICATION_INSTANT_COMMITTED,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
 void TaskManagerTabContentsResourceProvider::StopUpdating() {
   DCHECK(updating_);
   updating_ = false;
 
-  // Then we unregister for notifications to get new tabs.
+  // Then we unregister for notifications to get new web contents.
   registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_CONNECTED,
       content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_SWAPPED,
       content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
       content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Remove(this, chrome::NOTIFICATION_INSTANT_COMMITTED,
       content::NotificationService::AllBrowserContextsAndSources());
 
   // Delete all the resources.
   STLDeleteContainerPairSecondPointers(resources_.begin(), resources_.end());
 
   resources_.clear();
 }
 
 void TaskManagerTabContentsResourceProvider::AddToTaskManager(
-    TabContents* tab_contents) {
+    WebContents* web_contents) {
   TaskManagerTabContentsResource* resource =
-      new TaskManagerTabContentsResource(tab_contents);
-  resources_[tab_contents] = resource;
+      new TaskManagerTabContentsResource(web_contents);
+  resources_[web_contents] = resource;
   task_manager_->AddResource(resource);
 }
 
-void TaskManagerTabContentsResourceProvider::Add(TabContents* tab_contents) {
+void TaskManagerTabContentsResourceProvider::Add(WebContents* web_contents) {
   if (!updating_)
     return;
 
   // Don't add dead tabs or tabs that haven't yet connected.
-  if (!tab_contents->web_contents()->GetRenderProcessHost()->GetHandle() ||
-      !tab_contents->web_contents()->WillNotifyDisconnection()) {
+  if (!web_contents->GetRenderProcessHost()->GetHandle() ||
+      !web_contents->WillNotifyDisconnection()) {
     return;
   }
 
-  std::map<TabContents*, TaskManagerTabContentsResource*>::const_iterator
-      iter = resources_.find(tab_contents);
-  if (iter != resources_.end()) {
+  if (resources_.count(web_contents)) {
     // The case may happen that we have added a WebContents 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.
     return;
   }
-  AddToTaskManager(tab_contents);
+  AddToTaskManager(web_contents);
 }
 
-void TaskManagerTabContentsResourceProvider::Remove(TabContents* tab_contents) {
+void TaskManagerTabContentsResourceProvider::Remove(WebContents* web_contents) {
   if (!updating_)
     return;
-  std::map<TabContents*, TaskManagerTabContentsResource*>::iterator
-      iter = resources_.find(tab_contents);
+  std::map<WebContents*, TaskManagerTabContentsResource*>::iterator
+      iter = resources_.find(web_contents);
   if (iter == resources_.end()) {
     // Since WebContents are destroyed asynchronously (see TabContentsCollector
     // in navigation_controller.cc), we can be notified of a tab being removed
     // that we don't know.  This can happen if the user closes a tab and quickly
     // opens the task manager, before the tab is actually destroyed.
     return;
   }
 
   // Remove the resource from the Task Manager.
   TaskManagerTabContentsResource* resource = iter->second;
   task_manager_->RemoveResource(resource);
   // And from the provider.
   resources_.erase(iter);
   // Finally, delete the resource.
   delete resource;
 }
 
-void TaskManagerTabContentsResourceProvider::Update(TabContents* tab_contents) {
+void TaskManagerTabContentsResourceProvider::InstantCommitted(
+    WebContents* web_contents) {
   if (!updating_)
     return;
-  std::map<TabContents*, TaskManagerTabContentsResource*>::iterator
-      iter = resources_.find(tab_contents);
+  std::map<WebContents*, TaskManagerTabContentsResource*>::iterator
+      iter = resources_.find(web_contents);
   DCHECK(iter != resources_.end());
   if (iter != resources_.end())
     iter->second->InstantCommitted();
 }
 
-void TaskManagerTabContentsResourceProvider::Observe(int type,
+void TaskManagerTabContentsResourceProvider::Observe(
+    int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  TabContents* tab_contents;
-  tab_contents = TabContents::FromWebContents(
-      content::Source<WebContents>(source).ptr());
-  // A background page does not have a TabContents.
-  if (!tab_contents)
+  WebContents* web_contents = content::Source<WebContents>(source).ptr();
+
+  // The contents that are tracked by this resource provider are those that
+  // are tab contents (WebContents serving as a tab in a Browser), instant
+  // pages, and prerender pages.
+  if (!chrome::FindBrowserWithWebContents(web_contents) &&
+      !IsContentsPrerendering(web_contents) &&
+      !IsContentsInstant(web_contents)) {
     return;
+  }
+
   switch (type) {
     case content::NOTIFICATION_WEB_CONTENTS_CONNECTED:
-      Add(tab_contents);
+      Add(web_contents);
       break;
     case content::NOTIFICATION_WEB_CONTENTS_SWAPPED:
-      Remove(tab_contents);
-      Add(tab_contents);
+      Remove(web_contents);
+      Add(web_contents);
       break;
     case content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED:
-      Remove(tab_contents);
+      Remove(web_contents);
       break;
     case chrome::NOTIFICATION_INSTANT_COMMITTED:
-      Update(tab_contents);
+      InstantCommitted(web_contents);
       break;
     default:
       NOTREACHED() << "Unexpected notification.";
       return;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerPanelResource class
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 1327 matching lines @@
     case content::NOTIFICATION_WEB_CONTENTS_CONNECTED:
       Add(web_contents->GetRenderViewHost());
       break;
     case content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED:
       Remove(web_contents->GetRenderViewHost());
       break;
     default:
       NOTREACHED() << "Unexpected notification.";
   }
 }