Balance defers with Resume.

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 81 matching lines @@
 
 namespace content {
 
 namespace {
 
 static ResourceDispatcherHostImpl* g_resource_dispatcher_host;
 
 // The interval for calls to ResourceDispatcherHostImpl::UpdateLoadStates
 const int kUpdateLoadStatesIntervalMsec = 100;
 
-// Maximum number of pending data messages sent to the renderer at any
-// given time for a given request.
-const int kMaxPendingDataMessages = 20;
-
 // Maximum byte "cost" of all the outstanding requests for a renderer.
 // See delcaration of |max_outstanding_requests_cost_per_process_| for details.
 // This bound is 25MB, which allows for around 6000 outstanding requests.
 const int kMaxOutstandingRequestsCostPerProcess = 26214400;
 
 // The number of milliseconds after noting a user gesture that we will
 // tag newly-created URLRequest objects with the
 // net::LOAD_MAYBE_USER_GESTURE load flag. This is a fairly arbitrary
 // guess at how long to expect direct impact from a user gesture, but
 // this should be OK as the load flag is a best-effort thing only,
@@ skipping 810 matching lines @@
                                                   route_id,
                                                   request_data.method,
                                                   request_data.url,
                                                   request_data.resource_type,
                                                   resource_context,
                                                   referrer)) {
     AbortRequestBeforeItStarts(filter_, sync_result, route_id, request_id);
     return;
   }
 
-  // Construct the event handler.
-  scoped_ptr<ResourceHandler> handler;
-  if (sync_result) {
-    handler.reset(new SyncResourceHandler(
-        filter_, request_data.url, sync_result, this));
-  } else {
-    handler.reset(new AsyncResourceHandler(
-        filter_, route_id, request_data.url, this));
-  }
-
-  // The RedirectToFileResourceHandler depends on being next in the chain.
-  if (request_data.download_to_file) {
-    handler.reset(
-        new RedirectToFileResourceHandler(handler.Pass(), child_id, this));
-  }
-
   int load_flags =
       BuildLoadFlagsForRequest(request_data, child_id, sync_result != NULL);
 
   // Construct the request.
   scoped_ptr<net::URLRequest> new_request;
   net::URLRequest* request;
   if (deferred_loader.get()) {
     request = deferred_loader->request();
   } else {
     new_request.reset(new net::URLRequest(request_data.url, NULL));
@@ skipping 20 matching lines @@
 
   // Set upload data.
   uint64 upload_size = 0;
   if (request_data.upload_data) {
     request->set_upload(request_data.upload_data);
     // This results in performing file IO. crbug.com/112607.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     upload_size = request_data.upload_data->GetContentLengthSync();
   }
 
+  // Construct the IPC resource handler.
+  scoped_ptr<ResourceHandler> handler;
+  if (sync_result) {
+    handler.reset(new SyncResourceHandler(
+        filter_, request, sync_result, this));
+  } else {
+    handler.reset(new AsyncResourceHandler(
+        filter_, route_id, request, this));
+  }
+
+  // The RedirectToFileResourceHandler depends on being next in the chain.
+  if (request_data.download_to_file) {
+    handler.reset(
+        new RedirectToFileResourceHandler(handler.Pass(), child_id, this));
+  }
+
   // Install a CrossSiteResourceHandler if this request is coming from a
   // RenderViewHost with a pending cross-site request.  We only check this for
   // MAIN_FRAME requests. Unblock requests only come from a blocked page, do
   // not count as cross-site, otherwise it gets blocked indefinitely.
   if (request_data.resource_type == ResourceType::MAIN_FRAME &&
       process_type == PROCESS_TYPE_RENDERER &&
       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.reset(
-        new CrossSiteResourceHandler(handler.Pass(), child_id, route_id, this));
+    handler.reset(new CrossSiteResourceHandler(handler.Pass(), child_id,
+                                               route_id, request));
   }
 
   // Insert a buffered event handler before the actual one.
   handler.reset(
       new BufferedResourceHandler(handler.Pass(), this, request));
 
   ScopedVector<ResourceThrottle> throttles;
   if (delegate_) {
     bool is_continuation_of_transferred_request =
         (deferred_loader.get() != NULL);
@@ skipping 63 matching lines @@
   } else {
     BeginRequestInternal(new_request.Pass(), handler.Pass());
   }
 }
 
 void ResourceDispatcherHostImpl::OnReleaseDownloadedFile(int request_id) {
   UnregisterDownloadedTempFile(filter_->child_id(), request_id);
 }
 
 void ResourceDispatcherHostImpl::OnDataReceivedACK(int request_id) {
-  DataReceivedACK(filter_->child_id(), request_id);
-}
-
-void ResourceDispatcherHostImpl::DataReceivedACK(int child_id,
-                                                 int request_id) {
-  ResourceLoader* loader = GetLoader(child_id, request_id);
+  ResourceLoader* loader = GetLoader(filter_->child_id(), request_id);
   if (!loader)
     return;
 
   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
-
-  // Decrement the number of pending data messages.
-  info->DecrementPendingDataCount();
-
-  // If the pending data count was higher than the max, resume the request.
-  if (info->pending_data_count() == kMaxPendingDataMessages) {
-    // Decrement the pending data count one more time because we also
-    // incremented it before pausing the request.
-    info->DecrementPendingDataCount();
-
-    // Resume the request.
-    //
-    // TODO(darin): Make the AsyncResourceHandler be responsible for resuming
-    // via its controller().  This static_cast is here as a temporary measure.
-    //
-    static_cast<ResourceController*>(loader)->Resume();
-  }
+  if (info->async_handler())
+    info->async_handler()->OnDataReceivedACK();
 }
 
 void ResourceDispatcherHostImpl::OnDataDownloadedACK(int request_id) {
   // TODO(michaeln): maybe throttle DataDownloaded messages
 }
 
 void ResourceDispatcherHostImpl::RegisterDownloadedTempFile(
     int child_id, int request_id, ShareableFileReference* reference) {
   registered_temp_files_[child_id][request_id] = reference;
   ChildProcessSecurityPolicyImpl::GetInstance()->GrantReadFile(
@@ skipping 43 matching lines @@
 void ResourceDispatcherHostImpl::OnFollowRedirect(
     int request_id,
     bool has_new_first_party_for_cookies,
     const GURL& new_first_party_for_cookies) {
   ResourceLoader* loader = GetLoader(filter_->child_id(), request_id);
   if (!loader) {
     DVLOG(1) << "OnFollowRedirect for invalid request";
     return;
   }
 
-  loader->OnFollowRedirect(has_new_first_party_for_cookies,
-                           new_first_party_for_cookies);
+  ResourceRequestInfoImpl* info = loader->GetRequestInfo();
+  if (info->async_handler()) {
+    info->async_handler()->OnFollowRedirect(
+        has_new_first_party_for_cookies,
+        new_first_party_for_cookies);
+  }
 }
 
 ResourceRequestInfoImpl* ResourceDispatcherHostImpl::CreateRequestInfo(
     int child_id,
     int route_id,
     bool download,
     ResourceContext* context) {
   return new ResourceRequestInfoImpl(
       PROCESS_TYPE_RENDERER,
       child_id,
@@ skipping 94 matching lines @@
   request->set_context(context->GetRequestContext());
 
   // Since we're just saving some resources we need, disallow downloading.
   ResourceRequestInfoImpl* extra_info =
       CreateRequestInfo(child_id, route_id, false, context);
   extra_info->AssociateWithRequest(request.get());  // Request takes ownership.
 
   BeginRequestInternal(request.Pass(), handler.Pass());
 }
 
-bool ResourceDispatcherHostImpl::WillSendData(int child_id, int request_id,
-                                              bool* defer) {
-  ResourceLoader* loader = GetLoader(child_id, request_id);
-  if (!loader) {
-    NOTREACHED() << "WillSendData for invalid request";
-    return false;
-  }
-
-  ResourceRequestInfoImpl* info = loader->GetRequestInfo();
-
-  info->IncrementPendingDataCount();
-  if (info->pending_data_count() > kMaxPendingDataMessages) {
-    // 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.
-    *defer = true;
-    return false;
-  }
-
-  return true;
-}
-
 void ResourceDispatcherHostImpl::MarkAsTransferredNavigation(
     const GlobalRequestID& id) {
   GetLoader(id)->MarkAsTransferring();
 }
 
 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()) ?
@@ skipping 431 matching lines @@
 
   return i->second.get();
 }
 
 ResourceLoader* ResourceDispatcherHostImpl::GetLoader(int child_id,
                                                       int request_id) const {
   return GetLoader(GlobalRequestID(child_id, request_id));
 }
 
 }  // namespace content