Make ResourceHandler::OnWillRead able to complete asynchronously.

content/browser/loader/test_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/test_resource_handler.h"
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "content/browser/loader/resource_controller.h"
 #include "content/public/common/resource_response.h"
@@ skipping 123 matching lines @@
   if (defer_on_will_start_) {
     defer_on_will_start_ = false;
     HoldController(std::move(controller));
     deferred_run_loop_->Quit();
     return;
   }
 
   controller->Resume();
 }
 
-bool TestResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
-                                     int* buf_size) {
+void TestResourceHandler::OnWillRead(
+    scoped_refptr<net::IOBuffer>* buf,
+    int* buf_size,
+    std::unique_ptr<ResourceController> controller) {
   EXPECT_FALSE(canceled_);
   EXPECT_FALSE(expect_on_data_downloaded_);
   EXPECT_EQ(0, on_response_completed_called_);
   // Only create a ScopedCallDepthTracker if not called re-entrantly, as
   // OnWillRead may be called synchronously in response to a Resume(), but
   // nothing may be called synchronously in response to the OnWillRead call.
   std::unique_ptr<ScopedCallDepthTracker> call_depth_tracker;
   if (call_depth_ == 0)
     call_depth_tracker = base::MakeUnique<ScopedCallDepthTracker>(&call_depth_);
 
   ++on_will_read_called_;
 
   if (!on_will_read_result_) {
     canceled_ = true;
-  } else {
-    *buf = buffer_;
-    *buf_size = buffer_size_;
-    memset(buffer_->data(), '\0', buffer_size_);
+    controller->Cancel();
+    return;
   }
 
-  return on_will_read_result_;
+  if (defer_on_will_read_) {
+    parent_read_buffer_ = buf;
+    parent_read_buffer_size_ = buf_size;
+    defer_on_will_read_ = false;
+    HoldController(std::move(controller));
+    deferred_run_loop_->Quit();
+    return;
+  }
+
+  *buf = buffer_;
+  *buf_size = buffer_size_;
+  controller->Resume();
 }
 
 void TestResourceHandler::OnReadCompleted(
     int bytes_read,
     std::unique_ptr<ResourceController> controller) {
   EXPECT_FALSE(canceled_);
   EXPECT_FALSE(expect_on_data_downloaded_);
   EXPECT_EQ(1, on_will_start_called_);
   EXPECT_EQ(1, on_response_started_called_);
   EXPECT_EQ(0, on_response_completed_called_);
-  EXPECT_EQ(0, on_read_eof_);
+  EXPECT_EQ(0, on_read_eof_called_);
   ScopedCallDepthTracker call_depth_tracker(&call_depth_);
 
   ++on_read_completed_called_;
   if (bytes_read == 0)
-    ++on_read_eof_;
+    ++on_read_eof_called_;
 
   EXPECT_LE(static_cast<size_t>(bytes_read), buffer_size_);
   if (body_ptr_)
     body_ptr_->append(buffer_->data(), bytes_read);
   body_.append(buffer_->data(), bytes_read);
 
   if (!on_read_completed_result_ || (!on_read_eof_result_ && bytes_read == 0)) {
     canceled_ = true;
     controller->Cancel();
     return;
   }
 
   if (defer_on_read_completed_ || (bytes_read == 0 && defer_on_read_eof_)) {
     defer_on_read_completed_ = false;
     HoldController(std::move(controller));
     deferred_run_loop_->Quit();
     return;
   }
 
   controller->Resume();
 }
 
 void TestResourceHandler::OnResponseCompleted(
     const net::URLRequestStatus& status,
     std::unique_ptr<ResourceController> controller) {
   ScopedCallDepthTracker call_depth_tracker(&call_depth_);
 
+  // These may be non-NULL if there was an out-of-band cancel.
+  parent_read_buffer_ = nullptr;
+  parent_read_buffer_size_ = nullptr;
+
   EXPECT_EQ(0, on_response_completed_called_);
   if (status.is_success() && !expect_on_data_downloaded_ && expect_eof_read_)
-    EXPECT_EQ(1, on_read_eof_);
+    EXPECT_EQ(1, on_read_eof_called_);
 
   ++on_response_completed_called_;
 
   if (request_status_ptr_)
     *request_status_ptr_ = status;
   final_status_ = status;
 
   // Consider response completed.  Even if deferring, the TestResourceHandler
   // won't be called again.
   response_complete_run_loop_.Quit();
@@ skipping 12 matching lines @@
   EXPECT_TRUE(expect_on_data_downloaded_);
   EXPECT_EQ(1, on_will_start_called_);
   EXPECT_EQ(1, on_response_started_called_);
   EXPECT_EQ(0, on_response_completed_called_);
 
   total_bytes_downloaded_ += bytes_downloaded;
 }
 
 void TestResourceHandler::Resume() {
   ScopedCallDepthTracker call_depth_tracker(&call_depth_);
+
+  if (parent_read_buffer_) {
+    *parent_read_buffer_ = buffer_;
+    *parent_read_buffer_size_ = buffer_size_;
+    parent_read_buffer_ = nullptr;
+    parent_read_buffer_size_ = nullptr;
+    memset(buffer_->data(), '\0', buffer_size_);
+  }
+
   ResourceHandler::Resume();
 }
 
 void TestResourceHandler::CancelWithError(net::Error net_error) {
   ScopedCallDepthTracker call_depth_tracker(&call_depth_);
   canceled_ = true;
+
+  // Don't want to populate these after a cancel.
+  parent_read_buffer_ = nullptr;
+  parent_read_buffer_size_ = nullptr;
+
   ResourceHandler::CancelWithError(net_error);
 }
 
 void TestResourceHandler::SetBufferSize(int buffer_size) {
   buffer_ = new net::IOBuffer(buffer_size);
   buffer_size_ = buffer_size;
   memset(buffer_->data(), '\0', buffer_size);
 }
 
 void TestResourceHandler::WaitUntilDeferred() {
   deferred_run_loop_->Run();
   deferred_run_loop_.reset(new base::RunLoop());
 }
 
 void TestResourceHandler::WaitUntilResponseComplete() {
   response_complete_run_loop_.Run();
 }
 
 base::WeakPtr<TestResourceHandler> TestResourceHandler::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace content