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

chrome/browser/renderer_host/download_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_resource_handler.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/download/download_item.h"
 #include "chrome/browser/download/download_file_manager.h"
 #include "chrome/browser/history/download_create_info.h"
 #include "chrome/browser/renderer_host/global_request_id.h"
+#include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host_request_info.h"
+#include "chrome/common/notification_service.h"
 #include "chrome/common/resource_response.h"
 #include "net/base/io_buffer.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_context.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
+
 DownloadResourceHandler::DownloadResourceHandler(
     ResourceDispatcherHost* rdh,
     int render_process_host_id,
     int render_view_id,
     int request_id,
     const GURL& url,
     DownloadFileManager* download_file_manager,
     net::URLRequest* request,
     bool save_as,
     const DownloadSaveInfo& save_info)
     : download_id_(-1),
       global_id_(render_process_host_id, request_id),
       render_view_id_(render_view_id),
       url_(url),
       original_url_(url),
       content_length_(0),
       download_file_manager_(download_file_manager),
       request_(request),
       save_as_(save_as),
       save_info_(save_info),
       buffer_(new DownloadBuffer),
       rdh_(rdh),
       is_paused_(false),
       url_check_pending_(false) {
+   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/13 03:08:36]

I'd rather not notify from the DownloadResourceHandler constructor, as that'll
mean in the case where a download comes off of the usual path (i.e. through the
DownloadThrottlingResourceHandler) you'll get two notifications that the same
download is starting.  I don't like the fragility of putting the notification in
ResourceDispatcherHost::BeginDownload, but it has the advantage of covering all
the (current :-{) pathways through which a download can be initiated while still
giving you the notification you're looking for when the initiation doesn't
actually go through to creating a DownloadResourceHandler.

[dominich, 2011/02/14 16:07:12]

I was considering download_util::DownloadUrl as an alternative to
RDH::BeginDownload as it may be a little more future-proof. What do you think?

[Randy Smith (Not in Mondays), 2011/02/14 19:20:51]

Neither one's particularly future-proof, I'm afraid :-{.  I have (vague) plans
to get rid of download_util based on a recent rant of Brett's on chromium-dev,
and no current plans to get rid of RDH::BeginDownload, but I don't consider
either of them part of a particularly clean architecture.  It's sort of like the
breakfast cereal adds: "Standing next to ^W ^W Part of this complete
architecture" :-} :-J.

Having said that, I'd vote in favor of RDH just because there's a path that
initiales a download that doesn't get notified if we use download_util:
ResourceMessageFilter::OnDownloadUrl -> ResourceDispatcherHost::BeginDownload->
DownloadResourceHandler().  That happens when the renderer processes sends us a
message requesting a download; I'm still not sure under what circumstances that
happens, but if the path's in the code, I'd like to catch it.

 }
 
 bool DownloadResourceHandler::OnUploadProgress(int request_id,
                                                uint64 position,
                                                uint64 size) {
   return true;
 }
 
 // Not needed, as this event handler ought to be the final resource.
 bool DownloadResourceHandler::OnRequestRedirected(int request_id,
@@ skipping 250 matching lines @@
                             render_view_id_,
                             save_info_.file_path.value().c_str());
 }
 
 void DownloadResourceHandler::UpdateDownloadUrlCheckStats(
     SBStatsType stat_type) {
   UMA_HISTOGRAM_ENUMERATION("SB2.DownloadUrlChecks",
                             stat_type,
                             DOWNLOAD_URL_CHECKS_MAX);
 }