Use defer out-params instead of ResourceDispatcherHostImpl::PauseRequest(...true)

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 1216 matching lines @@
                  << child_id << ", " << request_id << ")";
     return;
   }
 
   // TODO(eroman): are there other considerations for paused or blocked
   //               requests?
 
   StartRequest(i->second);
 }
 
+void ResourceDispatcherHostImpl::ResumeDeferredRequest(int child_id,
+                                                       int request_id) {
+  PauseRequest(child_id, request_id, false);
+}
+
 bool ResourceDispatcherHostImpl::WillSendData(int child_id,
                                               int request_id) {
   PendingRequestList::iterator i = pending_requests_.find(
       GlobalRequestID(child_id, request_id));
   if (i == pending_requests_.end()) {
     NOTREACHED() << "WillSendData for invalid request";
     return false;
   }
 
   ResourceRequestInfoImpl* info =
       ResourceRequestInfoImpl::ForRequest(i->second);
 
   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.
     PauseRequest(child_id, request_id, true);
     return false;
   }
 
   return true;
 }
 
-void ResourceDispatcherHostImpl::PauseRequest(int child_id,
-                                              int request_id,
-                                              bool pause) {
-  GlobalRequestID global_id(child_id, request_id);
-  PendingRequestList::iterator i = pending_requests_.find(global_id);
-  if (i == pending_requests_.end()) {
-    DVLOG(1) << "Pausing a request that wasn't found";
-    return;
-  }
-
-  ResourceRequestInfoImpl* info =
-      ResourceRequestInfoImpl::ForRequest(i->second);
-  int pause_count = info->pause_count() + (pause ? 1 : -1);
-  if (pause_count < 0) {
-    NOTREACHED();  // Unbalanced call to pause.
-    return;
-  }
-  info->set_pause_count(pause_count);
-
-  VLOG(1) << "To pause (" << pause << "): " << i->second->url().spec();
-
-  // If we're resuming, kick the request to start reading again. Run the read
-  // asynchronously to avoid recursion problems.
-  if (info->pause_count() == 0) {
-    MessageLoop::current()->PostTask(FROM_HERE,
-        base::Bind(
-            &ResourceDispatcherHostImpl::ResumeRequest,
-            weak_factory_.GetWeakPtr(),
-            global_id));
-  }
-}
-
 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 287 matching lines @@
         request->ssl_info().connection_status);
   } else {
     // We should not have any SSL state.
     DCHECK(!request->ssl_info().cert_status &&
            request->ssl_info().security_bits == -1 &&
            !request->ssl_info().connection_status);
   }
 
   NotifyResponseStarted(request, info->GetChildID());
   info->set_called_on_response_started(true);
-  return info->resource_handler()->OnResponseStarted(info->GetRequestID(),
-                                                     response.get());
+
+  bool defer = false;
+  if (!info->resource_handler()->OnResponseStarted(info->GetRequestID(),
+                                                   response.get(),
+                                                   &defer))
+    return false;
+
+  if (defer)
+    PauseRequest(info->GetChildID(), info->GetRequestID(), true);
+
+  return true;
 }
 
 void ResourceDispatcherHostImpl::CancelRequest(int child_id,
                                                int request_id,
                                                bool from_renderer) {
   GlobalRequestID id(child_id, request_id);
   if (from_renderer) {
     // When the old renderer dies, it sends a message to us to cancel its
     // requests.
     if (transferred_navigations_.find(id) != transferred_navigations_.end())
@@ skipping 167 matching lines @@
   }
 }
 
 bool ResourceDispatcherHostImpl::PauseRequestIfNeeded(
     ResourceRequestInfoImpl* info) {
   if (info->pause_count() > 0)
     info->set_is_paused(true);
   return info->is_paused();
 }
 
+void ResourceDispatcherHostImpl::PauseRequest(int child_id,
+                                              int request_id,
+                                              bool pause) {
+  GlobalRequestID global_id(child_id, request_id);
+  PendingRequestList::iterator i = pending_requests_.find(global_id);
+  if (i == pending_requests_.end()) {
+    DVLOG(1) << "Pausing a request that wasn't found";
+    return;
+  }
+
+  ResourceRequestInfoImpl* info =
+      ResourceRequestInfoImpl::ForRequest(i->second);
+  int pause_count = info->pause_count() + (pause ? 1 : -1);
+  if (pause_count < 0) {
+    NOTREACHED();  // Unbalanced call to pause.
+    return;
+  }
+  info->set_pause_count(pause_count);
+
+  VLOG(1) << "To pause (" << pause << "): " << i->second->url().spec();
+
+  // If we're resuming, kick the request to start reading again. Run the read
+  // asynchronously to avoid recursion problems.
+  if (info->pause_count() == 0) {
+    MessageLoop::current()->PostTask(FROM_HERE,
+        base::Bind(
+            &ResourceDispatcherHostImpl::ResumeRequest,
+            weak_factory_.GetWeakPtr(),
+            global_id));
+  }
+}
+
 void ResourceDispatcherHostImpl::ResumeRequest(
     const GlobalRequestID& request_id) {
   PendingRequestList::iterator i = pending_requests_.find(request_id);
   if (i == pending_requests_.end())  // The request may have been destroyed
     return;
 
   net::URLRequest* request = i->second;
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
 
   // We may already be unpaused, or the pause count may have increased since we
@@ skipping 121 matching lines @@
 }
 
 bool ResourceDispatcherHostImpl::CompleteRead(net::URLRequest* request,
                                               int* bytes_read) {
   if (!request || !request->status().is_success()) {
     NOTREACHED();
     return false;
   }
 
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
+
+  bool defer = false;
   if (!info->resource_handler()->OnReadCompleted(info->GetRequestID(),
-                                                 bytes_read)) {
+                                                 bytes_read, &defer)) {
     CancelRequestInternal(request, false);
     return false;
   }
 
+  if (defer)
+    PauseRequest(info->GetChildID(), info->GetRequestID(), true);
+
   return *bytes_read != 0;
 }
 
 void ResourceDispatcherHostImpl::ResponseCompleted(net::URLRequest* request) {
   VLOG(1) << "ResponseCompleted: " << request->url().spec();
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
 
   // If the load for a main frame has failed, track it in a histogram,
   // since it will probably cause the user to see an error page.
   if (!request->status().is_success() &&
@@ skipping 392 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