Add buffering to MimeSniffingResourceHandler.

content/browser/loader/mime_sniffing_resource_handler.cc

Index: content/browser/loader/mime_sniffing_resource_handler.cc
diff --git a/content/browser/loader/mime_sniffing_resource_handler.cc b/content/browser/loader/mime_sniffing_resource_handler.cc
index 11adad4704772748963bc5129752c2e95af17a20..a6147cb4934da2aaec9fefaff7cc166e7130fbc9 100644
--- a/content/browser/loader/mime_sniffing_resource_handler.cc
+++ b/content/browser/loader/mime_sniffing_resource_handler.cc
@@ -4,6 +4,7 @@
 
 #include "content/browser/loader/mime_sniffing_resource_handler.h"
 
+#include <algorithm>
 #include <utility>
 #include <vector>
 
@@ -125,8 +126,8 @@ MimeSniffingResourceHandler::MimeSniffingResourceHandler(
       must_download_is_set_(false),
       read_buffer_size_(0),
       bytes_read_(0),
-      parent_read_buffer_(nullptr),
-      parent_read_buffer_size_(nullptr),
+      bytes_replayed_(0),
+      out_buffer_size_(0),
       intercepting_handler_(intercepting_handler),
       request_context_type_(request_context_type),
       in_state_loop_(false),
@@ -223,8 +224,6 @@ void MimeSniffingResourceHandler::OnWillRead(
     std::unique_ptr<ResourceController> controller) {
   DCHECK(buf);
   DCHECK(buf_size);
-  DCHECK(!parent_read_buffer_);
-  DCHECK(!parent_read_buffer_size_);
 
   if (state_ == STATE_STREAMING) {
     next_handler_->OnWillRead(buf, buf_size, std::move(controller));
@@ -238,20 +237,13 @@ void MimeSniffingResourceHandler::OnWillRead(
     *buf = new DependentIOBuffer(read_buffer_.get(), bytes_read_);
     *buf_size = read_buffer_size_ - bytes_read_;
     controller->Resume();
-    return;
+  } else {
+    *buf_size = read_buffer_size_ = net::kMaxBytesToSniff * 2;
+    *buf = read_buffer_ = new net::IOBuffer(read_buffer_size_);
+    controller->Resume();
   }
 
-  DCHECK(!read_buffer_size_);
-
-  parent_read_buffer_ = buf;
-  parent_read_buffer_size_ = buf_size;
-
-  HoldController(std::move(controller));
-
-  // Have to go through AdvanceState here so that if OnWillRead completes
-  // synchronously, won't post a task.
-  state_ = State::STATE_CALLING_ON_WILL_READ;
-  AdvanceState();
+  return;
 }
 
 void MimeSniffingResourceHandler::OnReadCompleted(
@@ -335,16 +327,13 @@ void MimeSniffingResourceHandler::AdvanceState() {
       case STATE_BUFFERING:
         MaybeIntercept();
         break;
-      case STATE_CALLING_ON_WILL_READ:
-        CallOnWillRead();
-        break;
-      case STATE_WAITING_FOR_BUFFER:
-        BufferReceived();
-        break;
       case STATE_INTERCEPTION_CHECK_DONE:
         ReplayResponseReceived();
         break;
       case STATE_REPLAYING_RESPONSE_RECEIVED:
+        ReplayGetBuffer();
+        break;
+      case STATE_REPLAYING_WAIT_FOR_WILL_READ:
         ReplayReadCompleted();
         break;
       case STATE_STARTING:
@@ -372,32 +361,6 @@ void MimeSniffingResourceHandler::MaybeIntercept() {
   ResumeInternal();
 }
 
-void MimeSniffingResourceHandler::CallOnWillRead() {
-  DCHECK_EQ(STATE_CALLING_ON_WILL_READ, state_);
-
-  state_ = STATE_WAITING_FOR_BUFFER;
-  next_handler_->OnWillRead(&read_buffer_, &read_buffer_size_,
-                            base::MakeUnique<Controller>(this));
-}
-
-void MimeSniffingResourceHandler::BufferReceived() {
-  DCHECK_EQ(STATE_WAITING_FOR_BUFFER, state_);
-
-  DCHECK(read_buffer_);
-  DCHECK(parent_read_buffer_);
-  DCHECK(parent_read_buffer_size_);
-  DCHECK_GE(read_buffer_size_, net::kMaxBytesToSniff * 2);
-
-  *parent_read_buffer_ = read_buffer_;
-  *parent_read_buffer_size_ = read_buffer_size_;
-
-  parent_read_buffer_ = nullptr;
-  parent_read_buffer_size_ = nullptr;
-
-  state_ = State::STATE_BUFFERING;
-  Resume();
-}
-
 void MimeSniffingResourceHandler::ReplayResponseReceived() {
   DCHECK_EQ(STATE_INTERCEPTION_CHECK_DONE, state_);
   state_ = STATE_REPLAYING_RESPONSE_RECEIVED;
@@ -405,23 +368,40 @@ void MimeSniffingResourceHandler::ReplayResponseReceived() {
                                    base::MakeUnique<Controller>(this));
 }
 
-void MimeSniffingResourceHandler::ReplayReadCompleted() {
+void MimeSniffingResourceHandler::ReplayGetBuffer() {
   DCHECK_EQ(STATE_REPLAYING_RESPONSE_RECEIVED, state_);
 
-  state_ = STATE_STREAMING;
+  if (bytes_read_ == bytes_replayed_) {
+    read_buffer_ = nullptr;
+    read_buffer_size_ = 0;
+    bytes_read_ = bytes_replayed_ = 0;
+
+    state_ = STATE_STREAMING;
 
-  if (!read_buffer_.get()) {
     ResumeInternal();
     return;
   }
 
-  int bytes_read = bytes_read_;
+  state_ = STATE_REPLAYING_WAIT_FOR_WILL_READ;
+
+  out_buffer_ = nullptr;
+  out_buffer_size_ = 0;
+  next_handler_->OnWillRead(&out_buffer_, &out_buffer_size_,
+                            base::MakeUnique<Controller>(this));
+}
 
-  read_buffer_ = nullptr;
-  read_buffer_size_ = 0;
-  bytes_read_ = 0;
+void MimeSniffingResourceHandler::ReplayReadCompleted() {
+  DCHECK_EQ(STATE_REPLAYING_WAIT_FOR_WILL_READ, state_);
+  DCHECK(out_buffer_.get());
+  DCHECK_LT(0, out_buffer_size_);
+
+  state_ = STATE_REPLAYING_RESPONSE_RECEIVED;
+  int bytes_to_copy = std::min(bytes_read_ - bytes_replayed_, out_buffer_size_);
+  memcpy(out_buffer_->data(), read_buffer_->data() + bytes_replayed_,
+         bytes_to_copy);
+  bytes_replayed_ += bytes_to_copy;
 
-  next_handler_->OnReadCompleted(bytes_read,
+  next_handler_->OnReadCompleted(bytes_to_copy,
                                  base::MakeUnique<Controller>(this));
 }