Rewrite guts of ResourceLoader and BufferedResourceHandler to suck less.

content/browser/renderer_host/async_resource_handler.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.
 
 #include "content/browser/renderer_host/async_resource_handler.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/debug/alias.h"
@@ skipping 102 matching lines @@
     return;
   }
 
   if (has_new_first_party_for_cookies)
     request_->set_first_party_for_cookies(new_first_party_for_cookies);
 
   ResumeIfDeferred();
 }
 
 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,
                                             uint64 position,
                                             uint64 size) {
   return filter_->Send(new ResourceMsg_UploadProgress(routing_id_, request_id,
                                                       position, size));
 }
 
 bool AsyncResourceHandler::OnRequestRedirected(int request_id,
@@ skipping 85 matching lines @@
       return false;
     }
     DCHECK(read_buffer_->data());
     *buf = read_buffer_.get();
     *buf_size = next_buffer_size_;
   }
 
   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(
           filter_->peer_handle(), &handle)) {
     // We wrongfully incremented the pending data count. Fake an ACK message
     // to fix this. We can't move this call above the WillSendData because
     // it's killing our read_buffer_, and we don't want that when we pause
     // the request.
     OnDataReceivedACK();
 
     // We just unmapped the memory.
     read_buffer_ = NULL;
     return false;
   }
   // We just unmapped the memory.
   read_buffer_ = NULL;
 
   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;
 }
 
 void AsyncResourceHandler::OnDataDownloaded(
     int request_id, int bytes_downloaded) {
   filter_->Send(new ResourceMsg_DataDownloaded(
       routing_id_, request_id, bytes_downloaded));
 }
 
@@ skipping 30 matching lines @@
 // static
 void AsyncResourceHandler::GlobalCleanup() {
   if (g_spare_read_buffer) {
     // Avoid the CHECK in SharedIOBuffer::~SharedIOBuffer().
     SharedIOBuffer* tmp = g_spare_read_buffer;
     g_spare_read_buffer = NULL;
     tmp->Release();
   }
 }
 
-bool AsyncResourceHandler::WillSendData(bool* defer) {
-  if (++pending_data_count_ > kMaxPendingDataMessages) {
+void AsyncResourceHandler::WillSendData(bool* defer) {
+  if (++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 = did_defer_ = true;
-    return false;
   }
-
-  return true;
 }
 
 void AsyncResourceHandler::ResumeIfDeferred() {
   if (did_defer_) {
     did_defer_ = false;
     controller()->Resume();
   }
 }
 
 }  // namespace content