Cancel prerender when we discover a download starting from a page we are prer...

chrome/browser/renderer_host/download_throttling_resource_handler.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/renderer_host/download_throttling_resource_handler.h"
 
 #include "base/logging.h"
 #include "chrome/browser/renderer_host/download_resource_handler.h"
+#include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
+#include "chrome/common/notification_service.h"
 #include "chrome/common/resource_response.h"
 #include "net/base/io_buffer.h"
 #include "net/base/mime_sniffer.h"
 
+namespace {
+void NotifyOnUI(NotificationType::Type notification_type,
+                int process_id, int view_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  RenderViewHost* rvh = RenderViewHost::FromID(process_id, view_id);
+  if (!rvh)
+    return;
+
+  NotificationService::current()->Notify(notification_type,
+                                         Source<RenderViewHost>(rvh),
+                                         NotificationService::NoDetails());
+}
+}  // namespace
+
 DownloadThrottlingResourceHandler::DownloadThrottlingResourceHandler(
     ResourceDispatcherHost* host,
     net::URLRequest* request,
     const GURL& url,
     int render_process_host_id,
     int render_view_id,
     int request_id,
     bool in_complete)
     : host_(host),
       request_(request),
       url_(url),
       render_process_host_id_(render_process_host_id),
       render_view_id_(render_view_id),
       request_id_(request_id),
       tmp_buffer_length_(0),
       ignore_on_read_complete_(in_complete) {
   // Pause the request.
   host_->PauseRequest(render_process_host_id_, request_id_, true);
   host_->download_request_limiter()->CanDownloadOnIOThread(
       render_process_host_id_, render_view_id, this);
- }
+}
 
 DownloadThrottlingResourceHandler::~DownloadThrottlingResourceHandler() {
 }
 
 bool DownloadThrottlingResourceHandler::OnUploadProgress(int request_id,
                                                          uint64 position,
                                                          uint64 size) {
   if (download_handler_.get())
     return download_handler_->OnUploadProgress(request_id, position, size);
   return true;
 }
 
 bool DownloadThrottlingResourceHandler::OnRequestRedirected(
     int request_id,
     const GURL& url,
     ResourceResponse* response,
     bool* defer) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      NewRunnableFunction(&NotifyOnUI, NotificationType::DOWNLOAD_INITIATED,
+                          render_process_host_id_, render_view_id_));
   if (download_handler_.get()) {
     return download_handler_->OnRequestRedirected(
         request_id, url, response, defer);
   }
   url_ = url;
   return true;
 }
 
 bool DownloadThrottlingResourceHandler::OnResponseStarted(
     int request_id,
     ResourceResponse* response) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      NewRunnableFunction(&NotifyOnUI, NotificationType::DOWNLOAD_INITIATED,
+                          render_process_host_id_, render_view_id_));

[Randy Smith (Not in Mondays), 2011/02/11 18:44:15]

Why do separate notifications for request redirected and response started?  It's
a single download.  

My inclination would be to put the notification in the constructor; any reason
not to do that?

[dominich, 2011/02/11 22:51:54]

Done.

+
   if (download_handler_.get())
     return download_handler_->OnResponseStarted(request_id, response);
   response_ = response;
   return true;
 }
 
 bool DownloadThrottlingResourceHandler::OnWillStart(int request_id,
                                                     const GURL& url,
                                                     bool* defer) {
   if (download_handler_.get())
     return download_handler_->OnWillStart(request_id, url, defer);
   return true;
 }
 
 bool DownloadThrottlingResourceHandler::OnWillRead(int request_id,
                                                    net::IOBuffer** buf,
                                                    int* buf_size,
                                                    int min_size) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      NewRunnableFunction(&NotifyOnUI, NotificationType::DOWNLOAD_INITIATED,

[dominich, 2011/02/10 20:02:17]

Moving this to OnWillStart for the same reasons as outlined below. This is
called once but only once we've started.

+                          render_process_host_id_, render_view_id_));
   if (download_handler_.get())
     return download_handler_->OnWillRead(request_id, buf, buf_size, min_size);
 
   // We should only have this invoked once, as such we only deal with one
   // tmp buffer.
   DCHECK(!tmp_buffer_.get());
   // If the caller passed a negative |min_size| then chose an appropriate
   // default. The BufferedResourceHandler requires this to be at least 2 times
   // the size required for mime detection.
   if (min_size < 0)
@@ skipping 14 matching lines @@
   if (!*bytes_read)
     return true;
 
   if (tmp_buffer_.get()) {
     DCHECK(!tmp_buffer_length_);
     tmp_buffer_length_ = *bytes_read;
     if (download_handler_.get())
       CopyTmpBufferToDownloadHandler();
     return true;
   }
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,

[cbentzel, 2011/02/10 19:32:18]

I really don't think this is what you want - it will send out a notification
each time some bytes are read from the stream. 

[dominich, 2011/02/10 20:02:17]

You're right - I was going from rdsmith's diagram of entry points but it looks
like this one can't be hit without one of the other entry points being hit
first.

[dominich, 2011/02/10 20:02:17]

Done.

[Randy Smith (Not in Mondays), 2011/02/11 18:44:15]

Sorry; that diagram shows control flow within the download system.  For all the
reasons we've talked about, that's probably not relevant to you; the limiter
keeps the download from actually starting in the common case.  I think you want
the notification just from the constructor.

+      NewRunnableFunction(&NotifyOnUI, NotificationType::DOWNLOAD_INITIATED,
+                          render_process_host_id_, render_view_id_));
   if (download_handler_.get())
     return download_handler_->OnReadCompleted(request_id, bytes_read);
   return true;
 }
 
 bool DownloadThrottlingResourceHandler::OnResponseCompleted(
     int request_id,
     const net::URLRequestStatus& status,
     const std::string& security_info) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      NewRunnableFunction(&NotifyOnUI, NotificationType::DOWNLOAD_INITIATED,

[dominich, 2011/02/10 20:02:17]

This suffers from the same issue as above. Even though it is an entry point from
RDH, it is only called when a download request cannot be initiated or has
completed. Neither match the concept of an initiated download so I'm removing
this too.

+                          render_process_host_id_, render_view_id_));
   if (download_handler_.get())
     return download_handler_->OnResponseCompleted(request_id, status,
                                                   security_info);
 
   // For a download, if ResourceDispatcher::Read() fails,
   // ResourceDispatcher::OnresponseStarted() will call
   // OnResponseCompleted(), and we will end up here with an error
   // status.
   if (!status.is_success())
     return false;
@@ skipping 42 matching lines @@
   int buf_size;
   if (download_handler_->OnWillRead(request_id_, &buffer, &buf_size,
                                     tmp_buffer_length_)) {
     CHECK(buf_size >= tmp_buffer_length_);
     memcpy(buffer->data(), tmp_buffer_->data(), tmp_buffer_length_);
     download_handler_->OnReadCompleted(request_id_, &tmp_buffer_length_);
   }
   tmp_buffer_length_ = 0;
   tmp_buffer_ = NULL;
 }