Fix UrlFetcher upload retry handling.

net/url_request/url_fetcher_impl_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 "net/url_request/url_fetcher_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop_proxy.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "crypto/nss_util.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/network_change_notifier.h"
-#include "net/base/upload_data_stream.h"
-#include "net/base/upload_file_element_reader.h"
 #include "net/http/http_response_headers.h"
 #include "net/test/test_server.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "net/url_request/url_request_throttler_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(USE_NSS) || defined(OS_IOS)
 #include "net/ocsp/nss_ocsp.h"
@@ skipping 200 matching lines @@
 // Version of URLFetcherTest that does a POST instead
 class URLFetcherPostTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
   virtual void CreateFetcher(const GURL& url) OVERRIDE;
 
   // URLFetcherDelegate:
   virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
 };
 
-// Version of URLFetcherTest that does a POST of a file using
-// SetUploadDataStream
-class URLFetcherPostFileTest : public URLFetcherTest {
+// Version of URLFetcherTest that does a POST and retries it.
+class URLFetcherPostRetryTest : public URLFetcherMockDnsTest {
  public:
-  URLFetcherPostFileTest();
-
-  // URLFetcherTest:
+  // URLFetcherMockDnsTest:
   virtual void CreateFetcher(const GURL& url) OVERRIDE;
 
   // URLFetcherDelegate:
   virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
-
- private:
-  base::FilePath path_;
 };
 
 // Version of URLFetcherTest that does a POST instead with empty upload body
 class URLFetcherEmptyPostTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
   virtual void CreateFetcher(const GURL& url) OVERRIDE;
 
   // URLFetcherDelegate:
   virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
@@ skipping 249 matching lines @@
   fetcher_->Start();
 }
 
 void URLFetcherPostTest::OnURLFetchComplete(const URLFetcher* source) {
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_EQ(std::string("bobsyeruncle"), data);
   URLFetcherTest::OnURLFetchComplete(source);
 }
 
-URLFetcherPostFileTest::URLFetcherPostFileTest() {
-  PathService::Get(base::DIR_SOURCE_ROOT, &path_);
-  path_ = path_.Append(FILE_PATH_LITERAL("net"));
-  path_ = path_.Append(FILE_PATH_LITERAL("data"));
-  path_ = path_.Append(FILE_PATH_LITERAL("url_request_unittest"));
-  path_ = path_.Append(FILE_PATH_LITERAL("BullRunSpeech.txt"));
-}
-
-void URLFetcherPostFileTest::CreateFetcher(const GURL& url) {
+void URLFetcherPostRetryTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::POST, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy(), request_context()));
-  scoped_ptr<UploadElementReader> reader(new UploadFileElementReader(
-        base::MessageLoopProxy::current(), path_, 0, kuint64max, base::Time()));
-  fetcher_->SetUploadDataStream(
-      "application/x-www-form-urlencoded",
-       make_scoped_ptr(UploadDataStream::CreateWithReader(reader.Pass(), 0)));
-  fetcher_->Start();
+  fetcher_->SetUploadData("application/x-www-form-urlencoded",
+                          "bobsyeruncle");
 }
 
-void URLFetcherPostFileTest::OnURLFetchComplete(const URLFetcher* source) {
-  int64 size = 0;
-  ASSERT_EQ(true, file_util::GetFileSize(path_, &size));
-  scoped_array<char> expected(new char[size]);
-  ASSERT_EQ(size, file_util::ReadFile(path_, expected.get(), size));
-
+void URLFetcherPostRetryTest::OnURLFetchComplete(const URLFetcher* source) {
+  io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
-  EXPECT_EQ(std::string(&expected[0], size), data);
-  URLFetcherTest::OnURLFetchComplete(source);
+  EXPECT_EQ(std::string("bobsyeruncle"), data);
+  completed_fetcher_.reset(fetcher_);
 }
 
 void URLFetcherEmptyPostTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::POST, this);
   fetcher_->SetRequestContext(new TestURLRequestContextGetter(
       io_message_loop_proxy()));
   fetcher_->SetUploadData("text/plain", "");
   fetcher_->Start();
 }
 
@@ skipping 474 matching lines @@
   ASSERT_TRUE(completed_fetcher_);
 
   // This time the request succeeded.
   EXPECT_EQ(OK, completed_fetcher_->GetStatus().error());
   EXPECT_EQ(200, completed_fetcher_->GetResponseCode());
 }
 
 TEST_F(URLFetcherPostTest, Basic) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
+                         FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   CreateFetcher(test_server.GetURL("echo"));
   MessageLoop::current()->Run();
 }
 
-TEST_F(URLFetcherPostFileTest, Basic) {
-  TestServer test_server(TestServer::TYPE_HTTP,
-                         TestServer::kLocalhost,
-                         base::FilePath(kDocRoot));
-  ASSERT_TRUE(test_server.Start());
+TEST_F(URLFetcherPostRetryTest, RetryOnNetworkChangedWithUploadData) {
+  EXPECT_EQ(0, GetNumFetcherCores());
+  EXPECT_FALSE(resolver_.has_pending_requests());
 
-  CreateFetcher(test_server.GetURL("echo"));
+  GURL url = GURL(
+        base::StringPrintf("http://example.com:%d/echo",
+        test_server_->host_port_pair().port()));
+
+  // This posts a task to start the fetcher.
+  CreateFetcher(url);
+  fetcher_->SetAutomaticallyRetryOnNetworkChanges(3);
+  fetcher_->Start();
+  EXPECT_EQ(0, GetNumFetcherCores());
+  MessageLoop::current()->RunUntilIdle();
+
+  // The fetcher is now running, but is pending the host resolve.
+  EXPECT_EQ(1, GetNumFetcherCores());
+  EXPECT_TRUE(resolver_.has_pending_requests());
+  ASSERT_FALSE(completed_fetcher_);
+
+  // Make it fail 3 times.
+  for (int i = 0; i < 3; ++i) {
+    // A network change notification aborts the connect job.
+    NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
+    MessageLoop::current()->RunUntilIdle();
+
+    // But the fetcher retries automatically.
+    EXPECT_EQ(1, GetNumFetcherCores());
+    EXPECT_TRUE(resolver_.has_pending_requests());
+    ASSERT_FALSE(completed_fetcher_);
+  }
+
+  // Now let it succeed by resolving the pending request.
+  resolver_.ResolveAllPending();
   MessageLoop::current()->Run();
+
+  // URLFetcherMockDnsTest::OnURLFetchComplete() will quit the loop.
+  EXPECT_EQ(0, GetNumFetcherCores());
+  EXPECT_FALSE(resolver_.has_pending_requests());
+  ASSERT_TRUE(completed_fetcher_);
+
+  // This time the request succeeded.
+  EXPECT_EQ(OK, completed_fetcher_->GetStatus().error());
+  EXPECT_EQ(200, completed_fetcher_->GetResponseCode());
 }
 
 TEST_F(URLFetcherEmptyPostTest, Basic) {
   TestServer test_server(TestServer::TYPE_HTTP,
                          TestServer::kLocalhost,
                          base::FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   CreateFetcher(test_server.GetURL("echo"));
   MessageLoop::current()->Run();
@@ skipping 402 matching lines @@
   MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
   MessageLoop::current()->RunUntilIdle();
   ASSERT_FALSE(file_util::PathExists(file_path_))
       << file_path_.value() << " not removed.";
 }
 
 }  // namespace
 
 }  // namespace net