Add buffering to MimeSniffingResourceHandler.

content/browser/loader/mime_sniffing_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/loader/mime_sniffing_resource_handler.h"
 
+#include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 101 matching lines @@
     : LayeredResourceHandler(request, std::move(next_handler)),
       state_(STATE_STARTING),
       host_(host),
 #if BUILDFLAG(ENABLE_PLUGINS)
       plugin_service_(plugin_service),
 #endif
       must_download_(false),
       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),
       advance_state_(false),
       weak_ptr_factory_(this) {
 }
 
 MimeSniffingResourceHandler::~MimeSniffingResourceHandler() {}
 
 void MimeSniffingResourceHandler::OnWillStart(
@@ skipping 76 matching lines @@
   HoldController(std::move(controller));
   AdvanceState();
 }
 
 void MimeSniffingResourceHandler::OnWillRead(
     scoped_refptr<net::IOBuffer>* buf,
     int* buf_size,
     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));
     return;
   }
 
   DCHECK_EQ(State::STATE_BUFFERING, state_);
 
   if (read_buffer_.get()) {
     CHECK_LT(bytes_read_, read_buffer_size_);
     *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(
     int bytes_read,
     std::unique_ptr<ResourceController> controller) {
   DCHECK(!has_controller());
 
   if (state_ == STATE_STREAMING) {
     next_handler_->OnReadCompleted(bytes_read, std::move(controller));
     return;
@@ skipping 63 matching lines @@
 
   base::AutoReset<bool> auto_in_state_loop(&in_state_loop_, true);
   advance_state_ = true;
   while (advance_state_) {
     advance_state_ = false;
 
     switch (state_) {
       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:
       case STATE_STREAMING:
         Resume();
         return;
       default:
         NOTREACHED();
         break;
     }
   }
 
   DCHECK(in_state_loop_);
   in_state_loop_ = false;
 }
 
 void MimeSniffingResourceHandler::MaybeIntercept() {
   DCHECK_EQ(STATE_BUFFERING, state_);
   // If a request that can be intercepted failed the check for interception
   // step, it should be canceled.
   if (!MaybeStartInterception())
     return;
 
   state_ = STATE_INTERCEPTION_CHECK_DONE;
   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;
   next_handler_->OnResponseStarted(response_.get(),
                                    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;
 
-  if (!read_buffer_.get()) {
+    state_ = STATE_STREAMING;
+
     ResumeInternal();
     return;
   }
 
-  int bytes_read = bytes_read_;
+  state_ = STATE_REPLAYING_WAIT_FOR_WILL_READ;
 
-  read_buffer_ = nullptr;
-  read_buffer_size_ = 0;
-  bytes_read_ = 0;
+  out_buffer_ = nullptr;
+  out_buffer_size_ = 0;
+  next_handler_->OnWillRead(&out_buffer_, &out_buffer_size_,
+                            base::MakeUnique<Controller>(this));
+}
 
-  next_handler_->OnReadCompleted(bytes_read,
+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_to_copy,
                                  base::MakeUnique<Controller>(this));
 }
 
 bool MimeSniffingResourceHandler::ShouldSniffContent() {
   if (request_context_type_ == REQUEST_CONTEXT_TYPE_FETCH) {
     // MIME sniffing should be disabled for a request initiated by fetch().
     return false;
   }
 
   const std::string& mime_type = response_->head.mime_type;
@@ skipping 170 matching lines @@
 
 void MimeSniffingResourceHandler::OnPluginsLoaded(
     const std::vector<WebPluginInfo>& plugins) {
   // No longer blocking on the plugins being loaded.
   request()->LogUnblocked();
   if (state_ == STATE_BUFFERING)
     AdvanceState();
 }
 
 }  // namespace content