Add buffering to MimeSniffingResourceHandler.

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 <algorithm>
 #include <memory>
 
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/loader/intercepting_resource_handler.h"
@@ skipping 165 matching lines @@
                                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);
+                           bool defer_read_completed,
+                           int read_chunk_size,
+                           int downstream_handler_buffer_size);
 
   // 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);
+                             bool defer_read_completed,
+                             int read_chunk_size,
+                             int downstream_handler_buffer_size);
 
  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_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) {
+    bool defer_read_completed,
+    int read_chunk_size,
+    int downstream_handler_buffer_size) {
   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
                                           0,        // render_frame_id
                                           true,     // is_main_frame
@@ skipping 12 matching lines @@
                                       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);
+  scoped_test_handler->SetBufferSize(downstream_handler_buffer_size);
   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);
 
   ASSERT_EQ(MockResourceLoader::Status::IDLE,
             mock_loader.OnWillStart(request->url()));
 
   // The response should be sniffed.
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   response->head.mime_type.assign("text/plain");
 
   // Simulate the response starting. The MimeSniffingHandler should start
   // buffering, so the return value should always be true.
   ASSERT_EQ(MockResourceLoader::Status::IDLE,
             mock_loader.OnResponseStarted(std::move(response)));
 
-  // Read some data to sniff the mime type. This will ask the next
-  // ResourceHandler for a buffer.
-  mock_loader.OnWillRead();
+  // Read some data to sniff the mime type.
+  // 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>";
+  size_t string_pos = 0u;
+  do {
+    mock_loader.OnWillRead();
 
-  if (!will_read) {
+    ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader.status());
+
+    size_t amount_to_write = std::min(sizeof(kData) - string_pos,
+                                      static_cast<size_t>(read_chunk_size));
+
+    // 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 + string_pos, amount_to_write));
+    string_pos += amount_to_write;
+  } while (string_pos != sizeof(kData));
+
+  // If the next handler cancels the response start, the caller of
+  // MimeSniffingHandler::OnReadCompleted should be notified immediately.
+  if (!response_started) {
     EXPECT_EQ(MockResourceLoader::Status::CANCELED, mock_loader.status());
     EXPECT_EQ(net::ERR_ABORTED, mock_loader.error_code());
 
     EXPECT_EQ(1, test_handler->on_will_start_called());
     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(1, test_handler->on_response_started_called());
+    EXPECT_EQ(0, 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) {
+  if (defer_response_started) {
     ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
               mock_loader.status());
-    EXPECT_EQ(MimeSniffingResourceHandler::STATE_WAITING_FOR_BUFFER,
+    EXPECT_EQ(MimeSniffingResourceHandler::STATE_REPLAYING_RESPONSE_RECEIVED,
               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)));
-
-  // If the next handler cancels the response start, the caller of
-  // MimeSniffingHandler::OnReadCompleted should be notified immediately.
-  if (!response_started) {
+  // This is the point at which the replay will happen, which will allocate
+  // a buffer and give the downstream handler a chance to cancel.
+  if (!will_read) {
     EXPECT_EQ(MockResourceLoader::Status::CANCELED, mock_loader.status());
     EXPECT_EQ(net::ERR_ABORTED, mock_loader.error_code());
 
     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(0, test_handler->on_read_completed_called());
 
     // Process all messages to ensure proper test teardown.
     content::RunAllPendingInMessageLoop();
     return;
   }
 
-  if (defer_response_started) {
+  if (defer_will_read) {
     ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
               mock_loader.status());
-    EXPECT_EQ(MimeSniffingResourceHandler::STATE_REPLAYING_RESPONSE_RECEIVED,
+    EXPECT_EQ(MimeSniffingResourceHandler::STATE_REPLAYING_WAIT_FOR_WILL_READ,
               mime_sniffing_handler.state_);
     test_handler->Resume();
     // MimeSniffingResourceHandler may not synchronously resume the request.
     base::RunLoop().RunUntilIdle();
   }
 
   // The body that was sniffed should be transmitted to the next handler. This
   // may cancel the request.
   if (!read_completed) {
     EXPECT_EQ(MockResourceLoader::Status::CANCELED, mock_loader.status());
     EXPECT_EQ(net::ERR_ABORTED, mock_loader.error_code());
 
     // Process all messages to ensure proper test teardown.
     content::RunAllPendingInMessageLoop();
     return;
   }
 
-  EXPECT_EQ(MimeSniffingResourceHandler::STATE_STREAMING,
-            mime_sniffing_handler.state_);
-
   // The request may be deferred by the next handler once the read is done.
   if (defer_read_completed) {
+    // The replay isn't considered complete until the downstream handler
+    // finishes the read completed....
+    EXPECT_EQ(MimeSniffingResourceHandler::STATE_REPLAYING_RESPONSE_RECEIVED,
+              mime_sniffing_handler.state_);
     ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
               mock_loader.status());
     test_handler->Resume();
-    // MimeSniffingResourceHandler may not synchronously resume the request.
+
+    // (MimeSniffingResourceHandler may not synchronously resume the request.)
     base::RunLoop().RunUntilIdle();
+
+    // ... which should be now.
+    EXPECT_EQ(MimeSniffingResourceHandler::STATE_STREAMING,
+              mime_sniffing_handler.state_);
+  } else {
+    EXPECT_EQ(MimeSniffingResourceHandler::STATE_STREAMING,
+              mime_sniffing_handler.state_);
   }
 
   EXPECT_EQ(MockResourceLoader::Status::IDLE, mock_loader.status());
   EXPECT_EQ(MimeSniffingResourceHandler::STATE_STREAMING,
             mime_sniffing_handler.state_);
 
   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());
+  EXPECT_LE(1, test_handler->on_will_read_called());
+  EXPECT_LE(1, test_handler->on_read_completed_called());
+  // Include trailing null in expected value.
+  EXPECT_EQ(std::string(kData, strlen(kData) + 1), test_handler->body());
 
   // 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) {
+    bool defer_read_completed,
+    int read_chunk_size,
+    int downstream_handler_buffer_size) {
   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
                                           0,        // render_frame_id
                                           true,     // is_main_frame
@@ skipping 12 matching lines @@
                                       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);
+  scoped_test_handler->SetBufferSize(downstream_handler_buffer_size);
   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);
 
   ASSERT_EQ(MockResourceLoader::Status::IDLE,
             mock_loader.OnWillStart(request->url()));
@@ skipping 24 matching lines @@
   if (defer_response_started) {
     ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
               mock_loader.status());
     EXPECT_EQ(MimeSniffingResourceHandler::STATE_REPLAYING_RESPONSE_RECEIVED,
               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());
+  const std::string input(std::string(2000, 'a'));
+  const char* to_read = input.c_str();
+  int read_cycles = 1;
+  do {
+    // The MimeSniffingResourceHandler should be acting as a pass-through
+    // ResourceHandler.
+    mock_loader.OnWillRead();
 
-  // The MimeSniffingResourceHandler should be acting as a pass-through
-  // ResourceHandler.
-  mock_loader.OnWillRead();
+    // Only relevant the first time through the loop.
+    if (!will_read) {
+      EXPECT_EQ(MockResourceLoader::Status::CANCELED, mock_loader.status());
+      EXPECT_EQ(net::ERR_ABORTED, mock_loader.error_code());
 
-  if (!will_read) {
-    EXPECT_EQ(MockResourceLoader::Status::CANCELED, mock_loader.status());
-    EXPECT_EQ(net::ERR_ABORTED, mock_loader.error_code());
+      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(0, test_handler->on_read_completed_called());
+
+      // Process all messages to ensure proper test teardown.
+      content::RunAllPendingInMessageLoop();
+      return;
+    }
+
+    if (defer_will_read) {
+      defer_will_read = false;  // Only a single will read is deferred.
+      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());
+
+    ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader.status());
+    int amount_to_read =
+        std::min(static_cast<int>(strlen(to_read)),
+                 std::min(mock_loader.io_buffer_size(), read_chunk_size));
+
+    mock_loader.OnReadCompleted(std::string(to_read, amount_to_read));
+    to_read += amount_to_read;
 
     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(0, test_handler->on_read_completed_called());
+    EXPECT_EQ(read_cycles, test_handler->on_will_read_called());
+    EXPECT_EQ(read_cycles, test_handler->on_read_completed_called());
 
-    // Process all messages to ensure proper test teardown.
-    content::RunAllPendingInMessageLoop();
-    return;
-  }
+    // Only relevant first time through.
+    if (!read_completed) {
+      EXPECT_EQ(MockResourceLoader::Status::CANCELED, mock_loader.status());
+      EXPECT_EQ(net::ERR_ABORTED, mock_loader.error_code());
 
-  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();
-  }
+      // Process all messages to ensure proper test teardown.
+      content::RunAllPendingInMessageLoop();
+      return;
+    }
 
-  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader.status());
+    if (mock_loader.status() == MockResourceLoader::Status::CALLBACK_PENDING) {
+      test_handler->Resume();
+      // MimeSniffingResourceHandler may not synchronously resume the request.
+      base::RunLoop().RunUntilIdle();
+    }
 
-  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());
-
-  if (!read_completed) {
-    EXPECT_EQ(MockResourceLoader::Status::CANCELED, mock_loader.status());
-    EXPECT_EQ(net::ERR_ABORTED, mock_loader.error_code());
-
-    // Process all messages to ensure proper test teardown.
-    content::RunAllPendingInMessageLoop();
-    return;
-  }
+    ++read_cycles;
+  } while (strlen(to_read) > 0);
 
   if (mock_loader.status() == MockResourceLoader::Status::CALLBACK_PENDING) {
     test_handler->Resume();
     // MimeSniffingResourceHandler may not synchronously resume the request.
     base::RunLoop().RunUntilIdle();
   }
 
   ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader.status());
 
   // Process all messages to ensure proper test teardown.
@@ skipping 130 matching lines @@
 #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 */);
+      true /* read_completed_succeeds */, false /* defer_read_completed */,
+      2048, 2048);
 
   // 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 */);
+      true /* read_completed_succeeds */, false /* defer_read_completed */,
+      2048, 2048);
   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 */);
+      true /* read_completed_succeeds */, false /* defer_read_completed */,
+      2048, 2048);
   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 */);
+      true /* read_completed_succeeds */, true /* defer_read_completed */, 2048,
+      2048);
   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 */);
+      true /* read_completed_succeeds */, true /* defer_read_completed */, 2048,
+      2048);
 
   // 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 */);
+      false /* read_completed_succeeds */, false /* defer_read_completed */,
+      2048, 2048);
   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 */);
+      false /* read_completed_succeeds */, false /* defer_read_completed */,
+      2048, 2048);
   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 */);
+      false /* read_completed_succeeds */, false /* defer_read_completed */,
+      2048, 2048);
 
   // 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 */);
+      false /* read_completed_succeeds */, false /* defer_read_completed */,
+      2048, 2048);
   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 */);
+      false /* read_completed_succeeds */, false /* defer_read_completed */,
+      2048, 2048);
 
   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 */);
+      true /* read_completed_succeeds */, false /* defer_read_completed */,
+      2048, 2048);
 
   // 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 */);
+      true /* read_completed_succeeds */, false /* defer_read_completed */,
+      2048, 2048);
+  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 */, 2048, 2048);
   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 */);
+      true /* read_completed_succeeds */, true /* defer_read_completed */, 2048,
+      2048);
+  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 */, 2048, 2048);
 
   // 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 */);
+      false /* read_completed_succeeds */, false /* defer_read_completed */,
+      2048, 2048);
   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 */);
+      false /* read_completed_succeeds */, false /* defer_read_completed */,
+      2048, 2048);
   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 */);
+      false /* read_completed_succeeds */, false /* defer_read_completed */,
+      2048, 2048);
 
   // 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 */);
+      false /* read_completed_succeeds */, false /* defer_read_completed */,
+      2048, 2048);
+  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 */, 2048, 2048);
 
   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(
       GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
   ResourceRequestInfo::AllocateForTesting(request.get(),
@@ skipping 86 matching lines @@
   // mime sniffing is disabled and the wrapped resource handler returns false
   // 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();
 }
 
+TEST_F(MimeSniffingResourceHandlerTest, SmallReturnedBuffer) {
+  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 */, 1, 1);
+
+  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 */, 1,
+      1);
+}
+
 }  // namespace content