net: Add SetUploadStream method to URLFetcher.

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 <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/strings/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/elements_upload_data_stream.h"
 #include "net/base/network_change_notifier.h"
+#include "net/base/upload_bytes_element_reader.h"
+#include "net/base/upload_element_reader.h"
+#include "net/base/upload_file_element_reader.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_response_headers.h"
 #include "net/test/spawned_test_server/spawned_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"
 #endif
 
 namespace net {
 
 using base::Time;
 using base::TimeDelta;
 
 // TODO(eroman): Add a regression test for http://crbug.com/40505.
 
 namespace {
 
 // TODO(akalin): Move all the test data to somewhere under net/.
 const base::FilePath::CharType kDocRoot[] =
     FILE_PATH_LITERAL("net/data/url_fetcher_impl_unittest");
 const char kTestServerFilePrefix[] = "files/";
 
+scoped_ptr<UploadDataStream> CreateUploadStream(size_t* call_count) {
+  ++*call_count;
+  const std::string str("bobsyeruncle\n");
+  std::vector<char> buffer(str.begin(), str.end());
+  return ElementsUploadDataStream::CreateWithReader(
+      scoped_ptr<UploadElementReader>(
+          new UploadOwnedBytesElementReader(&buffer)),
+      0);
+}
+
 class ThrottlingTestURLRequestContext : public TestURLRequestContext {
  public:
   ThrottlingTestURLRequestContext() : TestURLRequestContext(true) {
     set_throttler_manager(&throttler_manager_);
     Init();
     DCHECK(throttler_manager() != NULL);
   }
 
  private:
   URLRequestThrottlerManager throttler_manager_;
@@ skipping 16 matching lines @@
   ~ThrottlingTestURLRequestContextGetter() override {}
 
   TestURLRequestContext* const context_;
 };
 
 }  // namespace
 
 class URLFetcherTest : public testing::Test,
                        public URLFetcherDelegate {
  public:
-  URLFetcherTest() : fetcher_(NULL) {}
+  URLFetcherTest() : fetcher_(NULL), expected_status_code_(200) {}
 
   static int GetNumFetcherCores() {
     return URLFetcherImpl::GetNumFetcherCores();
   }
 
   // Creates a URLFetcher, using the program's main thread to do IO.
   virtual void CreateFetcher(const GURL& url);
 
   // URLFetcherDelegate:
   // Subclasses that override this should either call this function or
@@ skipping 33 matching lines @@
   }
 
   // URLFetcher is designed to run on the main UI thread, but in our tests
   // we assume that the current thread is the IO thread where the URLFetcher
   // dispatches its requests to.  When we wish to simulate being used from
   // a UI thread, we dispatch a worker thread to do so.
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
 
   URLFetcherImpl* fetcher_;
   scoped_ptr<TestURLRequestContext> context_;
+  int expected_status_code_;
 };
 
 // A test fixture that uses a MockHostResolver, so that name resolutions can
 // be manipulated by the tests to keep connections in the resolving state.
 class URLFetcherMockDnsTest : public URLFetcherTest {
  public:
   // testing::Test:
   void SetUp() override;
 
   // URLFetcherTest:
@@ skipping 11 matching lines @@
 
 void URLFetcherTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy().get(), request_context()));
   fetcher_->Start();
 }
 
 void URLFetcherTest::OnURLFetchComplete(const URLFetcher* source) {
   EXPECT_TRUE(source->GetStatus().is_success());
-  EXPECT_EQ(200, source->GetResponseCode());  // HTTP OK
+  EXPECT_EQ(expected_status_code_, source->GetResponseCode());  // HTTP OK
 
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_FALSE(data.empty());
 
   CleanupAfterFetchComplete();
 }
 
 void URLFetcherTest::CleanupAfterFetchComplete() {
   delete fetcher_;  // Have to delete this here and not in the destructor,
@@ skipping 72 matching lines @@
 
   // URLFetcherDelegate:
   void OnURLFetchComplete(const URLFetcher* source) override;
 
  private:
   base::FilePath path_;
   uint64 range_offset_;
   uint64 range_length_;
 };
 
+class URLFetcherPostStreamTest : public URLFetcherTest {
+ public:
+  URLFetcherPostStreamTest() : create_stream_count_(0) {}
+
+  // URLFetcherTest:
+  void CreateFetcher(const GURL& url) override;
+
+  // URLFetcherDelegate:
+  void OnURLFetchComplete(const URLFetcher* source) override;
+
+ protected:
+  // Count of calling CreateStream.
+  size_t create_stream_count_;
+};
+
 // Version of URLFetcherTest that does a POST instead with empty upload body
 class URLFetcherEmptyPostTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
   void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
   void OnURLFetchComplete(const URLFetcher* source) override;
 };
 
@@ skipping 292 matching lines @@
   ASSERT_LE(range_offset_, expected.size());
   uint64 expected_size =
       std::min(range_length_, expected.size() - range_offset_);
 
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_EQ(expected.substr(range_offset_, expected_size), data);
   URLFetcherTest::OnURLFetchComplete(source);
 }
 
+void URLFetcherPostStreamTest::CreateFetcher(const GURL& url) {
+  fetcher_ = new URLFetcherImpl(url, URLFetcher::POST, this);
+  fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
+      io_message_loop_proxy().get(), request_context()));
+  fetcher_->SetUploadStreamFactory(
+      "text/plain", base::Bind(&CreateUploadStream, &create_stream_count_));
+  fetcher_->SetAutomaticallyRetryOn5xx(true);
+  fetcher_->SetMaxRetriesOn5xx(1);
+  fetcher_->Start();
+}
+
+void URLFetcherPostStreamTest::OnURLFetchComplete(const URLFetcher* source) {
+  std::string data;
+  EXPECT_TRUE(source->GetResponseAsString(&data));
+  EXPECT_EQ(std::string("bobsyeruncle\n"), data);

[mmenke, 2015/01/15 15:38:54]

nit:  set::string isn't needed here.

[hirono, 2015/01/16 03:55:58]

Done.

+  URLFetcherTest::OnURLFetchComplete(source);
+}
+
 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", std::string());
   fetcher_->Start();
 }
 
 void URLFetcherEmptyPostTest::OnURLFetchComplete(const URLFetcher* source) {
   EXPECT_TRUE(source->GetStatus().is_success());
@@ skipping 494 matching lines @@
                                 SpawnedTestServer::kLocalhost,
                                 base::FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   SetUploadRange(30, 100);
 
   CreateFetcher(test_server.GetURL("echo"));
   base::MessageLoop::current()->Run();
 }
 
+TEST_F(URLFetcherPostStreamTest, Basic) {
+  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
+                                SpawnedTestServer::kLocalhost,
+                                base::FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  CreateFetcher(test_server.GetURL("echo"));
+  base::MessageLoop::current()->Run();
+  ASSERT_EQ(1u, create_stream_count_);
+}
+
+TEST_F(URLFetcherPostStreamTest, Retry) {
+  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
+                                SpawnedTestServer::kLocalhost,
+                                base::FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+  expected_status_code_ = 500;
+  CreateFetcher(test_server.GetURL("echo?status=500"));
+  base::MessageLoop::current()->Run();
+  ASSERT_EQ(2u, create_stream_count_);
+}
+
 TEST_F(URLFetcherEmptyPostTest, Basic) {
   SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
                                 SpawnedTestServer::kLocalhost,
                                 base::FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   CreateFetcher(test_server.GetURL("echo"));
   base::MessageLoop::current()->Run();
 }
 
@@ skipping 436 matching lines @@
 
     base::MessageLoop::current()->RunUntilIdle();
     ASSERT_EQ(kTake[i], base::PathExists(file_path_)) <<
         "FilePath: " << file_path_.value();
   }
 }
 
 }  // namespace
 
 }  // namespace net