Move TransferNavigationResourceThrottle to content since that's where it belongs. This is a step in…

content/browser/renderer_host/resource_dispatcher_host_impl.cc

 // Copyright (c) 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/renderer_host/resource_dispatcher_host_impl.h"
 
 #include <set>
 #include <vector>
@@ skipping 21 matching lines @@
 #include "content/browser/download/save_file_resource_handler.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/plugin_service_impl.h"
 #include "content/browser/renderer_host/async_resource_handler.h"
 #include "content/browser/renderer_host/buffered_resource_handler.h"
 #include "content/browser/renderer_host/cross_site_resource_handler.h"
 #include "content/browser/renderer_host/doomed_resource_handler.h"
 #include "content/browser/renderer_host/redirect_to_file_resource_handler.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/resource_message_filter.h"
-#include "content/public/browser/resource_request_details.h"
+#include "content/browser/renderer_host/transfer_navigation_resource_throttle.h"
 #include "content/browser/renderer_host/resource_request_info_impl.h"
 #include "content/browser/renderer_host/sync_resource_handler.h"
 #include "content/browser/renderer_host/throttling_resource_handler.h"
 #include "content/browser/resource_context_impl.h"
 #include "content/browser/ssl/ssl_client_auth_handler.h"
 #include "content/browser/ssl/ssl_manager.h"
 #include "content/browser/worker_host/worker_service_impl.h"
 #include "content/common/resource_messages.h"
 #include "content/common/ssl_status_serialization.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/global_request_id.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host_delegate.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_dispatcher_host_login_delegate.h"
+#include "content/public/browser/resource_request_details.h"
 #include "content/public/browser/resource_throttle.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/auth.h"
 #include "net/base/cert_status_flags.h"
 #include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/registry_controlled_domain.h"
@@ skipping 474 matching lines @@
   return net::OK;
 }
 
 void ResourceDispatcherHostImpl::ClearLoginDelegateForRequest(
     net::URLRequest* request) {
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
   if (info)
     info->set_login_delegate(NULL);
 }
 
-void ResourceDispatcherHostImpl::MarkAsTransferredNavigation(
-    net::URLRequest* transferred_request) {
-  ResourceRequestInfoImpl* info =
-      ResourceRequestInfoImpl::ForRequest(transferred_request);
-
-  GlobalRequestID transferred_request_id(info->GetChildID(),
-                                         info->GetRequestID());
-  transferred_navigations_[transferred_request_id] = transferred_request;
-
-  // If a URLRequest is transferred to a new RenderViewHost, its
-  // ResourceHandler should not receive any notifications because it may
-  // depend on the state of the old RVH. We set a ResourceHandler that only
-  // allows canceling requests, because on shutdown of the RDH all pending
-  // requests are canceled. The RVH of requests that are being transferred may
-  // be gone by that time. If the request is resumed, the ResoureHandlers are
-  // substituted again.
-  scoped_refptr<ResourceHandler> transferred_resource_handler(
-      new DoomedResourceHandler(info->resource_handler()));
-  info->set_resource_handler(transferred_resource_handler.get());
-}
-
 void ResourceDispatcherHostImpl::Shutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&ResourceDispatcherHostImpl::OnShutdown,
                                      base::Unretained(this)));
 }
 
 scoped_refptr<ResourceHandler>
 ResourceDispatcherHostImpl::CreateResourceHandlerForDownload(
@@ skipping 305 matching lines @@
       CrossSiteRequestManager::GetInstance()->
           HasPendingCrossSiteRequest(child_id, route_id)) {
     // Wrap the event handler to be sure the current page's onunload handler
     // has a chance to run before we render the new page.
     handler = new CrossSiteResourceHandler(handler, child_id, route_id, this);
   }
 
   // Insert a buffered event handler before the actual one.
   handler = new BufferedResourceHandler(handler, this, request);
 
+  ScopedVector<ResourceThrottle> throttles;
   if (delegate_) {
     bool is_continuation_of_transferred_request =
         (deferred_request != NULL);
 
-    ScopedVector<ResourceThrottle> throttles;
     delegate_->RequestBeginning(request,
                                 resource_context,
                                 request_data.resource_type,
                                 child_id,
                                 route_id,
                                 is_continuation_of_transferred_request,
                                 &throttles);
-    if (!throttles.empty()) {
-      handler = new ThrottlingResourceHandler(this, handler, child_id,
-                                              request_id, throttles.Pass());
-    }
+  }
+
+  if (request_data.resource_type == ResourceType::MAIN_FRAME) {
+    throttles.insert(
+        throttles.begin(), new TransferNavigationResourceThrottle(request));
+  }
+
+  if (!throttles.empty()) {
+    handler = new ThrottlingResourceHandler(this, handler, child_id, request_id,
+                                            throttles.Pass());
   }
 
   bool allow_download = request_data.allow_download &&
       ResourceType::IsFrame(request_data.resource_type);
   // Make extra info and read footer (contains request ID).
   ResourceRequestInfoImpl* extra_info =
       new ResourceRequestInfoImpl(
           handler,
           process_type,
           child_id,
@@ skipping 329 matching lines @@
     // We reached the max number of data messages that can be sent to
     // the renderer for a given request. Pause the request and wait for
     // the renderer to start processing them before resuming it.
     PauseRequest(child_id, request_id, true);
     return false;
   }
 
   return true;
 }
 
+void ResourceDispatcherHostImpl::MarkAsTransferredNavigation(
+    net::URLRequest* transferred_request) {
+  ResourceRequestInfoImpl* info =
+      ResourceRequestInfoImpl::ForRequest(transferred_request);
+
+  GlobalRequestID transferred_request_id(info->GetChildID(),
+                                         info->GetRequestID());
+  transferred_navigations_[transferred_request_id] = transferred_request;
+
+  // If a URLRequest is transferred to a new RenderViewHost, its
+  // ResourceHandler should not receive any notifications because it may
+  // depend on the state of the old RVH. We set a ResourceHandler that only
+  // allows canceling requests, because on shutdown of the RDH all pending
+  // requests are canceled. The RVH of requests that are being transferred may
+  // be gone by that time. If the request is resumed, the ResoureHandlers are
+  // substituted again.
+  scoped_refptr<ResourceHandler> transferred_resource_handler(
+      new DoomedResourceHandler(info->resource_handler()));
+  info->set_resource_handler(transferred_resource_handler.get());
+}
+
 int ResourceDispatcherHostImpl::GetOutstandingRequestsMemoryCost(
     int child_id) const {
   OutstandingRequestsMemoryCostMap::const_iterator entry =
       outstanding_requests_memory_cost_map_.find(child_id);
   return (entry == outstanding_requests_memory_cost_map_.end()) ?
       0 : entry->second;
 }
 
 // The object died, so cancel and detach all requests associated with it except
 // for downloads, which belong to the browser process even if initiated via a
@@ skipping 1077 matching lines @@
   return allow_cross_origin_auth_prompt_;
 }
 
 bool ResourceDispatcherHostImpl::IsTransferredNavigation(
     const GlobalRequestID& transferred_request_id) const {
   return transferred_navigations_.find(transferred_request_id) !=
       transferred_navigations_.end();
 }
 
 }  // namespace content