Add buffering to MimeSniffingResourceHandler.

content/browser/loader/mojo_async_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/mojo_async_resource_handler.h"
 
 #include <string.h>
 
 #include <utility>
 #include <vector>
@@ skipping 536 matching lines @@
     if (result == MOJO_RESULT_SHOULD_WAIT) {
       base::RunLoop().RunUntilIdle();
       continue;
     }
     contents.append(buffer, read_size);
   }
   EXPECT_EQ("AB", contents);
 }
 
 TEST_F(MojoAsyncResourceHandlerTest,
-       OnWillReadAndOnReadCompletedWithInsufficientInitialCapacity) {
-  MojoAsyncResourceHandler::SetAllocationSizeForTesting(2);
-
-  ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
-  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead());
-  // The buffer size that the mime sniffer requires implicitly.
-  ASSERT_GE(mock_loader_->io_buffer_size(),
-            kSizeMimeSnifferRequiresForFirstOnWillRead);
-
-  const std::string data("abcdefgh");
-  ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
-            mock_loader_->OnReadCompleted(data));
-
-  url_loader_client_.RunUntilResponseBodyArrived();
-  ASSERT_TRUE(url_loader_client_.response_body().is_valid());
-
-  std::string contents;
-  while (contents.size() < data.size()) {
-    // This is needed for Resume to be called.
-    base::RunLoop().RunUntilIdle();
-    char buffer[16];
-    uint32_t read_size = sizeof(buffer);
-    MojoResult result =
-        mojo::ReadDataRaw(url_loader_client_.response_body(), buffer,
-                          &read_size, MOJO_READ_DATA_FLAG_NONE);
-    if (result == MOJO_RESULT_SHOULD_WAIT)
-      continue;
-    ASSERT_EQ(MOJO_RESULT_OK, result);
-    contents.append(buffer, read_size);
-  }
-  EXPECT_EQ(data, contents);
-  EXPECT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->status());
-}
-
-TEST_F(MojoAsyncResourceHandlerTest,
        IOBufferFromOnWillReadShouldRemainValidEvenIfHandlerIsGone) {
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
   ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead());
   // The io_buffer size that the mime sniffer requires implicitly.
   ASSERT_GE(mock_loader_->io_buffer_size(),
             kSizeMimeSnifferRequiresForFirstOnWillRead);
 
   handler_ = nullptr;
   url_loader_client_.Unbind();
   base::RunLoop().RunUntilIdle();
@@ skipping 274 matching lines @@
             mock_loader_->OnResponseCompleted(
                 net::URLRequestStatus::FromError(net::OK)));
 
   url_loader_client_.RunUntilComplete();
   EXPECT_TRUE(url_loader_client_.has_received_completion());
 
   handler_.reset();
   EXPECT_EQ(0, rdh_.num_in_flight_requests_for_testing());
 }
 
-TEST_F(MojoAsyncResourceHandlerTest,
-       EndWriteFailsOnWillReadWithInsufficientInitialCapacity) {
-  MojoAsyncResourceHandler::SetAllocationSizeForTesting(2);
-  ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
-  handler_->set_end_write_expectation(MOJO_RESULT_UNKNOWN);
-  ASSERT_EQ(MockResourceLoader::Status::CANCELED, mock_loader_->OnWillRead());
-}
-
 TEST_F(MojoAsyncResourceHandlerTest, EndWriteFailsOnReadCompleted) {
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
   ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead());
 
   handler_->set_end_write_expectation(MOJO_RESULT_SHOULD_WAIT);
   ASSERT_EQ(MockResourceLoader::Status::CANCELED,
             mock_loader_->OnReadCompleted(
                 std::string(mock_loader_->io_buffer_size(), 'w')));
 }
 
-TEST_F(MojoAsyncResourceHandlerTest,
-       EndWriteFailsOnReadCompletedWithInsufficientInitialCapacity) {
-  MojoAsyncResourceHandler::SetAllocationSizeForTesting(2);
-  ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
-  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead());
-
-  handler_->set_end_write_expectation(MOJO_RESULT_SHOULD_WAIT);
-  ASSERT_EQ(MockResourceLoader::Status::CANCELED,
-            mock_loader_->OnReadCompleted(
-                std::string(mock_loader_->io_buffer_size(), 'w')));
-}
-
-TEST_F(MojoAsyncResourceHandlerTest,
-       EndWriteFailsOnResumeWithInsufficientInitialCapacity) {
-  MojoAsyncResourceHandler::SetAllocationSizeForTesting(8);
-  ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
-  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead());
-
-  while (true) {
-    MockResourceLoader::Status result = mock_loader_->OnReadCompleted(
-        std::string(mock_loader_->io_buffer_size(), 'A'));
-    if (result == MockResourceLoader::Status::CALLBACK_PENDING)
-      break;
-    ASSERT_EQ(MockResourceLoader::Status::IDLE, result);
-
-    ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead());
-  }
-
-  url_loader_client_.RunUntilResponseBodyArrived();
-  ASSERT_TRUE(url_loader_client_.response_body().is_valid());
-
-  while (true) {
-    char buf[16];
-    uint32_t read_size = sizeof(buf);
-    MojoResult result =
-        mojo::ReadDataRaw(url_loader_client_.response_body(), buf, &read_size,
-                          MOJO_READ_DATA_FLAG_NONE);
-    if (result == MOJO_RESULT_SHOULD_WAIT)
-      break;
-    ASSERT_EQ(MOJO_RESULT_OK, result);
-  }
-
-  handler_->set_end_write_expectation(MOJO_RESULT_SHOULD_WAIT);
-  mock_loader_->WaitUntilIdleOrCanceled();
-  EXPECT_FALSE(url_loader_client_.has_received_completion());
-  EXPECT_EQ(MockResourceLoader::Status::CANCELED, mock_loader_->status());
-  EXPECT_EQ(net::ERR_INSUFFICIENT_RESOURCES, mock_loader_->error_code());
-}
-
 TEST_F(MojoAsyncResourceHandlerUploadTest, UploadProgressHandling) {
   ASSERT_TRUE(CallOnWillStart());
 
   // Expect no report for no progress.
   set_upload_progress(net::UploadProgress(0, 1000));
   handler_->PollUploadProgress();
   EXPECT_FALSE(url_loader_client_.has_received_upload_progress());
   EXPECT_EQ(0, url_loader_client_.current_upload_position());
   EXPECT_EQ(0, url_loader_client_.total_upload_size());
 
@@ skipping 391 matching lines @@
     }
   }
   EXPECT_EQ("B", body);
 }
 
 INSTANTIATE_TEST_CASE_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
                         MojoAsyncResourceHandlerWithAllocationSizeTest,
                         ::testing::Values(8, 32 * 2014));
 }  // namespace
 }  // namespace content