ResourceHandler::OnWillStart: Remove min_size argument.

content/browser/loader/intercepting_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/intercepting_resource_handler.h"
 
 #include "base/auto_reset.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 75 matching lines @@
 
   // Otherwise, switch handlers. First, inform the original ResourceHandler
   // that this will be handled entirely by the new ResourceHandler.
   HoldController(std::move(controller));
   state_ = State::SWAPPING_HANDLERS;
 
   DoLoop();
 }
 
 bool InterceptingResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
-                                             int* buf_size,
-                                             int min_size) {
+                                             int* buf_size) {
   if (state_ == State::PASS_THROUGH)
-    return next_handler_->OnWillRead(buf, buf_size, min_size);
+    return next_handler_->OnWillRead(buf, buf_size);
 
   DCHECK_EQ(State::STARTING, state_);
-  DCHECK_EQ(-1, min_size);
 
-  if (!next_handler_->OnWillRead(buf, buf_size, min_size))
+  if (!next_handler_->OnWillRead(buf, buf_size))
     return false;
 
   first_read_buffer_ = *buf;
   first_read_buffer_size_ = *buf_size;
   first_read_buffer_double_ = new net::IOBuffer(static_cast<size_t>(*buf_size));
   *buf = first_read_buffer_double_;
   return true;
 }
 
 void InterceptingResourceHandler::OnReadCompleted(
@@ skipping 164 matching lines @@
   int size = 0;
   if (first_read_buffer_) {
     // |first_read_buffer_| is a buffer gotten from |next_handler_| via
     // OnWillRead. Use the buffer.
     buffer = first_read_buffer_;
     size = first_read_buffer_size_;
 
     first_read_buffer_ = nullptr;
     first_read_buffer_size_ = 0;
   } else {
-    if (!next_handler_->OnWillRead(&buffer, &size, -1)) {
+    if (!next_handler_->OnWillRead(&buffer, &size)) {
       Cancel();
       return;
     }
   }
 
   size = std::min(size, static_cast<int>(payload_for_old_handler_.size() -
                                          payload_bytes_written_));
   memcpy(buffer->data(),
          payload_for_old_handler_.data() + payload_bytes_written_, size);
   payload_bytes_written_ += size;
@@ skipping 11 matching lines @@
 
   if (first_read_buffer_bytes_written_ == first_read_buffer_bytes_read_) {
     state_ = State::PASS_THROUGH;
     first_read_buffer_double_ = nullptr;
     ResumeInternal();
     return;
   }
 
   scoped_refptr<net::IOBuffer> buf;
   int size = 0;
-  if (!next_handler_->OnWillRead(&buf, &size, -1)) {
+  if (!next_handler_->OnWillRead(&buf, &size)) {
     Cancel();
     return;
   }
   size = std::min(size, static_cast<int>(first_read_buffer_bytes_read_ -
                                          first_read_buffer_bytes_written_));
   memcpy(buf->data(),
          first_read_buffer_double_->data() + first_read_buffer_bytes_written_,
          size);
   first_read_buffer_bytes_written_ += size;
   next_handler_->OnReadCompleted(size, base::MakeUnique<Controller>(this));
 }
 
 }  // namespace content