Change URLRequest to use a ref-counted buffer for actual IO....

chrome/browser/renderer_host/buffered_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/buffered_resource_handler.h"
 
 #include "base/histogram.h"
 #include "net/base/mime_sniffer.h"
 #include "chrome/browser/renderer_host/download_throttling_resource_handler.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
+#include "net/base/mime_sniffer.h"
+#include "net/base/io_buffer.h"
 
 namespace {
 
+const int kMaxBytesToSniff = 512;
+
 void RecordSnifferMetrics(bool sniffing_blocked,
                           bool we_would_like_to_sniff,
                           const std::string& mime_type) {
   static BooleanHistogram nosniff_usage(L"nosniff.usage");
   nosniff_usage.SetFlags(kUmaTargetedHistogramFlag);
   nosniff_usage.AddBoolean(sniffing_blocked);
 
   if (sniffing_blocked) {
     static BooleanHistogram nosniff_otherwise(L"nosniff.otherwise");
     nosniff_otherwise.SetFlags(kUmaTargetedHistogramFlag);
@@ skipping 40 matching lines @@
 }
 
 
 bool BufferedResourceHandler::OnResponseCompleted(
     int request_id, const URLRequestStatus& status) {
   return real_handler_->OnResponseCompleted(request_id, status);
 }
 
 // We'll let the original event handler provide a buffer, and reuse it for
 // subsequent reads until we're done buffering.
-bool BufferedResourceHandler::OnWillRead(int request_id,
-                                         char** buf, int* buf_size,
-                                         int min_size) {
+bool BufferedResourceHandler::OnWillRead(int request_id, net::IOBuffer** buf,
+                                         int* buf_size, int min_size) {
   if (buffering_) {
-    *buf = read_buffer_ + bytes_read_;
-    *buf_size = read_buffer_size_ - bytes_read_;
-    DCHECK(*buf_size > 0);
+    DCHECK(!my_buffer_.get());
+    my_buffer_ = new net::IOBuffer(kMaxBytesToSniff);
+    *buf = my_buffer_.get();
+    *buf_size = kMaxBytesToSniff;
     return true;
   }
 
   if (finished_)
     return false;
 
   bool ret = real_handler_->OnWillRead(request_id, buf, buf_size, min_size);
   read_buffer_ = *buf;
   read_buffer_size_ = *buf_size;
+  DCHECK(read_buffer_size_ >= kMaxBytesToSniff * 2); 
   bytes_read_ = 0;
   return ret;
 }
 
 bool BufferedResourceHandler::OnReadCompleted(int request_id, int* bytes_read) {
   if (sniff_content_ || should_buffer_) {
     if (KeepBuffering(*bytes_read))
       return true;
 
     LOG(INFO) << "Finished buffering " << request_->url().spec();
     sniff_content_ = should_buffer_ = false;
     *bytes_read = bytes_read_;
 
     // Done buffering, send the pending ResponseStarted event.
     if (!CompleteResponseStarted(request_id, true))
       return false;
   }
 
+  // Release the reference that we acquired at OnWillRead.
+  read_buffer_ = NULL;
   return real_handler_->OnReadCompleted(request_id, bytes_read);
 }
 
 bool BufferedResourceHandler::DelayResponse() {
   std::string mime_type;
   request_->GetMimeType(&mime_type);
 
   std::string content_type_options;
   request_->GetResponseHeaderByName("x-content-type-options",
                                     &content_type_options);
@@ skipping 43 matching lines @@
     return false;
 
   // Today, the only reason to buffer the request is to fix the doctype decoding
   // performed by webkit: if there is not enough data it will go to quirks mode.
   // We only expect the doctype check to apply to html documents.
   return mime_type == "text/html";
 }
 
 bool BufferedResourceHandler::KeepBuffering(int bytes_read) {
   DCHECK(read_buffer_);
+  if (my_buffer_) {
+    // We are using our own buffer to read, update the main buffer.
+    CHECK(bytes_read + bytes_read_ < read_buffer_size_);
+    memcpy(read_buffer_->data() + bytes_read_, my_buffer_->data(), bytes_read);
+    my_buffer_ = NULL;
+  }
   bytes_read_ += bytes_read;
   finished_ = (bytes_read == 0);
 
   if (sniff_content_) {
     std::string type_hint, new_type;
     request_->GetMimeType(&type_hint);
 
-    if (!net::SniffMimeType(read_buffer_, bytes_read_, request_->url(),
-                            type_hint, &new_type)) {
+    if (!net::SniffMimeType(read_buffer_->data(), bytes_read_,
+                            request_->url(), type_hint, &new_type)) {
       // SniffMimeType() returns false if there is not enough data to determine
       // the mime type. However, even if it returns false, it returns a new type
       // that is probably better than the current one.
-      DCHECK(bytes_read_ < 512 /*kMaxBytesToSniff*/);
+      DCHECK(bytes_read_ < kMaxBytesToSniff);
       if (!finished_) {
         buffering_ = true;
         return true;
       }
     }
     sniff_content_ = false;
     response_->response_head.mime_type.assign(new_type);
 
     // We just sniffed the mime type, maybe there is a doctype to process.
     if (ShouldBuffer(request_->url(), new_type))
@@ skipping 42 matching lines @@
         new DownloadThrottlingResourceHandler(host_,
                                            request_,
                                            request_->url().spec(),
                                            info->render_process_host_id,
                                            info->render_view_id,
                                            request_id,
                                            in_complete);
     if (bytes_read_) {
       // a Read has already occurred and we need to copy the data into the
       // EventHandler.
-      char *buf = NULL;
+      net::IOBuffer* buf = NULL;
       int buf_len = 0;
       download_handler->OnWillRead(request_id, &buf, &buf_len, bytes_read_);
       CHECK((buf_len >= bytes_read_) && (bytes_read_ >= 0));
-      memcpy(buf, read_buffer_, bytes_read_);
+      memcpy(buf->data(), read_buffer_->data(), bytes_read_);
     }
     // Update the renderer with the response headers which will cause it to
     // cancel the request.
     // TODO(paulg): Send the renderer a response that indicates that the request
     //              will be handled by an external source (the browser).
     real_handler_->OnResponseStarted(info->request_id, response_);
     real_handler_ = download_handler;
   }
   return real_handler_->OnResponseStarted(request_id, response_);
 }
 
 bool BufferedResourceHandler::DidBufferEnough(int bytes_read) {
   const int kRequiredLength = 256;
 
   return bytes_read >= kRequiredLength;
 }