net: Change argument of URLRequest::set_upload from UploadData to UploadDataStream

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 21 matching lines @@
 #include "net/base/load_flags.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/net_module.h"
 #include "net/base/net_util.h"
 #include "net/base/ssl_connection_status_flags.h"
 #include "net/base/test_data_directory.h"
 #include "net/base/test_root_certs.h"
-#include "net/base/upload_data.h"
+#include "net/base/upload_bytes_element_reader.h"
+#include "net/base/upload_data_stream.h"
+#include "net/base/upload_file_element_reader.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_store_test_helpers.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/ftp/ftp_network_layer.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/ocsp/nss_ocsp.h"
@@ skipping 50 matching lines @@
     srand(seed);
   }
 
   for (size_t i = 0; i < len; i++) {
     buffer[i] = static_cast<char>(rand());
     if (!buffer[i])
       buffer[i] = 'g';
   }
 }
 
-scoped_refptr<UploadData> CreateSimpleUploadData(const char* data) {
-  scoped_refptr<UploadData> upload(new UploadData);
-  upload->AppendBytes(data, strlen(data));
-  return upload;
+UploadDataStream* CreateSimpleUploadData(const char* data) {
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(new UploadBytesElementReader(data, strlen(data)));
+  return new UploadDataStream(&element_readers, 0);
 }
 
 // Verify that the SSLInfo of a successful SSL connection has valid values.
 void CheckSSLInfo(const SSLInfo& ssl_info) {
   // Allow ChromeFrame fake SSLInfo to get through.
   if (ssl_info.cert.get() &&
       ssl_info.cert.get()->issuer().GetDisplayName() == "Chrome Internal") {
     // -1 means unknown.
     EXPECT_EQ(ssl_info.security_bits, -1);
     return;
@@ skipping 1775 matching lines @@
   // |request_method| == |redirect_method|.
   void HTTPRedirectMethodTest(const GURL& redirect_url,
                               const std::string& request_method,
                               const std::string& redirect_method,
                               bool include_data) {
     static const char kData[] = "hello world";
     TestDelegate d;
     URLRequest req(redirect_url, &d, &default_context_);
     req.set_method(request_method);
     if (include_data) {
-      req.set_upload(CreateSimpleUploadData(kData).get());
+      req.set_upload(CreateSimpleUploadData(kData));
       HttpRequestHeaders headers;
       headers.SetHeader(HttpRequestHeaders::kContentLength,
                         base::UintToString(arraysize(kData) - 1));
       req.SetExtraRequestHeaders(headers);
     }
     req.Start();
     MessageLoop::current()->Run();
     EXPECT_EQ(redirect_method, req.method());
     EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status());
     EXPECT_EQ(OK, req.status().error());
@@ skipping 24 matching lines @@
           marker = 'a';
       }
     }
     uploadBytes[kMsgSize] = '\0';
 
     for (int i = 0; i < kIterations; ++i) {
       TestDelegate d;
       URLRequest r(test_server_.GetURL("echo"), &d, &default_context_);
       r.set_method(method.c_str());
 
-      scoped_refptr<UploadData> upload_data(new UploadData());
-      upload_data->AppendBytes(uploadBytes, kMsgSize);
-      r.set_upload(upload_data);
+      ScopedVector<UploadElementReader> element_readers;
+      element_readers.push_back(new UploadBytesElementReader(
+          uploadBytes, kMsgSize));
+      r.set_upload(new UploadDataStream(&element_readers, 0));

[mmenke, 2012/12/11 18:53:21]

Looks to me like you can just use CreateSimpleUploadData(uploadBytes) here.

[hashimoto, 2012/12/12 10:29:07]

Done.

 
       r.Start();
       EXPECT_TRUE(r.is_pending());
 
       MessageLoop::current()->Run();
 
       ASSERT_EQ(1, d.response_started_count())
           << "request failed: " << r.status().status()
           << ", os error: " << r.status().error();
 
@@ skipping 345 matching lines @@
   network_delegate.set_redirect_url(redirect_url);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     GURL original_url(test_server_.GetURL("empty.html"));
     URLRequest r(original_url, &d, &context);
     r.set_method("POST");
-    r.set_upload(CreateSimpleUploadData(kData).get());
+    r.set_upload(CreateSimpleUploadData(kData));
     HttpRequestHeaders headers;
     headers.SetHeader(HttpRequestHeaders::kContentLength,
                       base::UintToString(arraysize(kData) - 1));
     r.SetExtraRequestHeaders(headers);
     r.Start();
     MessageLoop::current()->Run();
 
     EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
     EXPECT_EQ(0, r.status().error());
     EXPECT_EQ(redirect_url, r.url());
@@ skipping 785 matching lines @@
 
   TestDelegate d;
   {
     URLRequest r(test_server_.GetURL("echo"), &d, &default_context_);
     r.set_method("POST");
 
     FilePath dir;
     PathService::Get(base::DIR_EXE, &dir);
     file_util::SetCurrentDirectory(dir);
 
-    scoped_refptr<UploadData> upload_data(new UploadData);
+    ScopedVector<UploadElementReader> element_readers;
 
     FilePath path;
     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("with-headers.html"));
-    upload_data->AppendFileRange(path, 0, kuint64max, base::Time());
+    element_readers.push_back(new UploadFileElementReader(
+        path, 0, kuint64max, base::Time()));
 
     // This file should just be ignored in the upload stream.
-    upload_data->AppendFileRange(
+    element_readers.push_back(new UploadFileElementReader(
         FilePath(FILE_PATH_LITERAL(
             "c:\\path\\to\\non\\existant\\file.randomness.12345")),
-        0, kuint64max, base::Time());
-    r.set_upload(upload_data);
+        0, kuint64max, base::Time()));
+    r.set_upload(new UploadDataStream(&element_readers, 0));
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     int64 size = 0;
     ASSERT_EQ(true, file_util::GetFileSize(path, &size));
     scoped_array<char> buf(new char[size]);
 
@@ skipping 513 matching lines @@
 }
 
 TEST_F(URLRequestTestHTTP, InterceptPost302RedirectGet) {
   ASSERT_TRUE(test_server_.Start());
 
   const char kData[] = "hello world";
 
   TestDelegate d;
   URLRequest req(test_server_.GetURL("empty.html"), &d, &default_context_);
   req.set_method("POST");
-  req.set_upload(CreateSimpleUploadData(kData).get());
+  req.set_upload(CreateSimpleUploadData(kData));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kContentLength,
                     base::UintToString(arraysize(kData) - 1));
   req.SetExtraRequestHeaders(headers);
 
   URLRequestRedirectJob* job = new URLRequestRedirectJob(
       &req, default_context_.network_delegate(), test_server_.GetURL("echo"),
       URLRequestRedirectJob::REDIRECT_302_FOUND);
   AddTestInterceptor()->set_main_intercept_job(job);
 
   req.Start();
   MessageLoop::current()->Run();
   EXPECT_EQ("GET", req.method());
 }
 
 TEST_F(URLRequestTestHTTP, InterceptPost307RedirectPost) {
   ASSERT_TRUE(test_server_.Start());
 
   const char kData[] = "hello world";
 
   TestDelegate d;
   URLRequest req(test_server_.GetURL("empty.html"), &d, &default_context_);
   req.set_method("POST");
-  req.set_upload(CreateSimpleUploadData(kData).get());
+  req.set_upload(CreateSimpleUploadData(kData));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kContentLength,
                     base::UintToString(arraysize(kData) - 1));
   req.SetExtraRequestHeaders(headers);
 
   URLRequestRedirectJob* job = new URLRequestRedirectJob(
       &req, default_context_.network_delegate(), test_server_.GetURL("echo"),
       URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT);
   AddTestInterceptor()->set_main_intercept_job(job);
 
@@ skipping 499 matching lines @@
   TestDelegate d;
   // Navigating to https://www.somewhere.com instead of https://127.0.0.1 will
   // cause a certificate error.  Ignore the error.
   d.set_allow_certificate_errors(true);
 
   URLRequest req(GURL(StringPrintf("http://www.somewhere.com:%d/echo",
                                    test_server.host_port_pair().port())),
                  &d,
                  &context);
   req.set_method("POST");
-  req.set_upload(CreateSimpleUploadData(kData).get());
+  req.set_upload(CreateSimpleUploadData(kData));
 
   req.Start();
   MessageLoop::current()->Run();
 
   EXPECT_EQ("https", req.url().scheme());
   EXPECT_EQ("POST", req.method());
   EXPECT_EQ(kData, d.data_received());
 }
 
 TEST_F(HTTPSRequestTest, SSLv3Fallback) {
@@ skipping 930 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