Add buffering to MimeSniffingResourceHandler.

content/browser/loader/mojo_async_resource_handler.cc

 // Copyright 2016 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/mojo_async_resource_handler.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
@@ skipping 10 matching lines @@
 #include "content/browser/loader/resource_controller.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/loader/resource_scheduler.h"
 #include "content/browser/loader/upload_progress_tracker.h"
 #include "content/common/resource_request_completion_status.h"
 #include "content/public/browser/global_request_id.h"
 #include "content/public/common/resource_response.h"
 #include "mojo/public/c/system/data_pipe.h"
 #include "mojo/public/cpp/bindings/message.h"
-#include "net/base/mime_sniffer.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/redirect_info.h"
 
 namespace content {
 namespace {
 
 int g_allocation_size = MojoAsyncResourceHandler::kDefaultAllocationSize;
 
-// MimeTypeResourceHandler *implicitly* requires that the buffer size
-// returned from OnWillRead should be larger than certain size.
-// TODO(yhirano): Fix MimeTypeResourceHandler.
-constexpr size_t kMinAllocationSize = 2 * net::kMaxBytesToSniff;
-
 constexpr size_t kMaxChunkSize = 32 * 1024;
 
 void GetNumericArg(const std::string& name, int* result) {
   const std::string& value =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(name);
   if (!value.empty())
     base::StringToInt(value, result);
 }
 
 void InitializeResourceBufferConstants() {
@@ skipping 176 matching lines @@
   // final 0-byte read, so this DCHECK will also catch OnWillRead being called
   // after OnReadCompelted(0)).
   DCHECK(!buffer_);
   DCHECK_EQ(0u, buffer_offset_);
 
   if (!CheckForSufficientResource()) {
     controller->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
     return;
   }
 
-  bool first_call = false;
   if (!shared_writer_) {
-    first_call = true;
     MojoCreateDataPipeOptions options;
     options.struct_size = sizeof(MojoCreateDataPipeOptions);
     options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
     options.element_num_bytes = 1;
     options.capacity_num_bytes = g_allocation_size;
     mojo::DataPipe data_pipe(options);
 
     DCHECK(data_pipe.producer_handle.is_valid());
     DCHECK(data_pipe.consumer_handle.is_valid());
 
@@ skipping 14 matching lines @@
   if (defer) {
     DCHECK(!buffer_);
     parent_buffer_ = buf;
     parent_buffer_size_ = buf_size;
     HoldController(std::move(controller));
     request()->LogBlockedBy("MojoAsyncResourceHandler");
     did_defer_on_will_read_ = true;
     return;
   }
 
-  // The first call to OnWillRead must return a buffer of at least
-  // kMinAllocationSize. If the Mojo buffer is too small, need to allocate an
-  // intermediary buffer.
-  if (first_call && static_cast<size_t>(buffer_->size()) < kMinAllocationSize) {
-    // The allocated buffer is too small, so need to create an intermediary one.
-    if (EndWrite(0) != MOJO_RESULT_OK) {
-      controller->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
-      return;
-    }
-    DCHECK(!is_using_io_buffer_not_from_writer_);
-    is_using_io_buffer_not_from_writer_ = true;
-    buffer_ = new net::IOBufferWithSize(kMinAllocationSize);
-  }
-
   *buf = buffer_;
   *buf_size = buffer_->size();
   controller->Resume();
 }
 
 void MojoAsyncResourceHandler::OnReadCompleted(
     int bytes_read,
     std::unique_ptr<ResourceController> controller) {
   DCHECK(!has_controller());
   DCHECK_GE(bytes_read, 0);
@@ skipping 13 matching lines @@
       url_loader_client_->OnTransferSizeUpdated(transfer_size_diff);
   }
 
   if (response_body_consumer_handle_.is_valid()) {
     // Send the data pipe on the first OnReadCompleted call.
     url_loader_client_->OnStartLoadingResponseBody(
         std::move(response_body_consumer_handle_));
     response_body_consumer_handle_.reset();
   }
 
-  if (is_using_io_buffer_not_from_writer_) {
-    // Couldn't allocate a large enough buffer on the data pipe in OnWillRead.
-    DCHECK_EQ(0u, buffer_bytes_read_);
-    buffer_bytes_read_ = bytes_read;
-    bool defer = false;
-    if (!CopyReadDataToDataPipe(&defer)) {
-      controller->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
-      return;
-    }
-    if (defer) {
-      request()->LogBlockedBy("MojoAsyncResourceHandler");
-      did_defer_on_writing_ = true;
-      HoldController(std::move(controller));
-      return;
-    }
-    controller->Resume();
-    return;
-  }
-
   if (EndWrite(bytes_read) != MOJO_RESULT_OK) {
     controller->Cancel();
     return;
   }
 
   buffer_ = nullptr;
   controller->Resume();
 }
 
 void MojoAsyncResourceHandler::OnDataDownloaded(int bytes_downloaded) {
   url_loader_client_->OnDataDownloaded(bytes_downloaded,
                                        CalculateRecentlyReceivedBytes());
 }
 
 void MojoAsyncResourceHandler::FollowRedirect() {
   if (!request()->status().is_success()) {
     DVLOG(1) << "FollowRedirect for invalid request";
     return;
   }
   if (!did_defer_on_redirect_) {
     DVLOG(1) << "Malformed FollowRedirect request";
     ReportBadMessage("Malformed FollowRedirect request");
     return;
   }
 
   DCHECK(!did_defer_on_will_read_);
-  DCHECK(!did_defer_on_writing_);
   did_defer_on_redirect_ = false;
   request()->LogUnblocked();
   Resume();
 }
 
 void MojoAsyncResourceHandler::SetPriority(net::RequestPriority priority,
                                            int32_t intra_priority_value) {
   ResourceDispatcherHostImpl::Get()->scheduler()->ReprioritizeRequest(
       request(), priority, intra_priority_value);
 }
@@ skipping 69 matching lines @@
   request_complete_data.exists_in_cache = request()->response_info().was_cached;
   request_complete_data.completion_time = base::TimeTicks::Now();
   request_complete_data.encoded_data_length =
       request()->GetTotalReceivedBytes();
   request_complete_data.encoded_body_length = request()->GetRawBodyBytes();
 
   url_loader_client_->OnComplete(request_complete_data);
   controller->Resume();
 }
 
-bool MojoAsyncResourceHandler::CopyReadDataToDataPipe(bool* defer) {
-  while (buffer_bytes_read_ > 0) {
-    scoped_refptr<net::IOBufferWithSize> dest;
-    if (!AllocateWriterIOBuffer(&dest, defer))
-      return false;
-    if (*defer)
-      return true;
-
-    size_t copied_size =
-        std::min(buffer_bytes_read_, static_cast<size_t>(dest->size()));
-    memcpy(dest->data(), buffer_->data() + buffer_offset_, copied_size);
-    buffer_offset_ += copied_size;
-    buffer_bytes_read_ -= copied_size;
-    if (EndWrite(copied_size) != MOJO_RESULT_OK)
-      return false;
-  }
-
-  // All bytes are copied.
-  buffer_ = nullptr;
-  buffer_offset_ = 0;
-  is_using_io_buffer_not_from_writer_ = false;
-  return true;
-}
-
 bool MojoAsyncResourceHandler::AllocateWriterIOBuffer(
     scoped_refptr<net::IOBufferWithSize>* buf,
     bool* defer) {
   void* data = nullptr;
   uint32_t available = 0;
   MojoResult result = BeginWrite(&data, &available);
   if (result == MOJO_RESULT_SHOULD_WAIT) {
     *defer = true;
     return true;
   }
   if (result != MOJO_RESULT_OK)
     return false;
   DCHECK_GT(available, 0u);
   *buf = new WriterIOBuffer(shared_writer_, data, available);
   return true;
 }
 
 bool MojoAsyncResourceHandler::CheckForSufficientResource() {
   if (has_checked_for_sufficient_resources_)
     return true;
   has_checked_for_sufficient_resources_ = true;
 
   if (rdh_->HasSufficientResourcesForRequest(request()))
     return true;
 
   return false;
 }
 
 void MojoAsyncResourceHandler::OnWritable(MojoResult result) {
-  if (did_defer_on_will_read_) {
-    DCHECK(has_controller());
-    DCHECK(!did_defer_on_writing_);
-    DCHECK(!did_defer_on_redirect_);
+  if (!did_defer_on_will_read_)
+    return;
 
-    did_defer_on_will_read_ = false;
-
-    scoped_refptr<net::IOBuffer>* parent_buffer = parent_buffer_;
-    parent_buffer_ = nullptr;
-    int* parent_buffer_size = parent_buffer_size_;
-    parent_buffer_size_ = nullptr;
-
-    request()->LogUnblocked();
-    OnWillRead(parent_buffer, parent_buffer_size, ReleaseController());
-    return;
-  }
-
-  if (!did_defer_on_writing_)
-    return;
   DCHECK(has_controller());
   DCHECK(!did_defer_on_redirect_);
-  did_defer_on_writing_ = false;
 
-  DCHECK(is_using_io_buffer_not_from_writer_);
-  // |buffer_| is set to a net::IOBufferWithSize. Write the buffer contents
-  // to the data pipe.
-  DCHECK_GT(buffer_bytes_read_, 0u);
-  if (!CopyReadDataToDataPipe(&did_defer_on_writing_)) {
-    CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
-    return;
-  }
+  did_defer_on_will_read_ = false;
 
-  if (did_defer_on_writing_) {
-    // Continue waiting.
-    return;
-  }
+  scoped_refptr<net::IOBuffer>* parent_buffer = parent_buffer_;
+  parent_buffer_ = nullptr;
+  int* parent_buffer_size = parent_buffer_size_;
+  parent_buffer_size_ = nullptr;
+
   request()->LogUnblocked();
-  Resume();
+  OnWillRead(parent_buffer, parent_buffer_size, ReleaseController());
 }
 
 void MojoAsyncResourceHandler::Cancel() {
   const ResourceRequestInfoImpl* info = GetRequestInfo();
   ResourceDispatcherHostImpl::Get()->CancelRequestFromRenderer(
       GlobalRequestID(info->GetChildID(), info->GetRequestID()));
 }
 
 int64_t MojoAsyncResourceHandler::CalculateRecentlyReceivedBytes() {
   int64_t total_received_bytes = request()->GetTotalReceivedBytes();
@@ skipping 33 matching lines @@
       base::Bind(&MojoAsyncResourceHandler::OnUploadProgressACK,
                  weak_factory_.GetWeakPtr()));
 }
 
 void MojoAsyncResourceHandler::OnUploadProgressACK() {
   if (upload_progress_tracker_)
     upload_progress_tracker_->OnAckReceived();
 }
 
 }  // namespace content