When sending resources across the IPC barrier, use increasing sized buffers.

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.
-static SharedIOBuffer* g_spare_read_buffer = NULL;
+SharedIOBuffer* g_spare_read_buffer = NULL;
+
+// The initial size of the shared memory buffer. (32 kilobytes).
+const int kReadBufSize = 32768;

[agl, 2009/10/23 17:01:12]

static

[Elliot Glaysher, 2009/10/23 17:07:00]

anonymous namespace

[darin (slow to review), 2009/10/23 17:59:40]

kInitialReadBufSize?

+
+// The maximum size of the shared memory buffer. (512 kilobytes).
+const int kMaxBufSize = 524288;

[agl, 2009/10/23 17:01:12]

static

[darin (slow to review), 2009/10/23 17:59:40]

kMaxReadBufSize

+
+}  // namespace
 
 // Our version of IOBuffer that uses shared memory.
 class SharedIOBuffer : public net::IOBuffer {
  public:
-  SharedIOBuffer(int buffer_size) : net::IOBuffer(), ok_(false) {
+  SharedIOBuffer(int buffer_size)
+      : net::IOBuffer(),
+        ok_(false),
+        buffer_size_(buffer_size) {
     if (shared_memory_.Create(std::wstring(), false, false, buffer_size) &&
         shared_memory_.Map(buffer_size)) {
       ok_ = true;
       data_ = reinterpret_cast<char*>(shared_memory_.memory());
     }
   }
   ~SharedIOBuffer() {
     // TODO(willchan): Remove after debugging bug 16371.
     CHECK(g_spare_read_buffer != this);
     data_ = NULL;
   }
 
   base::SharedMemory* shared_memory() { return &shared_memory_; }
   bool ok() { return ok_; }
+  int buffer_size() { return buffer_size_; }
 
  private:
   base::SharedMemory shared_memory_;
   bool ok_;
+  int buffer_size_;
 };
 
 AsyncResourceHandler::AsyncResourceHandler(
     ResourceDispatcherHost::Receiver* receiver,
     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) {
+      rdh_(resource_dispatcher_host),
+      next_buffer_size_(kReadBufSize) {
 }
 
 bool AsyncResourceHandler::OnUploadProgress(int request_id,
                                             uint64 position,
                                             uint64 size) {
   return receiver_->Send(new ViewMsg_Resource_UploadProgress(routing_id_,
                                                              request_id,
                                                              position, size));
 }
 
 bool AsyncResourceHandler::OnRequestRedirected(int request_id,
                                                const GURL& new_url,
                                                ResourceResponse* response,
                                                bool* defer) {
   *defer = true;
   return receiver_->Send(new ViewMsg_Resource_ReceivedRedirect(
       routing_id_, request_id, new_url, response->response_head));
 }
 
 bool AsyncResourceHandler::OnResponseStarted(int request_id,
                                              ResourceResponse* response) {
   receiver_->Send(new ViewMsg_Resource_ReceivedResponse(
       routing_id_, request_id, response->response_head));
   return true;
 }
 
 bool AsyncResourceHandler::OnWillRead(int request_id, net::IOBuffer** buf,
                                       int* buf_size, int min_size) {
   DCHECK(min_size == -1);
-  static const int kReadBufSize = 32768;
+
   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();

[rvargas (doing something else), 2009/10/23 17:52:04]

nit: drop the get()

   } else {
-    read_buffer_ = new SharedIOBuffer(kReadBufSize);
-    if (!read_buffer_->ok())
+    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_;
   }
-  *buf = read_buffer_.get();
-  *buf_size = kReadBufSize;
+
+  next_buffer_size_ = std::min(next_buffer_size_ * 2, kMaxBufSize);

[darin (slow to review), 2009/10/23 17:59:40]

we do allow up to 20 (iirc) unanswered resource IPCs.  perhaps we should only
increase the buffer size if there are unanswered IPCs?

why progressively increase the buffer size?  why not just make the buffers 64k
instead of 32k, or maybe something even larger to begin with?

+
   return true;
 }
 
 bool AsyncResourceHandler::OnReadCompleted(int request_id, int* bytes_read) {
   if (!*bytes_read)
     return true;
   DCHECK(read_buffer_.get());
 
   if (!rdh_->WillSendData(process_id_, request_id)) {
     // We should not send this data now, we have too many pending requests.
@@ skipping 42 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();
   }
 }