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 835 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) {
+  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());

[mmenke, 2016/11/10 21:42:41]

Check that there was only one received redirect call?

[yhirano, 2016/11/11 09:47:04]

Done in TestResourceClient.

+  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());

[mmenke, 2016/11/10 21:42:41]

Let's continue this request to completion.  Otherwise, we don't know if the
async resource handler's state machine continues to work after following the
redirect.

[yhirano, 2016/11/11 09:47:04]

Done.

+}
+
 // 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