Implement redirect handling on MojoAsyncResourceHandler

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>
 
@@ skipping 228 matching lines @@
   void ResetBeginWriteExpectation() { is_begin_write_expectation_set_ = false; }
 
   void set_begin_write_expectation(MojoResult begin_write_expectation) {
     is_begin_write_expectation_set_ = true;
     begin_write_expectation_ = begin_write_expectation;
   }
   void set_end_write_expectation(MojoResult end_write_expectation) {
     is_end_write_expectation_set_ = true;
     end_write_expectation_ = end_write_expectation;
   }
+  bool has_received_bad_message() const { return has_received_bad_message_; }
 
  private:
   MojoResult BeginWrite(void** data, uint32_t* available) override {
     if (is_begin_write_expectation_set_)
       return begin_write_expectation_;
     return MojoAsyncResourceHandler::BeginWrite(data, available);
   }
   MojoResult EndWrite(uint32_t written) override {
     if (is_end_write_expectation_set_)
       return end_write_expectation_;
     return MojoAsyncResourceHandler::EndWrite(written);
   }
+  void ReportBadMessage(const std::string& error) override {
+    has_received_bad_message_ = true;
+  }
 
   bool is_begin_write_expectation_set_ = false;
   bool is_end_write_expectation_set_ = false;
+  bool has_received_bad_message_ = false;
   MojoResult begin_write_expectation_ = MOJO_RESULT_UNKNOWN;
   MojoResult end_write_expectation_ = MOJO_RESULT_UNKNOWN;
 
   DISALLOW_COPY_AND_ASSIGN(
       MojoAsyncResourceHandlerWithCustomDataPipeOperations);
 };
 
 class TestURLLoaderFactory final : public mojom::URLLoaderFactory {
  public:
   TestURLLoaderFactory() {}
@@ skipping 558 matching lines @@
     written += io_buffer_size;
     bool defer = false;
     ASSERT_TRUE(handler_->OnReadCompleted(io_buffer_size, &defer));
     if (defer)
       break;
   }
 
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
   handler_->ResetBeginWriteExpectation();
-  handler_->ResumeForTesting();
+  handler_->OnWritableForTesting();
 
   std::string actual;
   while (actual.size() < written) {
     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);
     ASSERT_TRUE(result == MOJO_RESULT_OK || result == MOJO_RESULT_SHOULD_WAIT);
     if (result == MOJO_RESULT_OK)
@@ skipping 218 matching lines @@
     if (result == MOJO_RESULT_FAILED_PRECONDITION)
       break;
     base::RunLoop().RunUntilIdle();
     DCHECK(result == MOJO_RESULT_SHOULD_WAIT || result == MOJO_RESULT_OK);
   }
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, resource_controller_.num_resume_calls());
 }
 
+TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, RedirectHandling) {
+  rdh_delegate_.set_num_on_response_started_calls_expectation(1);
+  bool defer = false;
+
+  ASSERT_TRUE(handler_->OnWillStart(request_->url(), &defer));
+  ASSERT_FALSE(defer);
+  scoped_refptr<ResourceResponse> response = new ResourceResponse();
+  net::RedirectInfo redirect_info;
+  redirect_info.status_code = 301;
+  ASSERT_TRUE(
+      handler_->OnRequestRedirected(redirect_info, response.get(), &defer));
+  ASSERT_TRUE(defer);
+
+  ASSERT_FALSE(url_loader_client_.has_received_response());
+  ASSERT_FALSE(url_loader_client_.has_received_redirect());
+  url_loader_client_.RunUntilRedirectReceived();
+
+  ASSERT_FALSE(url_loader_client_.has_received_response());
+  ASSERT_TRUE(url_loader_client_.has_received_redirect());
+  EXPECT_EQ(301, url_loader_client_.redirect_info().status_code);
+
+  EXPECT_EQ(0, resource_controller_.num_resume_calls());
+  handler_->FollowRedirect();
+  EXPECT_EQ(1, resource_controller_.num_resume_calls());
+
+  url_loader_client_.ClearHasReceivedRedirect();
+  // Redirect once more.
+  defer = false;
+  redirect_info.status_code = 302;
+  ASSERT_TRUE(
+      handler_->OnRequestRedirected(redirect_info, response.get(), &defer));
+  ASSERT_TRUE(defer);
+
+  ASSERT_FALSE(url_loader_client_.has_received_response());
+  ASSERT_FALSE(url_loader_client_.has_received_redirect());
+  url_loader_client_.RunUntilRedirectReceived();
+
+  ASSERT_FALSE(url_loader_client_.has_received_response());
+  ASSERT_TRUE(url_loader_client_.has_received_redirect());
+  EXPECT_EQ(302, url_loader_client_.redirect_info().status_code);
+
+  EXPECT_EQ(1, resource_controller_.num_resume_calls());
+  handler_->FollowRedirect();
+  EXPECT_EQ(2, resource_controller_.num_resume_calls());
+
+  // Give the final response.
+  defer = false;
+  ASSERT_TRUE(handler_->OnResponseStarted(response.get(), &defer));
+  ASSERT_FALSE(defer);
+
+  net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK);
+  handler_->OnResponseCompleted(status, &defer);
+  ASSERT_FALSE(defer);
+
+  ASSERT_FALSE(url_loader_client_.has_received_completion());
+  url_loader_client_.RunUntilComplete();
+
+  ASSERT_TRUE(url_loader_client_.has_received_response());
+  ASSERT_TRUE(url_loader_client_.has_received_completion());
+  EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code);
+}
+
+TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
+       MalformedFollowRedirectRequest) {
+  handler_->FollowRedirect();
+
+  EXPECT_TRUE(handler_->has_received_bad_message());
+  EXPECT_EQ(0, resource_controller_.num_resume_calls());
+}
+
 // Typically ResourceHandler methods are called in this order.
 TEST_P(
     MojoAsyncResourceHandlerWithAllocationSizeTest,
     OnWillStartThenOnResponseStartedThenOnWillReadThenOnReadCompletedThenOnResponseCompleted) {
   rdh_delegate_.set_num_on_response_started_calls_expectation(1);
   bool defer = false;
 
   ASSERT_TRUE(handler_->OnWillStart(request_->url(), &defer));
   ASSERT_FALSE(defer);
   scoped_refptr<ResourceResponse> response = new ResourceResponse();
@@ skipping 104 matching lines @@
     }
   }
   EXPECT_EQ("B", body);
 }
 
 INSTANTIATE_TEST_CASE_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
                         MojoAsyncResourceHandlerWithAllocationSizeTest,
                         ::testing::Values(8, 32 * 2014));
 }  // namespace
 }  // namespace content