Cancel downloads earlier when prerendering.

chrome/browser/prerender/prerender_contents.cc

 // Copyright (c) 2011 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/prerender/prerender_contents.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/process_util.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/background_contents_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/history/history_marshaling.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_render_widget_host_view.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_preferences_util.h"
+#include "chrome/browser/ui/download/download_tab_helper.h"
 #include "chrome/browser/ui/login/login_prompt.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/icon_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browsing_instance.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
@@ skipping 214 matching lines @@
   DCHECK(!prerendering_has_started_);
   DCHECK(prerender_contents_.get() == NULL);
   DCHECK(source_render_view_host != NULL);
   DCHECK(source_render_view_host->view() != NULL);
 
   prerendering_has_started_ = true;
   TabContents* new_contents = new TabContents(profile_, NULL, MSG_ROUTING_NONE,
                                               NULL, NULL);
   prerender_contents_.reset(new TabContentsWrapper(new_contents));
   tab_contents_observer_registrar_.Observe(new_contents);
+  prerender_contents_->download_tab_helper()->set_delegate(this);
 
   TabContents* source_tc =
       source_render_view_host->delegate()->GetAsTabContents();
   if (source_tc) {
     // So that history merging will work, get the max page ID
     // of the old page, and add a safety margin of 10 to it (for things
     // such as redirects).
     int32 max_page_id = source_tc->GetMaxPageID();
     if (max_page_id != -1) {
       prerender_contents_->controller().set_max_restored_page_id(
@@ skipping 34 matching lines @@
   notification_registrar_.Add(this, NotificationType::PROFILE_DESTROYED,
                               Source<Profile>(profile_));
 
   // Register to cancel if Authentication is required.
   notification_registrar_.Add(this, NotificationType::AUTH_NEEDED,
                               NotificationService::AllSources());
 
   notification_registrar_.Add(this, NotificationType::AUTH_CANCELLED,
                               NotificationService::AllSources());
 
-  // Register all responses to see if we should cancel.
-  notification_registrar_.Add(this, NotificationType::DOWNLOAD_INITIATED,
-                              NotificationService::AllSources());
-
   // Register to inform new RenderViews that we're prerendering.
   notification_registrar_.Add(
       this, NotificationType::RENDER_VIEW_HOST_CREATED_FOR_TAB,
       Source<TabContents>(new_contents));
 
   // Register for redirect notifications sourced from |this|.
   notification_registrar_.Add(
       this, NotificationType::RESOURCE_RECEIVED_REDIRECT,
       Source<RenderViewHostDelegate>(GetRenderViewHostDelegate()));
 
@@ skipping 49 matching lines @@
     RecordFinalStatus(final_status_);
 
   // Only delete the RenderViewHost if we own it.
   if (render_view_host_)
     render_view_host_->Shutdown();
 
   if (child_id_ != -1 && route_id_ != -1) {
     PrerenderTracker::GetInstance()->OnPrerenderingFinished(
         child_id_, route_id_);
   }
+
+  // If we still have a TabContents, clean up anything we need to and then
+  // destroy it.
+  if (prerender_contents_.get())
+    delete ReleasePrerenderContents();
 }
 
 RenderViewHostDelegate::View* PrerenderContents::GetViewDelegate() {
   return this;
 }
 
 const GURL& PrerenderContents::GetURL() const {
   return url_;
 }
 
@@ skipping 62 matching lines @@
       LoginHandler* handler = details_ptr->handler();
       DCHECK(handler != NULL);
       RenderViewHostDelegate* delegate = handler->GetRenderViewHostDelegate();
       if (delegate == GetRenderViewHostDelegate()) {
         Destroy(FINAL_STATUS_AUTH_NEEDED);
         return;
       }
       break;
     }
 
+    // TODO(mmenke):  Once we get rid of the old RenderViewHost code, remove
+    //                this.
     case NotificationType::DOWNLOAD_INITIATED: {
       // If the download is started from a RenderViewHost that we are
       // delegating, kill the prerender. This cancels any pending requests
       // though the download never actually started thanks to the
       // DownloadRequestLimiter.
       DCHECK(NotificationService::NoDetails() == details);
       RenderViewHost* render_view_host = Source<RenderViewHost>(source).ptr();
       CHECK(render_view_host != NULL);
       if (render_view_host->delegate() == GetRenderViewHostDelegate()) {
         Destroy(FINAL_STATUS_DOWNLOAD);
@@ skipping 258 matching lines @@
   if (render_view_host_observer_.get())
     render_view_host_observer_->set_prerender_contents(NULL);
 }
 
 void PrerenderContents::RendererUnresponsive(RenderViewHost* render_view_host,
                                              bool is_during_unload) {
   DCHECK_EQ(render_view_host_, render_view_host);
   Destroy(FINAL_STATUS_RENDERER_UNRESPONSIVE);
 }
 
+bool PrerenderContents::CanDownload(int request_id) {
+  Destroy(FINAL_STATUS_DOWNLOAD);
+  // Cancel the download.
+  return false;
+}
+
+void PrerenderContents::OnStartDownload(DownloadItem* download,
+                                        TabContentsWrapper* tab) {
+  // Prerendered pages should never be able to download files.
+  NOTREACHED();
+}
+
 base::ProcessMetrics* PrerenderContents::MaybeGetProcessMetrics() {
   if (process_metrics_.get() == NULL) {
     // If a PrenderContents hasn't started prerending, don't be fully formed.
     if (!render_view_host() || !render_view_host()->process())
       return NULL;
     base::ProcessHandle handle = render_view_host()->process()->GetHandle();
     if (handle == base::kNullProcessHandle)
       return NULL;
 #if !defined(OS_MACOSX)
     process_metrics_.reset(base::ProcessMetrics::CreateProcessMetrics(handle));
@@ skipping 16 matching lines @@
   if (metrics->GetMemoryBytes(&private_bytes, &shared_bytes)) {
     if (private_bytes >
         prerender_manager_->max_prerender_memory_mb() * 1024 * 1024) {
       Destroy(FINAL_STATUS_MEMORY_LIMIT_EXCEEDED);
     }
   }
 }
 
 TabContentsWrapper* PrerenderContents::ReleasePrerenderContents() {
   render_view_host_observer_.reset();
+  prerender_contents_->download_tab_helper()->set_delegate(NULL);
   return prerender_contents_.release();
 }
 
 RenderViewHostDelegate* PrerenderContents::GetRenderViewHostDelegate() {
   if (UseTabContents()) {
     if (!prerender_contents_.get())
       return NULL;
     return prerender_contents_->tab_contents();
   } else {
     return this;
@@ skipping 14 matching lines @@
   }
   return render_view_host_;
 }
 
 void PrerenderContents::CommitHistory(TabContents* tc) {
   if (tab_contents_delegate_.get())
     tab_contents_delegate_->CommitHistory(tc);
 }
 
 }  // namespace prerender