InstantExtended: Remove overlay control code.

chrome/browser/task_manager/tab_contents_resource_provider.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/tab_contents_resource_provider.h"
 
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/prerender/prerender_manager.h"
@@ skipping 46 matching lines @@
 
 namespace task_manager {
 
 // Tracks a single tab contents, prerendered page, Instant page, or background
 // printing page.
 class TabContentsResource : public RendererResource {
  public:
   explicit TabContentsResource(content::WebContents* web_contents);
   virtual ~TabContentsResource();
 
-  // Called when the underlying web_contents has been committed and is no
-  // longer an Instant overlay.
-  void InstantCommitted();
-
   // Resource methods:
   virtual Type GetType() const OVERRIDE;
   virtual string16 GetTitle() const OVERRIDE;
   virtual string16 GetProfileName() const OVERRIDE;
   virtual gfx::ImageSkia GetIcon() const OVERRIDE;
   virtual content::WebContents* GetWebContents() const OVERRIDE;
   virtual const extensions::Extension* GetExtension() const OVERRIDE;
 
  private:
   // Returns true if contains content rendered by an extension.
   bool HostsExtension() const;
 
   static gfx::ImageSkia* prerender_icon_;
   content::WebContents* web_contents_;
   Profile* profile_;
-  bool is_instant_overlay_;
+  bool is_instant_ntp_;
 
   DISALLOW_COPY_AND_ASSIGN(TabContentsResource);
 };
 
 gfx::ImageSkia* TabContentsResource::prerender_icon_ = NULL;
 
 TabContentsResource::TabContentsResource(
     WebContents* web_contents)
     : RendererResource(web_contents->GetRenderProcessHost()->GetHandle(),
                        web_contents->GetRenderViewHost()),
       web_contents_(web_contents),
       profile_(Profile::FromBrowserContext(web_contents->GetBrowserContext())),
-      is_instant_overlay_(chrome::IsInstantOverlay(web_contents) ||
-                          chrome::IsPreloadedInstantExtendedNTP(web_contents)) {
+      is_instant_ntp_(chrome::IsPreloadedInstantExtendedNTP(web_contents)) {
   if (!prerender_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     prerender_icon_ = rb.GetImageSkiaNamed(IDR_PRERENDER);
   }
 }
 
 TabContentsResource::~TabContentsResource() {
 }
 
-void TabContentsResource::InstantCommitted() {
-  DCHECK(is_instant_overlay_);
-  is_instant_overlay_ = false;
-}
-
 bool TabContentsResource::HostsExtension() const {
   return web_contents_->GetURL().SchemeIs(extensions::kExtensionScheme);
 }
 
 Resource::Type TabContentsResource::GetType() const {
   return HostsExtension() ? EXTENSION : RENDERER;
 }
 
 string16 TabContentsResource::GetTitle() const {
   // Fall back on the URL if there's no title.
   GURL url = web_contents_->GetURL();
   string16 tab_title = util::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 = util::GetMessagePrefixID(
       is_app,
       HostsExtension(),
       profile_->IsOffTheRecord(),
       IsContentsPrerendering(web_contents_),
-      is_instant_overlay_,
+      is_instant_ntp_,
       false);  // is_background
   return l10n_util::GetStringFUTF16(message_id, tab_title);
 }
 
 string16 TabContentsResource::GetProfileName() const {
   return util::GetProfileNameFromInfoCache(profile_);
 }
 
 gfx::ImageSkia TabContentsResource::GetIcon() const {
   if (IsContentsPrerendering(web_contents_))
@@ skipping 61 matching lines @@
   // 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.
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     if (it->instant_controller()) {
-      if (it->instant_controller()->instant()->GetOverlayContents())
-        Add(it->instant_controller()->instant()->GetOverlayContents());
       if (it->instant_controller()->instant()->GetNTPContents())
         Add(it->instant_controller()->instant()->GetNTPContents());
     }
   }
 
   // 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 =
@@ skipping 15 matching lines @@
     Add(*i);
   }
 
   // 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 TabContentsResourceProvider::StopUpdating() {
   DCHECK(updating_);
   updating_ = false;
 
   // 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 TabContentsResourceProvider::AddToTaskManager(WebContents* web_contents) {
   TabContentsResource* resource = new TabContentsResource(web_contents);
   resources_[web_contents] = resource;
   task_manager_->AddResource(resource);
 }
 
 void TabContentsResourceProvider::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
   // pages, prerender pages, and background printed pages.
   if (!chrome::FindBrowserWithWebContents(web_contents) &&
       !IsContentsPrerendering(web_contents) &&
-      !chrome::IsInstantOverlay(web_contents) &&
       !chrome::IsPreloadedInstantExtendedNTP(web_contents) &&
       !IsContentsBackgroundPrinted(web_contents)) {
     return;
   }
 
   // Don't add dead tabs or tabs that haven't yet connected.
   if (!web_contents->GetRenderProcessHost()->GetHandle() ||
       !web_contents->WillNotifyDisconnection()) {
     return;
   }
@@ skipping 23 matching lines @@
 
   // Remove the resource from the Task Manager.
   TabContentsResource* resource = iter->second;
   task_manager_->RemoveResource(resource);
   // And from the provider.
   resources_.erase(iter);
   // Finally, delete the resource.
   delete resource;
 }
 
-void TabContentsResourceProvider::InstantCommitted(WebContents* web_contents) {
-  if (!updating_)
-    return;
-  std::map<WebContents*, TabContentsResource*>::iterator
-      iter = resources_.find(web_contents);
-  DCHECK(iter != resources_.end());
-  if (iter != resources_.end())
-    iter->second->InstantCommitted();
-}
-
 void TabContentsResourceProvider::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   WebContents* web_contents = content::Source<WebContents>(source).ptr();
 
   switch (type) {
     case content::NOTIFICATION_WEB_CONTENTS_CONNECTED:
       Add(web_contents);
       break;
     case content::NOTIFICATION_WEB_CONTENTS_SWAPPED:
       Remove(web_contents);
       Add(web_contents);
       break;
     case content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED:
       Remove(web_contents);
       break;
-    case chrome::NOTIFICATION_INSTANT_COMMITTED:
-      InstantCommitted(web_contents);
-      break;
     default:
       NOTREACHED() << "Unexpected notification.";
       return;
   }
 }
 
 }  // namespace task_manager