Make ResourceHandler::OnWillRead able to complete asynchronously.

content/browser/loader/mock_resource_loader.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/mock_resource_loader.h"
 
 #include <memory>
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
@@ skipping 80 matching lines @@
   if (status_ == Status::CALLING_HANDLER)
     status_ = Status::CALLBACK_PENDING;
   return status_;
 }
 
 MockResourceLoader::Status MockResourceLoader::OnWillRead() {
   EXPECT_FALSE(weak_factory_.HasWeakPtrs());
   EXPECT_EQ(Status::IDLE, status_);
 
   status_ = Status::CALLING_HANDLER;
-  bool result =
-      resource_handler_->OnWillRead(&io_buffer_, &io_buffer_size_);
+  waiting_on_buffer_ = true;
+  resource_handler_->OnWillRead(
+      &io_buffer_, &io_buffer_size_,
+      base::MakeUnique<TestResourceController>(weak_factory_.GetWeakPtr()));
+  if (status_ == Status::CALLING_HANDLER) {
+    // Shouldn't update  |io_buffer_| or |io_buffer_size_| yet if Resume()
+    // hasn't yet been called.
+    EXPECT_FALSE(io_buffer_);
+    EXPECT_EQ(0, io_buffer_size_);
 
-  // The second case isn't really allowed, but a number of classes do it
-  // anyways.
-  EXPECT_TRUE(status_ == Status::CALLING_HANDLER ||
-              (result == false && status_ == Status::CANCELED));
-  if (!result) {
-    // In the case of double-cancels, keep the old error code.
-    if (status_ != Status::CANCELED)
-      error_code_ = net::ERR_ABORTED;
-    EXPECT_EQ(0, io_buffer_size_);
-    EXPECT_FALSE(io_buffer_);
-    status_ = Status::CANCELED;
-  } else {
-    EXPECT_LT(0, io_buffer_size_);
-    EXPECT_TRUE(io_buffer_);
-    status_ = Status::IDLE;
+    status_ = Status::CALLBACK_PENDING;
   }
+
   return status_;
 };
 
 MockResourceLoader::Status MockResourceLoader::OnReadCompleted(
     base::StringPiece bytes) {
   EXPECT_FALSE(weak_factory_.HasWeakPtrs());
   EXPECT_EQ(Status::IDLE, status_);
   EXPECT_LE(bytes.size(), static_cast<size_t>(io_buffer_size_));
 
   status_ = Status::CALLING_HANDLER;
@@ skipping 59 matching lines @@
   EXPECT_TRUE(status_ == Status::IDLE || status_ == Status::CANCELED);
 }
 
 void MockResourceLoader::OutOfBandCancel(int error_code, bool tell_renderer) {
   // Shouldn't be called in-band.
   EXPECT_NE(Status::CALLING_HANDLER, status_);
 
   status_ = Status::CANCELED;
   canceled_out_of_band_ = true;
 
+  // If OnWillRead was deferred, no longer waiting on a buffer.
+  waiting_on_buffer_ = false;
+
   // To mimic real behavior, keep old error, in the case of double-cancel.
   if (error_code_ == net::OK)
     error_code_ = error_code;
 }
 
 void MockResourceLoader::OnCancel(int error_code) {
   // It's currently allowed to be canceled in-band after being cancelled
   // out-of-band, so do nothing, unless the status is no longer CANCELED, which
   // which case, OnResponseCompleted has already been called, and cancels aren't
   // expected then.
   // TODO(mmenke):  Make CancelOutOfBand synchronously destroy the
   // ResourceLoader.
   if (canceled_out_of_band_ && status_ == Status::CANCELED)
     return;
 
+  // Shouldn't update |io_buffer_| or |io_buffer_size_| on cancel.
+  if (waiting_on_buffer_) {
+    EXPECT_FALSE(io_buffer_);
+    EXPECT_EQ(0, io_buffer_size_);
+    waiting_on_buffer_ = false;
+  }
+
   EXPECT_LT(error_code, 0);
   EXPECT_TRUE(status_ == Status::CALLBACK_PENDING ||
               status_ == Status::CALLING_HANDLER);
 
   status_ = Status::CANCELED;
   error_code_ = error_code;
   if (canceled_or_idle_run_loop_)
     canceled_or_idle_run_loop_->Quit();
 }
 
 void MockResourceLoader::OnResume() {
+  if (waiting_on_buffer_) {
+    EXPECT_TRUE(io_buffer_);
+    EXPECT_LT(0, io_buffer_size_);
+
+    waiting_on_buffer_ = false;
+  }
+
+  // Shouldn't update |io_buffer_| or |io_buffer_size_| on cancel.
   EXPECT_TRUE(status_ == Status::CALLBACK_PENDING ||
               status_ == Status::CALLING_HANDLER);
 
   status_ = Status::IDLE;
   if (canceled_or_idle_run_loop_)
     canceled_or_idle_run_loop_->Quit();
 }
 
 }  // namespace content