Make ResourceHandler::OnWillRead able to complete asynchronously.

content/browser/loader/intercepting_resource_handler_unittest.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 <stdint.h>
 
 #include <memory>
 #include <string>
@@ skipping 18 matching lines @@
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace content {
 
 namespace {
 
-class TestResourceController : public ResourceController {
- public:
-  TestResourceController() = default;
-  void Cancel() override {}
-  void CancelAndIgnore() override {}
-  void CancelWithError(int error_code) override {}
-  void Resume() override { ++resume_calls_; }
-
-  int resume_calls() const { return resume_calls_; }
-
- private:
-  int resume_calls_ = 0;
-
-  DISALLOW_COPY_AND_ASSIGN(TestResourceController);
-};
-
 class InterceptingResourceHandlerTest : public testing::Test {
  public:
   InterceptingResourceHandlerTest()
       : request_(context_.CreateRequest(GURL("http://www.google.com"),
                                         net::DEFAULT_PRIORITY,
                                         nullptr)),
         old_handler_status_(
             net::URLRequestStatus::FromError(net::ERR_IO_PENDING)) {
     ResourceRequestInfo::AllocateForTesting(request_.get(),
                                             RESOURCE_TYPE_MAIN_FRAME,
@@ skipping 311 matching lines @@
   ASSERT_EQ(MockResourceLoader::Status::CANCELED,
             mock_loader_->OnReadCompleted(kData));
   EXPECT_EQ(net::ERR_ABORTED, mock_loader_->error_code());
 }
 
 // The old handler sets |defer| to true in OnReadCompleted and
 // OnResponseCompleted. The new handler sets |defer| to true in
 // OnResponseStarted and OnReadCompleted.
 TEST_F(InterceptingResourceHandlerTest, DeferredOperations) {
   const char kData[] = "The data";
-  const std::string kPayload = "The long long long long long payload";
-  const int kOldHandlerBufferSize = 10;
+  const char kPayload[] = "The long long long long long payload";
+  // This should be less than half the size of the payload, so it needs at least
+  // 3 reads to receive.
+  const int kOldHandlerBufferSize = arraysize(kPayload) / 3;
 
   // When sending a payload to the old ResourceHandler, the
   // InterceptingResourceHandler doesn't send a final EOF read.
   // TODO(mmenke):  Should it?  Or can we just get rid of that 0-byte read
   // entirely?
   old_handler_->set_expect_eof_read(false);
   old_handler_->SetBufferSize(kOldHandlerBufferSize);
+  old_handler_->set_defer_on_will_read(true);
   old_handler_->set_defer_on_read_completed(true);
   scoped_refptr<net::IOBuffer> old_buffer = old_handler_->buffer();
 
   // Simulate the MimeSniffingResourceHandler buffering the data.
+
   ASSERT_EQ(MockResourceLoader::Status::IDLE,
             mock_loader_->OnWillStart(request_->url()));
-  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead());
+  // The old handler defers the read.
+  ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
+            mock_loader_->OnWillRead());
+  old_handler_->WaitUntilDeferred();
+
+  EXPECT_EQ(net::URLRequestStatus::IO_PENDING, old_handler_status_.status());
+  EXPECT_EQ(1, old_handler_->on_will_read_called());
+  EXPECT_EQ(0, old_handler_->on_read_completed_called());
+  EXPECT_EQ(0, old_handler_->on_response_completed_called());
+
+  // Defer the next OnWillRead, too. This is needed to test the case where
+  // OnWillRead completes asynchornously when passing the payload to the old

[Charlie Harrison, 2017/02/16 21:25:04]

s/asynchornously/asynchronously

[mmenke, 2017/03/08 19:16:07]

Done.

+  // handler.
+  old_handler_->set_defer_on_will_read(true);
+
+  // The old handle resumes the request.
+  old_handler_->Resume();
+
+  // Resume() call may do work asynchronously. Wait until that's done.
+  mock_loader_->WaitUntilIdleOrCanceled();
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->status());
 
   ASSERT_NE(mock_loader_->io_buffer(), old_buffer.get());
 
   // Simulate the MimeSniffingResourceHandler asking the
   // InterceptingResourceHandler to switch to a new handler.
   net::URLRequestStatus new_handler_status = {net::URLRequestStatus::IO_PENDING,
                                               0};
 
   std::string new_handler_body;
   std::unique_ptr<TestResourceHandler> scoped_new_handler(
       new TestResourceHandler(&new_handler_status, &new_handler_body));
   base::WeakPtr<TestResourceHandler> new_handler =
       scoped_new_handler->GetWeakPtr();
   scoped_new_handler->SetBufferSize(1);
   scoped_new_handler->set_defer_on_will_start(true);
   scoped_new_handler->set_defer_on_response_started(true);
+  scoped_new_handler->set_defer_on_will_read(true);
   scoped_new_handler->set_defer_on_read_completed(true);
   scoped_new_handler->set_defer_on_response_completed(true);
   intercepting_handler_->UseNewHandler(std::move(scoped_new_handler), kPayload);
 
   // The response is received, and then deferred by the old handler's
   // OnReadCompleted method.
   ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
             mock_loader_->OnResponseStarted(
                 make_scoped_refptr(new ResourceResponse())));
+  old_handler_->WaitUntilDeferred();
+
+  EXPECT_EQ(1, old_handler_->on_read_completed_called());
+  EXPECT_EQ(0, old_handler_->on_response_completed_called());
+  EXPECT_EQ(0, new_handler->on_response_started_called());
 
   // The old handler has received the first N bytes of the payload synchronously
   // where N is the size of the buffer exposed via OnWillRead.
   EXPECT_EQ(std::string(kPayload, 0, kOldHandlerBufferSize), old_handler_body_);
   EXPECT_EQ(std::string(), new_handler_body);
   EXPECT_EQ(net::URLRequestStatus::IO_PENDING, old_handler_status_.status());
   EXPECT_EQ(net::URLRequestStatus::IO_PENDING, new_handler_status.status());
 
+  // Run until the old handler's OnWillRead method defers the request while
+  // replaying the payload.
+  old_handler_->Resume();
+  old_handler_->WaitUntilDeferred();
+  EXPECT_EQ(2, old_handler_->on_will_read_called());
+  EXPECT_EQ(1, old_handler_->on_read_completed_called());
+  EXPECT_EQ(0, old_handler_->on_response_completed_called());
+  EXPECT_EQ(std::string(kPayload, 0, kOldHandlerBufferSize), old_handler_body_);
+  EXPECT_EQ(std::string(), new_handler_body);
+  EXPECT_EQ(net::URLRequestStatus::IO_PENDING, old_handler_status_.status());
+  EXPECT_EQ(net::URLRequestStatus::IO_PENDING, new_handler_status.status());
+
   // Run until the new handler's OnWillStart method defers the request.
   old_handler_->Resume();
-  // Resume() call may do work asynchronously. Wait until that's done.
-  base::RunLoop().RunUntilIdle();
+  new_handler->WaitUntilDeferred();
+
+  EXPECT_EQ(1, new_handler->on_will_start_called());
+  EXPECT_EQ(0, new_handler->on_response_started_called());
   ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
             mock_loader_->status());
   EXPECT_EQ(kPayload, old_handler_body_);
   EXPECT_EQ(net::URLRequestStatus::SUCCESS, old_handler_status_.status());
   EXPECT_FALSE(old_handler_);
   EXPECT_EQ(std::string(), new_handler_body);
   EXPECT_EQ(net::URLRequestStatus::IO_PENDING, new_handler_status.status());
 
   // Run until the new handler's OnResponseStarted method defers the request.
   new_handler->Resume();
   // Resume() call may do work asynchronously. Wait until that's done.
-  base::RunLoop().RunUntilIdle();
+  new_handler->WaitUntilDeferred();
+
+  EXPECT_EQ(1, new_handler->on_response_started_called());
+  EXPECT_EQ(0, new_handler->on_will_read_called());
   ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
             mock_loader_->status());
   EXPECT_EQ(std::string(), new_handler_body);
   EXPECT_EQ(net::URLRequestStatus::IO_PENDING, new_handler_status.status());
 
   // Resuming should finally call back into the ResourceController.
   new_handler->Resume();
   mock_loader_->WaitUntilIdleOrCanceled();
   ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->status());
 
-  // Data is read, the new handler defers completion of the read.
+  // Data is read, the new handler defers OnWillRead.
   ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
             mock_loader_->OnReadCompleted(kData));
+  new_handler->WaitUntilDeferred();
+  EXPECT_EQ(1, new_handler->on_will_read_called());
+  EXPECT_EQ(0, new_handler->on_read_completed_called());
+
+  // The new ResourceHandler resumes, and then defers again in OnReadCompleted.
+  new_handler->Resume();
+  new_handler->WaitUntilDeferred();
+  EXPECT_EQ(1, new_handler->on_will_read_called());
+  EXPECT_EQ(1, new_handler->on_read_completed_called());
+  EXPECT_EQ(0, new_handler->on_response_completed_called());
 
   EXPECT_EQ("T", new_handler_body);
 
+  // New handler resumes again, everything continues synchronously until all
+  // written data is consumed.
   new_handler->Resume();
   mock_loader_->WaitUntilIdleOrCanceled();
   ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->status());
   EXPECT_EQ(kData, new_handler_body);
   EXPECT_EQ(net::URLRequestStatus::IO_PENDING, new_handler_status.status());
+  EXPECT_EQ(0, new_handler->on_read_eof_called());
+  EXPECT_EQ(0, new_handler->on_response_completed_called());
 
   // Final EOF byte is read.
   ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead());
   ASSERT_EQ(MockResourceLoader::Status::IDLE,
             mock_loader_->OnReadCompleted(""));
+  EXPECT_EQ(1, new_handler->on_read_eof_called());
+  EXPECT_EQ(0, new_handler->on_response_completed_called());
 
   ASSERT_EQ(
       MockResourceLoader::Status::CALLBACK_PENDING,
       mock_loader_->OnResponseCompleted({net::URLRequestStatus::SUCCESS, 0}));
   EXPECT_EQ(net::URLRequestStatus::SUCCESS, new_handler_status.status());
+  EXPECT_EQ(1, new_handler->on_response_completed_called());
 }
 
 // Test cancellation where there is only the old handler in an
 // InterceptingResourceHandler.
 TEST_F(InterceptingResourceHandlerTest, CancelOldHandler) {
   ASSERT_EQ(MockResourceLoader::Status::IDLE,
             mock_loader_->OnResponseCompletedFromExternalOutOfBandCancel(
                 {net::URLRequestStatus::CANCELED, net::ERR_FAILED}));
   EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status_.status());
   EXPECT_EQ(net::ERR_FAILED, old_handler_status_.error());
@@ skipping 81 matching lines @@
                 {net::URLRequestStatus::CANCELED, net::ERR_FAILED}));
   EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status_.status());
   EXPECT_EQ(net::ERR_FAILED, old_handler_status_.error());
   EXPECT_EQ(net::URLRequestStatus::CANCELED, new_handler_status.status());
   EXPECT_EQ(net::ERR_FAILED, new_handler_status.error());
 }
 
 }  // namespace
 
 }  // namespace content