[2/3 chromium] Support redirect option of Request and "opaqueredirect" response type.

content/browser/loader/resource_dispatcher_host_unittest.cc

 // Copyright (c) 2012 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 <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 928 matching lines @@
 
   // Generates a request using the given filter and resource type.
   void MakeTestRequestWithResourceType(ResourceMessageFilter* filter,
                                        int render_view_id,
                                        int request_id,
                                        const GURL& url,
                                        ResourceType type);
 
   void MakeWebContentsAssociatedTestRequest(int request_id, const GURL& url);
 
+  void MakeTestFetchRequestWithRedirectMode(
+      int render_view_id,
+      int request_id,
+      const GURL& url,
+      FetchRedirectMode fetch_redirect_mode);
+
   void CancelRequest(int request_id);
   void RendererCancelRequest(int request_id) {
     ResourceMessageFilter* old_filter = SetFilter(filter_.get());
     host_.OnCancelRequest(request_id);
     SetFilter(old_filter);
   }
 
   void CompleteStartRequest(int request_id);
   void CompleteStartRequest(ResourceMessageFilter* filter, int request_id);
 
@@ skipping 106 matching lines @@
   ResourceHostMsg_Request request =
       CreateResourceRequest("GET", RESOURCE_TYPE_SUB_RESOURCE, url);
   request.origin_pid = web_contents_->GetRenderProcessHost()->GetID();
   request.render_frame_id = web_contents_->GetMainFrame()->GetRoutingID();
   ResourceHostMsg_RequestResource msg(web_contents_->GetRoutingID(), request_id,
                                       request);
   host_.OnMessageReceived(msg, web_contents_filter_.get());
   KickOffRequest();
 }
 
+void ResourceDispatcherHostTest::MakeTestFetchRequestWithRedirectMode(
+    int render_view_id,
+    int request_id,
+    const GURL& url,
+    FetchRedirectMode fetch_redirect_mode) {
+  ResourceHostMsg_Request request =
+      CreateResourceRequest("GET", RESOURCE_TYPE_SUB_RESOURCE, url);
+  request.fetch_redirect_mode = fetch_redirect_mode;
+  ResourceHostMsg_RequestResource msg(render_view_id, request_id, request);
+  host_.OnMessageReceived(msg, filter_.get());
+  KickOffRequest();
+}
+
 void ResourceDispatcherHostTest::CancelRequest(int request_id) {
   host_.CancelRequest(filter_->child_id(), request_id);
 }
 
 void ResourceDispatcherHostTest::CompleteStartRequest(int request_id) {
   CompleteStartRequest(filter_.get(), request_id);
 }
 
 void ResourceDispatcherHostTest::CompleteStartRequest(
     ResourceMessageFilter* filter,
@@ skipping 91 matching lines @@
                              const std::string& reference_data) {
   ASSERT_EQ(5U, messages.size());
   ASSERT_EQ(ResourceMsg_ReceivedRedirect::ID, messages[0].type());
 
   const std::vector<IPC::Message> second_req_msgs =
       std::vector<IPC::Message>(messages.begin() + 1, messages.end());
   CheckSuccessfulRequest(second_req_msgs, reference_data);
 }
 
 void CheckFailedRequest(const std::vector<IPC::Message>& messages,
-                        const std::string& reference_data,
                         int expected_error) {
   ASSERT_LT(0U, messages.size());
   ASSERT_GE(2U, messages.size());
   size_t failure_index = messages.size() - 1;
 
   if (messages.size() == 2) {
     EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type());
   }
 
   CheckRequestCompleteErrorCode(messages[failure_index], expected_error);
@@ skipping 815 matching lines @@
 
   // Check that the first kMaxRequests succeeded.
   for (size_t i = 0; i < kMaxRequests; ++i)
     CheckSuccessfulRequest(msgs[i], net::URLRequestTestJob::test_data_2());
 
   // Check that the subsequent two requests (kMaxRequests + 1) and
   // (kMaxRequests + 2) were failed, since the per-process bound was reached.
   for (int i = 0; i < 2; ++i) {
     // Should have sent a single RequestComplete message.
     int index = kMaxRequests + i;
-    CheckFailedRequest(msgs[index], net::URLRequestTestJob::test_data_2(),
-                       net::ERR_INSUFFICIENT_RESOURCES);
+    CheckFailedRequest(msgs[index], net::ERR_INSUFFICIENT_RESOURCES);
   }
 
   // The final 2 requests should have succeeded.
   CheckSuccessfulRequest(msgs[kMaxRequests + 2],
                          net::URLRequestTestJob::test_data_2());
   CheckSuccessfulRequest(msgs[kMaxRequests + 3],
                          net::URLRequestTestJob::test_data_2());
 }
 
 // Test that when too many requests are outstanding for a particular
@@ skipping 45 matching lines @@
   // The processes issued the following requests:
   // #1 issued kMaxRequestsPerProcess that passed + 1 that failed
   // #2 issued 1 request that passed
   // #3 issued 1 request that failed
   ASSERT_EQ((kMaxRequestsPerProcess + 1) + 1 + 1, msgs.size());
 
   for (size_t i = 0; i < kMaxRequestsPerProcess; ++i)
     CheckSuccessfulRequest(msgs[i], net::URLRequestTestJob::test_data_2());
 
   CheckFailedRequest(msgs[kMaxRequestsPerProcess + 0],
-                     net::URLRequestTestJob::test_data_2(),
                      net::ERR_INSUFFICIENT_RESOURCES);
   CheckSuccessfulRequest(msgs[kMaxRequestsPerProcess + 1],
                          net::URLRequestTestJob::test_data_2());
   CheckFailedRequest(msgs[kMaxRequestsPerProcess + 2],
-                     net::URLRequestTestJob::test_data_2(),
                      net::ERR_INSUFFICIENT_RESOURCES);
 }
 
 // Tests that we sniff the mime type for a simple request.
 TEST_F(ResourceDispatcherHostTest, MimeSniffed) {
   std::string raw_headers("HTTP/1.1 200 OK\n\n");
   std::string response_data("<html><title>Test One</title></html>");
   SetResponse(raw_headers, response_data);
 
   HandleScheme("http");
@@ skipping 1217 matching lines @@
   int initial_count = web_contents_observer_->resource_request_redirect_count();
 
   MakeWebContentsAssociatedTestRequest(
       1, net::URLRequestTestJob::test_url_redirect_to_url_2());
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(initial_count + 1,
             web_contents_observer_->resource_request_redirect_count());
 }
 
+// Confirm that the redirect response is handled as an error when the request's
+// redirect mode is "error".
+TEST_F(ResourceDispatcherHostTest, FetchRedirectModeError) {
+  MakeTestFetchRequestWithRedirectMode(
+      0, 1, net::URLRequestTestJob::test_url_redirect_to_url_2(),
+      FETCH_REDIRECT_MODE_ERROR);
+
+  // flush all the pending requests
+  while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
+  base::MessageLoop::current()->RunUntilIdle();
+
+  // sorts out all the messages we saw by request
+  ResourceIPCAccumulator::ClassifiedMessages msgs;
+  accum_.GetClassifiedMessages(&msgs);
+
+  ASSERT_EQ(1U, msgs.size());
+  CheckFailedRequest(msgs[0], net::ERR_ABORTED);
+}
+
+// Confirm that the redirect response is not followed when the request's
+// redirect mode is "manual".
+TEST_F(ResourceDispatcherHostTest, FetchRedirectModeManual) {
+  MakeTestFetchRequestWithRedirectMode(
+      0, 1, net::URLRequestTestJob::test_url_redirect_to_url_2(),
+      FETCH_REDIRECT_MODE_MANUAL);
+
+  // flush all the pending requests
+  while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
+  base::MessageLoop::current()->RunUntilIdle();
+
+  // sorts out all the messages we saw by request
+  ResourceIPCAccumulator::ClassifiedMessages msgs;
+  accum_.GetClassifiedMessages(&msgs);
+
+  ASSERT_EQ(1U, msgs.size());
+  ASSERT_EQ(2U, msgs[0].size());
+  ResourceResponseHead response_head;
+  GetResponseHead(msgs[0], &response_head);
+  ASSERT_TRUE(response_head.headers);
+  ASSERT_EQ(302, response_head.headers->response_code());
+  CheckRequestCompleteErrorCode(msgs[0][1], net::OK);
+}
+
 net::URLRequestJob* TestURLRequestJobFactory::MaybeCreateJobWithProtocolHandler(
       const std::string& scheme,
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const {
   url_request_jobs_created_count_++;
   if (test_fixture_->wait_for_request_create_loop_)
     test_fixture_->wait_for_request_create_loop_->Quit();
   if (test_fixture_->loader_test_request_info_) {
     DCHECK_EQ(test_fixture_->loader_test_request_info_->url, request->url());
     scoped_ptr<LoadInfoTestRequestInfo> info =
@@ skipping 41 matching lines @@
   return nullptr;
 }
 
 net::URLRequestJob* TestURLRequestJobFactory::MaybeInterceptResponse(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) const {
   return nullptr;
 }
 
 }  // namespace content