Rewrite guts of ResourceLoader and BufferedResourceHandler to suck less.

content/browser/renderer_host/async_resource_handler.cc

Index: content/browser/renderer_host/async_resource_handler.cc
===================================================================
--- content/browser/renderer_host/async_resource_handler.cc	(revision 144275)
+++ content/browser/renderer_host/async_resource_handler.cc	(working copy)
@@ -120,15 +120,8 @@
 }
 
 void AsyncResourceHandler::OnDataReceivedACK() {
-  // If the pending data count was higher than the max, resume the request.
-  if (--pending_data_count_ == kMaxPendingDataMessages) {
-    // Decrement the pending data count one more time because we also
-    // incremented it before deferring the request.
-    --pending_data_count_;
-
-    // Resume the request.
+  if (pending_data_count_-- == kMaxPendingDataMessages)
     ResumeIfDeferred();
-  }
 }
 
 bool AsyncResourceHandler::OnUploadProgress(int request_id,
@@ -234,23 +227,20 @@
   return true;
 }
 
-bool AsyncResourceHandler::OnReadCompleted(int request_id, int* bytes_read,
+bool AsyncResourceHandler::OnReadCompleted(int request_id, int bytes_read,
                                            bool* defer) {
-  if (!*bytes_read)
+  if (!bytes_read)
     return true;
   DCHECK(read_buffer_.get());
 
-  if (read_buffer_->buffer_size() == *bytes_read) {
+  if (read_buffer_->buffer_size() == bytes_read) {
     // The network layer has saturated our buffer. Next time, we should give it
     // a bigger buffer for it to fill, to minimize the number of round trips we
     // do with the renderer process.
     next_buffer_size_ = std::min(next_buffer_size_ * 2, kMaxReadBufSize);
   }
 
-  if (!WillSendData(defer)) {
-    // We should not send this data now, we have too many pending requests.
-    return true;
-  }
+  WillSendData(defer);
 
   base::SharedMemoryHandle handle;
   if (!read_buffer_->shared_memory()->GiveToProcess(
@@ -271,7 +261,7 @@
   int encoded_data_length =
       DevToolsNetLogObserver::GetAndResetEncodedDataLength(request_);
   filter_->Send(new ResourceMsg_DataReceived(
-      routing_id_, request_id, handle, *bytes_read, encoded_data_length));
+      routing_id_, request_id, handle, bytes_read, encoded_data_length));
 
   return true;
 }
@@ -322,16 +312,13 @@
   }
 }
 
-bool AsyncResourceHandler::WillSendData(bool* defer) {
-  if (++pending_data_count_ > kMaxPendingDataMessages) {
+void AsyncResourceHandler::WillSendData(bool* defer) {
+  if (++pending_data_count_ >= kMaxPendingDataMessages) {

[darin (slow to review), 2012/06/28 21:49:53]

NOTE:  This change results from not repeating the OnReadCompleted call, which
led to WillSendData being called, upon Resume.  Now, instead of withholding the
data chunk that put us over the edge, we instead withhold future data chunks.

     // 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 = did_defer_ = true;
-    return false;
   }
-
-  return true;
 }
 
 void AsyncResourceHandler::ResumeIfDeferred() {