Factor out dependncy on download throttling from core download code.

chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.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/chrome_resource_dispatcher_host_delegate.h"
 
 #include "base/logging.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
+#include "chrome/browser/download/download_request_limiter.h"
+#include "chrome/browser/download/download_throttling_resource_handler.h"
+#include "chrome/browser/download/download_util.h"
 #include "chrome/browser/external_protocol/external_protocol_handler.h"
 #include "chrome/browser/net/load_timing_observer.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/browser/renderer_host/safe_browsing_resource_handler.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/ui/autologin_infobar_delegate.h"
 #include "chrome/browser/ui/login/login_prompt.h"
 #include "chrome/common/extensions/user_script.h"
@@ skipping 29 matching lines @@
                                                       url,
                                                       referrer);
 }
 
 }  // end namespace
 
 ChromeResourceDispatcherHostDelegate::ChromeResourceDispatcherHostDelegate(
     ResourceDispatcherHost* resource_dispatcher_host,
     prerender::PrerenderTracker* prerender_tracker)
     : resource_dispatcher_host_(resource_dispatcher_host),
+      download_request_limiter_(g_browser_process->download_request_limiter()),
       safe_browsing_(g_browser_process->safe_browsing_service()),
       prerender_tracker_(prerender_tracker) {
 }
 
 ChromeResourceDispatcherHostDelegate::~ChromeResourceDispatcherHostDelegate() {
 }
 
 bool ChromeResourceDispatcherHostDelegate::ShouldBeginRequest(
     int child_id, int route_id,
     const ResourceHostMsg_Request& request_data,
@@ skipping 66 matching lines @@
   // We check offline first, then check safe browsing so that we still can block
   // unsafe site after we remove offline page.
   handler = new OfflineResourceHandler(
       handler, child_id, route_id, resource_dispatcher_host_, request,
       resource_context.appcache_service());
 #endif
   return handler;
 }
 
 ResourceHandler* ChromeResourceDispatcherHostDelegate::DownloadStarting(
-    ResourceHandler* handler,
-    const content::ResourceContext& resource_context,
-    int child_id,
-    int route_id) {
+      ResourceHandler* handler,
+      const content::ResourceContext& resource_context,
+      net::URLRequest* request,
+      int child_id,
+      int route_id,
+      int request_id,
+      bool is_new_request,
+      bool in_complete) {
+
+  // If this isn't a new request, we've seen this before and added the safe
+  // browsing resource handler already so no need to add it again. This code
+  // path is only hit for requests initiated through the browser, and not the
+  // web, so no need to add the throttling handler.
+  if (is_new_request) {
 #if defined(ENABLE_SAFE_BROWSING)
-  ProfileIOData* io_data = reinterpret_cast<ProfileIOData*>(
-      resource_context.GetUserData(NULL));
-  if (!io_data->safe_browsing_enabled()->GetValue())
+    ProfileIOData* io_data = reinterpret_cast<ProfileIOData*>(
+        resource_context.GetUserData(NULL));
+    if (!io_data->safe_browsing_enabled()->GetValue())
+      return handler;
+
+    return CreateSafeBrowsingResourceHandler(
+        handler, child_id, route_id, false);
+#else
     return handler;
+#endif
+  }
 
-  return CreateSafeBrowsingResourceHandler(handler, child_id, route_id, false);
-#else
-  return handler;
-#endif
+  return new DownloadThrottlingResourceHandler(
+      handler, resource_dispatcher_host_, download_request_limiter_, request,
+      request->url(), child_id, route_id, request_id, in_complete);
 }
 
 bool ChromeResourceDispatcherHostDelegate::ShouldDeferStart(
     net::URLRequest* request,
     const content::ResourceContext& resource_context) {
   ResourceDispatcherHostRequestInfo* info =
       resource_dispatcher_host_->InfoForRequest(request);
   return prerender_tracker_->PotentiallyDelayRequestOnIOThread(
       request->url(), resource_context.prerender_manager_getter(),
       info->child_id(), info->route_id(), info->request_id());
@@ skipping 96 matching lines @@
   AutoLoginInfoBarDelegate::ShowIfAutoLoginRequested(request, info->child_id(),
                                                      info->route_id());
 }
 
 void ChromeResourceDispatcherHostDelegate::OnRequestRedirected(
     net::URLRequest* request,
     ResourceResponse* response,
     ResourceMessageFilter* filter) {
   LoadTimingObserver::PopulateTimingInfo(request, response);
 }