Release the cache entry on deferred redirect.

net/url_request/url_request_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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shlobj.h>
 #endif
@@ skipping 4185 matching lines @@
   URLRequest req(
       test_server_.GetURL("echoheader?Referer"), &d, &default_context_);
   req.SetReferrer("http://foo.com/test#fragment");
   req.SetReferrer("");
   req.Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(std::string("None"), d.data_received());
 }
 
+TEST_F(URLRequestTestHTTP, CachedRedirect) {

[rvargas (doing something else), 2013/09/17 19:53:25]

I would have gone for an URLRequestJob unit test... the URLRequest behavior is
not changing, and there's no need to start a server

[davidben, 2013/09/17 22:16:04]

Done.

+  ASSERT_TRUE(test_server_.Start());
+
+  // Write to the cache.
+  {
+    TestDelegate d;
+    GURL test_url(test_server_.GetURL("files/redirect-test.html"));
+    URLRequest req(test_url, &d, &default_context_);
+
+    req.Start();
+    base::RunLoop().Run();
+
+    EXPECT_EQ(1, d.received_redirect_count());
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status());
+  }
+
+  // Stop at the redirect and make sure it was read from cache.
+  {
+    TestDelegate d;
+    d.set_quit_on_redirect(true);
+    GURL test_url(test_server_.GetURL("files/redirect-test.html"));
+    URLRequest req(test_url, &d, &default_context_);
+
+    req.Start();
+    base::RunLoop().Run();
+
+    EXPECT_EQ(1, d.received_redirect_count());
+    EXPECT_TRUE(req.was_cached());
+  }
+}
+
 TEST_F(URLRequestTestHTTP, CancelRedirect) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
     d.set_cancel_in_received_redirect(true);
     URLRequest req(
         test_server_.GetURL("files/redirect-test.html"), &d, &default_context_);
     req.Start();
     base::RunLoop().Run();
@@ skipping 74 matching lines @@
     path = path.Append(FILE_PATH_LITERAL("data"));
     path = path.Append(FILE_PATH_LITERAL("url_request_unittest"));
     path = path.Append(FILE_PATH_LITERAL("with-headers.html"));
 
     std::string contents;
     EXPECT_TRUE(base::ReadFileToString(path, &contents));
     EXPECT_EQ(contents, d.data_received());
   }
 }
 
+// Tests that a deferred redirect releases its lock on the cache.
+TEST_F(URLRequestTestHTTP, DeferredRedirect_ReleaseCacheEntry) {
+  ASSERT_TRUE(test_server_.Start());
+
+  // First test the cold cache case.
+  {
+    // First, fire a request and (indefinitely) pause its redirect.
+    TestDelegate pausing_delegate;
+    pausing_delegate.set_quit_on_redirect(true);
+    GURL test_url(test_server_.GetURL("files/redirect-test.html"));
+    URLRequest paused_req(test_url, &pausing_delegate, &default_context_);
+    paused_req.Start();
+    base::RunLoop().Run();
+    EXPECT_EQ(1, pausing_delegate.received_redirect_count());
+
+    // This should test the cold cache case.
+    EXPECT_FALSE(paused_req.was_cached());
+
+    // Now, fire a second at the same. It should not get stuck.
+    TestDelegate delegate;
+    URLRequest req(test_url, &delegate, &default_context_);
+    req.Start();
+    base::RunLoop().Run();
+    EXPECT_EQ(1, delegate.response_started_count());
+    EXPECT_FALSE(delegate.received_data_before_response());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status());
+  }
+
+  // Repeat, now with the cache warmed from the last run.
+  {
+    // First, fire a request and (indefinitely) pause its redirect.
+    TestDelegate pausing_delegate;
+    pausing_delegate.set_quit_on_redirect(true);
+    GURL test_url(test_server_.GetURL("files/redirect-test.html"));
+    URLRequest paused_req(test_url, &pausing_delegate, &default_context_);
+    paused_req.Start();
+    base::RunLoop().Run();
+    EXPECT_EQ(1, pausing_delegate.received_redirect_count());
+
+    // This should test the cold cache case.
+    EXPECT_TRUE(paused_req.was_cached());
+
+    // Now, fire a second at the same. It should not get stuck.
+    TestDelegate delegate;
+    URLRequest req(test_url, &delegate, &default_context_);
+    req.Start();
+    base::RunLoop().Run();
+    EXPECT_EQ(1, delegate.response_started_count());
+    EXPECT_FALSE(delegate.received_data_before_response());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status());
+  }
+}
+
 TEST_F(URLRequestTestHTTP, CancelDeferredRedirect) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
     d.set_quit_on_redirect(true);
     URLRequest req(
         test_server_.GetURL("files/redirect-test.html"), &d, &default_context_);
     req.Start();
     base::RunLoop().Run();
@@ skipping 1976 matching lines @@
 
     EXPECT_FALSE(r.is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
     EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
   }
 }
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
 }  // namespace net