Only double the buffer when AsyncResourceHandler's caller fill the buffer.

chrome/browser/renderer_host/async_resource_handler.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/renderer_host/async_resource_handler.h"
 
 #include "base/logging.h"
 #include "base/process.h"
 #include "base/shared_memory.h"
 #include "chrome/common/render_messages.h"
 #include "net/base/io_buffer.h"
 
 namespace {
 
 // When reading, we don't know if we are going to get EOF (0 bytes read), so
 // we typically have a buffer that we allocated but did not use.  We keep
 // this buffer around for the next read as a small optimization.
 SharedIOBuffer* g_spare_read_buffer = NULL;
 
 // The initial size of the shared memory buffer. (32 kilobytes).
-const int kReadBufSize = 32768;
+const int kInitialReadBufSize = 32768;
 
 // The maximum size of the shared memory buffer. (512 kilobytes).
-const int kMaxBufSize = 524288;
+const int kMaxReadBufSize = 524288;
 
 }  // namespace
 
 // Our version of IOBuffer that uses shared memory.
 class SharedIOBuffer : public net::IOBuffer {
  public:
   SharedIOBuffer(int buffer_size)
       : net::IOBuffer(),
         ok_(false),
         buffer_size_(buffer_size) {
@@ skipping 24 matching lines @@
     int process_id,
     int routing_id,
     base::ProcessHandle process_handle,
     const GURL& url,
     ResourceDispatcherHost* resource_dispatcher_host)
     : receiver_(receiver),
       process_id_(process_id),
       routing_id_(routing_id),
       process_handle_(process_handle),
       rdh_(resource_dispatcher_host),
-      next_buffer_size_(kReadBufSize) {
+      next_buffer_size_(kInitialReadBufSize) {
 }
 
 bool AsyncResourceHandler::OnUploadProgress(int request_id,
                                             uint64 position,
                                             uint64 size) {
   return receiver_->Send(new ViewMsg_Resource_UploadProgress(routing_id_,
                                                              request_id,
                                                              position, size));
 }
 
@@ skipping 17 matching lines @@
                                       int* buf_size, int min_size) {
   DCHECK(min_size == -1);
 
   if (g_spare_read_buffer) {
     DCHECK(!read_buffer_);
     read_buffer_.swap(&g_spare_read_buffer);
     // TODO(willchan): Remove after debugging bug 16371.
     CHECK(read_buffer_->data());
 
     *buf = read_buffer_.get();
-    *buf_size = read_buffer_.get()->buffer_size();
+    *buf_size = read_buffer_->buffer_size();
   } else {
     read_buffer_ = new SharedIOBuffer(next_buffer_size_);
     if (!read_buffer_->ok()) {
       DLOG(ERROR) << "Couldn't allocate shared io buffer";
       return false;
     }
     // TODO(willchan): Remove after debugging bug 16371.
     CHECK(read_buffer_->data());
     *buf = read_buffer_.get();
     *buf_size = next_buffer_size_;
   }
 
-  next_buffer_size_ = std::min(next_buffer_size_ * 2, kMaxBufSize);
-
   return true;
 }
 
 bool AsyncResourceHandler::OnReadCompleted(int request_id, int* bytes_read) {
   if (!*bytes_read)
     return true;
   DCHECK(read_buffer_.get());
 
+  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 (!rdh_->WillSendData(process_id_, request_id)) {
     // We should not send this data now, we have too many pending requests.
     return true;
   }
 
   base::SharedMemoryHandle handle;
   if (!read_buffer_->shared_memory()->GiveToProcess(process_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
@@ skipping 34 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();
   }
 }