Make ResourceHandler::OnWillRead able to complete asynchronously.

content/browser/loader/mime_sniffing_resource_handler_unittest.cc

 // Copyright 2014 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/mime_sniffing_resource_handler.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 171 matching lines @@
 
   bool TestStreamIsIntercepted(bool allow_download,
                                bool must_download,
                                ResourceType request_resource_type);
 
   // Tests the operation of the MimeSniffingHandler when it needs to buffer
   // data (example case: the response is text/plain).
   void TestHandlerSniffing(bool response_started,
                            bool defer_response_started,
                            bool will_read,
+                           bool defer_will_read,
                            bool read_completed,
                            bool defer_read_completed);
 
   // Tests the operation of the MimeSniffingHandler when it doesn't buffer
   // data (example case: the response is text/html).
   void TestHandlerNoSniffing(bool response_started,
                              bool defer_response_started,
                              bool will_read,
+                             bool defer_will_read,
                              bool read_completed,
                              bool defer_read_completed);
 
  private:
   // Whether the URL request should be intercepted as a stream.
   bool stream_has_handler_;
   bool plugin_available_;
   bool plugin_stale_;
 
   TestBrowserThreadBundle thread_bundle_;
@@ skipping 95 matching lines @@
   EXPECT_LT(host.intercepted_as_stream_count(), 2);
   if (allow_download)
     EXPECT_TRUE(intercepting_handler->new_handler_for_testing());
   return host.intercepted_as_stream();
 }
 
 void MimeSniffingResourceHandlerTest::TestHandlerSniffing(
     bool response_started,
     bool defer_response_started,
     bool will_read,
+    bool defer_will_read,
     bool read_completed,
     bool defer_read_completed) {
   net::URLRequestContext context;
   std::unique_ptr<net::URLRequest> request(context.CreateRequest(
       GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
   ResourceRequestInfo::AllocateForTesting(request.get(),
                                           RESOURCE_TYPE_MAIN_FRAME,
                                           nullptr,  // context
                                           0,        // render_process_id
                                           0,        // render_view_id
@@ skipping 11 matching lines @@
   TestFakePluginService plugin_service(plugin_available_, plugin_stale_);
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
       new InterceptingResourceHandler(base::MakeUnique<TestResourceHandler>(),
                                       nullptr));
 
   std::unique_ptr<TestResourceHandler> scoped_test_handler(
       new TestResourceHandler());
   scoped_test_handler->set_on_response_started_result(response_started);
   scoped_test_handler->set_defer_on_response_started(defer_response_started);
   scoped_test_handler->set_on_will_read_result(will_read);
+  scoped_test_handler->set_defer_on_will_read(defer_will_read);
   scoped_test_handler->set_on_read_completed_result(read_completed);
   scoped_test_handler->set_defer_on_read_completed(defer_read_completed);
   TestResourceHandler* test_handler = scoped_test_handler.get();
   MimeSniffingResourceHandler mime_sniffing_handler(
       std::move(scoped_test_handler), &host, &plugin_service,
       intercepting_handler.get(), request.get(),
       REQUEST_CONTEXT_TYPE_UNSPECIFIED);
 
   MockResourceLoader mock_loader(&mime_sniffing_handler);
 
@@ skipping 21 matching lines @@
     EXPECT_EQ(0, test_handler->on_request_redirected_called());
     EXPECT_EQ(0, test_handler->on_response_started_called());
     EXPECT_EQ(1, test_handler->on_will_read_called());
     EXPECT_EQ(0, test_handler->on_read_completed_called());
 
     // Process all messages to ensure proper test teardown.
     content::RunAllPendingInMessageLoop();
     return;
   }
 
+  if (defer_will_read) {
+    ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
+              mock_loader.status());
+    EXPECT_EQ(MimeSniffingResourceHandler::STATE_WAITING_FOR_BUFFER,
+              mime_sniffing_handler.state_);
+    test_handler->Resume();
+    // MimeSniffingResourceHandler may not synchronously resume the request.
+    base::RunLoop().RunUntilIdle();
+  }
+
   ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader.status());
 
   // Simulate an HTML page. The mime sniffer will identify the MimeType and
   // proceed with replay.
   const char kData[] = "!DOCTYPE html\n<head>\n<title>Foo</title>\n</head>";
   // Construct StringPiece manually, as the terminal null needs to be included,
   // so it's sniffed as binary (Not important that it's sniffed as binary, but
   // this gaurantees it's sniffed as something, without waiting for more data).
   mock_loader.OnReadCompleted(base::StringPiece(kData, sizeof(kData)));
 
@@ skipping 58 matching lines @@
   EXPECT_EQ(1, test_handler->on_read_completed_called());
 
   // Process all messages to ensure proper test teardown.
   content::RunAllPendingInMessageLoop();
 }
 
 void MimeSniffingResourceHandlerTest::TestHandlerNoSniffing(
     bool response_started,
     bool defer_response_started,
     bool will_read,
+    bool defer_will_read,
     bool read_completed,
     bool defer_read_completed) {
   net::URLRequestContext context;
   std::unique_ptr<net::URLRequest> request(context.CreateRequest(
       GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
   ResourceRequestInfo::AllocateForTesting(request.get(),
                                           RESOURCE_TYPE_MAIN_FRAME,
                                           nullptr,  // context
                                           0,        // render_process_id
                                           0,        // render_view_id
@@ skipping 11 matching lines @@
   TestFakePluginService plugin_service(plugin_available_, plugin_stale_);
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
       new InterceptingResourceHandler(base::MakeUnique<TestResourceHandler>(),
                                       nullptr));
 
   std::unique_ptr<TestResourceHandler> scoped_test_handler(
       new TestResourceHandler());
   scoped_test_handler->set_on_response_started_result(response_started);
   scoped_test_handler->set_defer_on_response_started(defer_response_started);
   scoped_test_handler->set_on_will_read_result(will_read);
+  scoped_test_handler->set_defer_on_will_read(defer_will_read);
   scoped_test_handler->set_on_read_completed_result(read_completed);
   scoped_test_handler->set_defer_on_read_completed(defer_read_completed);
   TestResourceHandler* test_handler = scoped_test_handler.get();
   MimeSniffingResourceHandler mime_sniffing_handler(
       std::move(scoped_test_handler), &host, &plugin_service,
       intercepting_handler.get(), request.get(),
       REQUEST_CONTEXT_TYPE_UNSPECIFIED);
 
   MockResourceLoader mock_loader(&mime_sniffing_handler);
 
@@ skipping 47 matching lines @@
     EXPECT_EQ(0, test_handler->on_request_redirected_called());
     EXPECT_EQ(1, test_handler->on_response_started_called());
     EXPECT_EQ(1, test_handler->on_will_read_called());
     EXPECT_EQ(0, test_handler->on_read_completed_called());
 
     // Process all messages to ensure proper test teardown.
     content::RunAllPendingInMessageLoop();
     return;
   }
 
+  if (defer_will_read) {
+    ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
+              mock_loader.status());
+    EXPECT_EQ(MimeSniffingResourceHandler::STATE_STREAMING,
+              mime_sniffing_handler.state_);
+    test_handler->Resume();
+    // MimeSniffingResourceHandler may not synchronously resume the request.
+    base::RunLoop().RunUntilIdle();
+  }
+
   ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader.status());
 
   mock_loader.OnReadCompleted(std::string(2000, 'a'));
 
   EXPECT_EQ(1, test_handler->on_will_start_called());
   EXPECT_EQ(0, test_handler->on_request_redirected_called());
   EXPECT_EQ(1, test_handler->on_response_started_called());
   EXPECT_EQ(1, test_handler->on_will_read_called());
   EXPECT_EQ(1, test_handler->on_read_completed_called());
 
@@ skipping 142 matching lines @@
   allow_download = false;
   must_download = false;
   resource_type = RESOURCE_TYPE_OBJECT;
   EXPECT_TRUE(
       TestStreamIsIntercepted(allow_download, must_download, resource_type));
 }
 #endif
 
 // Test that the MimeSniffingHandler operates properly when it doesn't sniff
 // resources.
+// TODO(mmenke):  None of these test async cancellation.  Should they?
 TEST_F(MimeSniffingResourceHandlerTest, NoSniffing) {
   // Test simple case.
   TestHandlerNoSniffing(
       true  /* response_started_succeeds */,
       false /* defer_response_started */,
       true  /* will_read_succeeds */,
+      false /* defer_will_read */,
       true  /* read_completed_succeeds */,
       false /* defer_read_completed */);
 
-  // Test deferral in OnResponseStarted and/or in OnReadCompleted.
+  // Test deferral.
   TestHandlerNoSniffing(
       true  /* response_started_succeeds */,
       true  /* defer_response_started */,
       true  /* will_read_succeeds */,
+      false /* defer_will_read */,
       true  /* read_completed_succeeds */,
       false /* defer_read_completed */);
   TestHandlerNoSniffing(
       true  /* response_started_succeeds */,
       false /* defer_response_started */,
       true  /* will_read_succeeds */,
+      true  /* defer_will_read */,
+      true  /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+  TestHandlerNoSniffing(
+      true  /* response_started_succeeds */,
+      false /* defer_response_started */,
+      true  /* will_read_succeeds */,
+      false /* defer_will_read */,
       true  /* read_completed_succeeds */,
       true  /* defer_read_completed */);
   TestHandlerNoSniffing(
       true  /* response_started_succeeds */,
       true  /* defer_response_started */,
       true  /* will_read_succeeds */,
+      true  /* defer_will_read */,
       true  /* read_completed_succeeds */,
       true  /* defer_read_completed */);
 
   // Test cancel in OnResponseStarted, OnWillRead, OnReadCompleted.
   TestHandlerNoSniffing(
       false /* response_started_succeeds */,
       false /* defer_response_started */,
       false /* will_read_succeeds */,
+      false /* defer_will_read */,
       false /* read_completed_succeeds */,
       false /* defer_read_completed */);
   TestHandlerNoSniffing(
       true  /* response_started_succeeds */,
       false /* defer_response_started */,
       false /* will_read_succeeds */,
+      false /* defer_will_read */,
       false /* read_completed_succeeds */,
       false /* defer_read_completed */);
   TestHandlerNoSniffing(
       true  /* response_started_succeeds */,
       false /* defer_response_started */,
       true  /* will_read_succeeds */,
+      false /* defer_will_read */,
       false /* read_completed_succeeds */,
       false /* defer_read_completed */);
 
-  // Test cancel after OnResponseStarted deferral.
+  // Test cancel after deferral.
   TestHandlerNoSniffing(
       true  /* response_started_succeeds */,
       true  /* defer_response_started */,
       false /* will_read_succeeds */,
+      false /* defer_will_read */,
       false /* read_completed_succeeds */,
       false /* defer_read_completed */);
   TestHandlerNoSniffing(
       true  /* response_started_succeeds */,
       true  /* defer_response_started */,
+      true  /* defer_will_read */,
       true  /* will_read_succeeds */,
       false /* read_completed_succeeds */,
       false /* defer_read_completed */);
 
   content::RunAllPendingInMessageLoop();
 }
 
 // Test that the MimeSniffingHandler operates properly when it sniffs
 // resources.
+// TODO(mmenke):  None of these test async cancellation.  Should they?
 TEST_F(MimeSniffingResourceHandlerTest, Sniffing) {
   // Test simple case.
   TestHandlerSniffing(
       true  /* response_started_succeeds */,
       false /* defer_response_started */,
       true  /* will_read_succeeds */,
+      false /* defer_will_read */,
       true  /* read_completed_succeeds */,
       false /* defer_read_completed */);
 
-  // Test deferral in OnResponseStarted and/or in OnReadCompleted.
+  // Test deferral.
   TestHandlerSniffing(
       true  /* response_started_succeeds */,
       true  /* defer_response_started */,
       true  /* will_read_succeeds */,
+      false /* defer_will_read */,
       true  /* read_completed_succeeds */,
       false /* defer_read_completed */);
   TestHandlerSniffing(
       true  /* response_started_succeeds */,
       false /* defer_response_started */,
       true  /* will_read_succeeds */,
+      true  /* defer_will_read */,
+      true  /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+  TestHandlerSniffing(
+      true  /* response_started_succeeds */,
+      false /* defer_response_started */,
+      true  /* will_read_succeeds */,
+      false /* defer_will_read */,
       true  /* read_completed_succeeds */,
       true  /* defer_read_completed */);
   TestHandlerSniffing(
       true  /* response_started_succeeds */,
       true  /* defer_response_started */,
       true  /* will_read_succeeds */,
+      true  /* defer_will_read */,
       true  /* read_completed_succeeds */,
       true  /* defer_read_completed */);
 
   // Test cancel in OnResponseStarted, OnWillRead, OnReadCompleted.
   TestHandlerSniffing(
       false /* response_started_succeeds */,
       false /* defer_response_started */,
       false /* will_read_succeeds */,
+      false /* defer_will_read */,
       false /* read_completed_succeeds */,
       false /* defer_read_completed */);
   TestHandlerSniffing(
       true  /* response_started_succeeds */,
       false /* defer_response_started */,
       false /* will_read_succeeds */,
+      false /* defer_will_read */,
       false /* read_completed_succeeds */,
       false /* defer_read_completed */);
   TestHandlerSniffing(
       true  /* response_started_succeeds */,
       false /* defer_response_started */,
       true  /* will_read_succeeds */,
+      false /* defer_will_read */,
       false /* read_completed_succeeds */,
       false /* defer_read_completed */);
 
-  // Test cancel after OnResponseStarted deferral.
+  // Test cancel after deferral.
   TestHandlerSniffing(
       true  /* response_started_succeeds */,
       true  /* defer_response_started */,
       false /* will_read_succeeds */,
+      false /* defer_will_read */,
       false /* read_completed_succeeds */,
       false /* defer_read_completed */);
   TestHandlerSniffing(
       true  /* response_started_succeeds */,
       true  /* defer_response_started */,
       true  /* will_read_succeeds */,
+      true  /* defer_will_read */,
       false /* read_completed_succeeds */,
       false /* defer_read_completed */);
 
   content::RunAllPendingInMessageLoop();
 }
 
 // Tests that 304s do not trigger a change in handlers.
 TEST_F(MimeSniffingResourceHandlerTest, 304Handling) {
   net::URLRequestContext context;
   std::unique_ptr<net::URLRequest> request(context.CreateRequest(
@@ skipping 89 matching lines @@
   // on OnResponseStarted.
   EXPECT_EQ(MockResourceLoader::Status::CANCELED,
             mock_loader.OnResponseStarted(std::move(response)));
   EXPECT_EQ(net::ERR_ABORTED, mock_loader.error_code());
 
   // Process all messages to ensure proper test teardown.
   content::RunAllPendingInMessageLoop();
 }
 
 }  // namespace content