Instant: Use only one hidden WebContents per profile.

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 10 matching lines @@
 #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/devtools/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/instant/instant_loader.h"
+#include "chrome/browser/instant/instant_service.h"
+#include "chrome/browser/instant/instant_service_factory.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/printing/background_printing_manager.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"
@@ skipping 43 matching lines @@
 using extensions::Extension;
 
 namespace {
 
 // Returns the appropriate message prefix ID for tabs and extensions,
 // reflecting whether they are apps or in incognito mode.
 int GetMessagePrefixID(bool is_app,
                        bool is_extension,
                        bool is_incognito,
                        bool is_prerender,
-                       bool is_instant_preview,
+                       bool is_instant_overlay,
                        bool is_background) {
   if (is_app) {
     if (is_background) {
       return IDS_TASK_MANAGER_BACKGROUND_PREFIX;
     } else if (is_incognito) {
       return IDS_TASK_MANAGER_APP_INCOGNITO_PREFIX;
     } else {
       return IDS_TASK_MANAGER_APP_PREFIX;
     }
   } else if (is_extension) {
     if (is_incognito)
       return IDS_TASK_MANAGER_EXTENSION_INCOGNITO_PREFIX;
     else
       return IDS_TASK_MANAGER_EXTENSION_PREFIX;
   } else if (is_prerender) {
     return IDS_TASK_MANAGER_PRERENDER_PREFIX;
-  } else if (is_instant_preview) {
-    return IDS_TASK_MANAGER_INSTANT_PREVIEW_PREFIX;
+  } else if (is_instant_overlay) {
+    return IDS_TASK_MANAGER_INSTANT_OVERLAY_PREFIX;
   } else {
     return IDS_TASK_MANAGER_TAB_PREFIX;
   }
 }
 
 string16 GetProfileNameFromInfoCache(Profile* profile) {
   ProfileInfoCache& cache =
       g_browser_process->profile_manager()->GetProfileInfoCache();
   size_t index = cache.GetIndexOfProfileWithPath(
       profile->GetOriginalProfile()->GetPath());
@@ skipping 28 matching lines @@
 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) {
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents->GetBrowserContext());
+  InstantService* instant_service =
+      InstantServiceFactory::GetForProfile(profile);
+  if (instant_service && instant_service->loader()->contents() == web_contents)
+    return true;
+
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     if (it->instant_controller() &&
         it->instant_controller()->instant()->
-            GetPreviewContents() == web_contents) {
+            GetOverlayContents() == web_contents) {
       return true;
     }
   }
 
   return false;
 }
 
 bool IsContentsBackgroundPrinted(WebContents* web_contents) {
   printing::BackgroundPrintingManager* printing_manager =
       g_browser_process->background_printing_manager();
@@ skipping 123 matching lines @@
 // static
 gfx::ImageSkia* TaskManagerTabContentsResource::prerender_icon_ = NULL;
 
 TaskManagerTabContentsResource::TaskManagerTabContentsResource(
     WebContents* web_contents)
     : TaskManagerRendererResource(
           web_contents->GetRenderProcessHost()->GetHandle(),
           web_contents->GetRenderViewHost()),
       web_contents_(web_contents),
       profile_(Profile::FromBrowserContext(web_contents->GetBrowserContext())),
-      is_instant_preview_(IsContentsInstant(web_contents)) {
+      is_instant_overlay_(IsContentsInstant(web_contents)) {
   if (!prerender_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     prerender_icon_ = rb.GetImageSkiaNamed(IDR_PRERENDER);
   }
 }
 
 TaskManagerTabContentsResource::~TaskManagerTabContentsResource() {
 }
 
 void TaskManagerTabContentsResource::InstantCommitted() {
-  DCHECK(is_instant_preview_);
-  is_instant_preview_ = false;
+  DCHECK(is_instant_overlay_);
+  is_instant_overlay_ = false;
 }
 
 bool TaskManagerTabContentsResource::HostsExtension() const {
   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.
   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 = profile_->GetExtensionService();
   extensions::ProcessMap* process_map = extension_service->process_map();
   bool is_app = extension_service->IsInstalledApp(url) &&
       process_map->Contains(web_contents_->GetRenderProcessHost()->GetID());
 
   int message_id = GetMessagePrefixID(
       is_app,
       HostsExtension(),
       profile_->IsOffTheRecord(),
       IsContentsPrerendering(web_contents_),
-      is_instant_preview_,
+      is_instant_overlay_,
       false);
   return l10n_util::GetStringFUTF16(message_id, tab_title);
 }
 
 string16 TaskManagerTabContentsResource::GetProfileName() const {
   return GetProfileNameFromInfoCache(profile_);
 }
 
 gfx::ImageSkia TaskManagerTabContentsResource::GetIcon() const {
   if (IsContentsPrerendering(web_contents_))
@@ skipping 52 matching lines @@
     return NULL;
   }
   return res_iter->second;
 }
 
 void TaskManagerTabContentsResourceProvider::StartUpdating() {
   DCHECK(!updating_);
   updating_ = true;
 
   // The contents that are tracked by this resource provider are those that
-  // are tab contents (WebContents serving as a tab in a Browser), instant
+  // are tab contents (WebContents serving as a tab in a Browser), Instant
   // pages, prerender pages, and background printed pages.
 
   // Add all the existing WebContentses.
   for (TabContentsIterator iterator; !iterator.done(); iterator.Next())
     Add(*iterator);
 
-  // Add all the instant pages.
+  // Add all the Instant pages.
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     if (it->instant_controller() &&
-        it->instant_controller()->instant()->GetPreviewContents()) {
-      Add(it->instant_controller()->instant()->GetPreviewContents());
+        it->instant_controller()->instant()->GetOverlayContents()) {
+      Add(it->instant_controller()->instant()->GetOverlayContents());
     }
   }
 
-  // Add all the prerender pages.
   std::vector<Profile*> profiles(
       g_browser_process->profile_manager()->GetLoadedProfiles());
   for (size_t i = 0; i < profiles.size(); ++i) {
+    // Add all the prerender pages.
     prerender::PrerenderManager* prerender_manager =
         prerender::PrerenderManagerFactory::GetForProfile(profiles[i]);
     if (prerender_manager) {
       const std::vector<content::WebContents*> contentses =
           prerender_manager->GetAllPrerenderingContents();
       for (size_t j = 0; j < contentses.size(); ++j)
         Add(contentses[j]);
     }
+
+    // Add the Instant per-profile page.
+    InstantService* instant_service =
+        InstantServiceFactory::GetForProfile(profiles[i]);
+    if (instant_service && instant_service->loader()->contents())
+      Add(instant_service->loader()->contents());
   }
 
   // Add all the pages being background printed.
   printing::BackgroundPrintingManager* printing_manager =
       g_browser_process->background_printing_manager();
   for (printing::BackgroundPrintingManager::WebContentsSet::iterator i =
            printing_manager->begin();
        i != printing_manager->end(); ++i) {
     Add(*i);
   }
@@ skipping 35 matching lines @@
       new TaskManagerTabContentsResource(web_contents);
   resources_[web_contents] = resource;
   task_manager_->AddResource(resource);
 }
 
 void TaskManagerTabContentsResourceProvider::Add(WebContents* web_contents) {
   if (!updating_)
     return;
 
   // The contents that are tracked by this resource provider are those that
-  // are tab contents (WebContents serving as a tab in a Browser), instant
+  // are tab contents (WebContents serving as a tab in a Browser), Instant
   // pages, prerender pages, and background printed pages.
   if (!chrome::FindBrowserWithWebContents(web_contents) &&
       !IsContentsPrerendering(web_contents) &&
       !IsContentsInstant(web_contents) &&
       !IsContentsBackgroundPrinted(web_contents)) {
     return;
   }
 
   // Don't add dead tabs or tabs that haven't yet connected.
   if (!web_contents->GetRenderProcessHost()->GetHandle() ||
@@ skipping 1411 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.";
   }
 }