Add SetUploadDataStream method to URLFetcher.

net/url_request/url_fetcher_core.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_core.h"
 
 #include "base/bind.h"
 #include "base/file_util_proxy.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 320 matching lines @@
   if (network_task_runner_->RunsTasksOnCurrentThread()) {
     CancelURLRequest();
   } else {
     network_task_runner_->PostTask(
         FROM_HERE, base::Bind(&URLFetcherCore::CancelURLRequest, this));
   }
 }
 
 void URLFetcherCore::SetUploadData(const std::string& upload_content_type,
                                    const std::string& upload_content) {
+  scoped_ptr<UploadElementReader> reader(
+      UploadOwnedBytesElementReader::CreateWithString(upload_content));
+  SetUploadDataStream(
+      upload_content_type,
+      make_scoped_ptr(UploadDataStream::CreateWithReader(reader.Pass(), 0)));
+}
+
+void URLFetcherCore::SetUploadDataStream(
+    const std::string& upload_content_type,
+    scoped_ptr<UploadDataStream> upload_content) {
   DCHECK(!is_chunked_upload_);
+  DCHECK(!upload_content_);
+  DCHECK(upload_content_type_.empty());
   upload_content_type_ = upload_content_type;
-  upload_content_ = upload_content;
+  upload_content_ = upload_content.Pass();
 }
 
 void URLFetcherCore::SetChunkedUpload(const std::string& content_type) {
   DCHECK(is_chunked_upload_ ||
          (upload_content_type_.empty() &&
-          upload_content_.empty()));
+          !upload_content_));
   upload_content_type_ = content_type;
-  upload_content_.clear();
+  upload_content_.reset();
   is_chunked_upload_ = true;
 }
 
 void URLFetcherCore::AppendChunkToUpload(const std::string& content,
                                          bool is_last_chunk) {
   DCHECK(delegate_task_runner_);
   DCHECK(network_task_runner_.get());
   network_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&URLFetcherCore::CompleteAddingUploadDataChunk, this, content,
@@ skipping 369 matching lines @@
       break;
 
     case URLFetcher::POST:
     case URLFetcher::PUT:
       DCHECK(!upload_content_type_.empty());
 
       request_->set_method(
           request_type_ == URLFetcher::POST ? "POST" : "PUT");
       extra_request_headers_.SetHeader(HttpRequestHeaders::kContentType,
                                        upload_content_type_);
-      if (!upload_content_.empty()) {
-        scoped_ptr<UploadElementReader> reader(new UploadBytesElementReader(
-            upload_content_.data(), upload_content_.size()));
-        request_->set_upload(make_scoped_ptr(
-            UploadDataStream::CreateWithReader(reader.Pass(), 0)));
-      }
-
+      if (upload_content_)
+        request_->set_upload(upload_content_.Pass());
       current_upload_bytes_ = -1;
       // TODO(kinaba): http://crbug.com/118103. Implement upload callback in the
       //  layer and avoid using timer here.
       upload_progress_checker_timer_.reset(
           new base::RepeatingTimer<URLFetcherCore>());
       upload_progress_checker_timer_->Start(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kUploadProgressTimerInterval),
           this,
           &URLFetcherCore::InformDelegateUploadProgress);
@@ skipping 247 matching lines @@
   OnReadCompleted(request_.get(), bytes_read);
 }
 
 void URLFetcherCore::DisownFile() {
   file_writer_->DisownFile();
 }
 
 void URLFetcherCore::InformDelegateUploadProgress() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   if (request_.get()) {
     int64 current = request_->GetUploadProgress().position();

[hashimoto, 2013/01/15 06:59:28]

nit: How about replacing |current| and |total| with one net::UploadProgress?

[mattm, 2013/01/24 02:35:46]

Tried it out, but I think it just makes things a more verbose.  Also with the
handling of |total| being different for chunked or not it gets a little ugly.

     if (current_upload_bytes_ != current) {
       current_upload_bytes_ = current;
       int64 total = -1;
-      if (!is_chunked_upload_)
-        total = static_cast<int64>(upload_content_.size());
+      if (!is_chunked_upload_) {
+        total = static_cast<int64>(request_->GetUploadProgress().size());
+        // Total may be zero if the UploadDataStream::Init has not been called
+        // yet.  Don't send the upload progress until the size is initialized.
+        if (!total)
+          return;
+      }
       delegate_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(
               &URLFetcherCore::InformDelegateUploadProgressInDelegateThread,
               this, current, total));
     }
   }
 }
 
 void URLFetcherCore::InformDelegateUploadProgressInDelegateThread(
@@ skipping 33 matching lines @@
 }
 
 void URLFetcherCore::InformDelegateDownloadDataInDelegateThread(
     scoped_ptr<std::string> download_data) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchDownloadData(fetcher_, download_data.Pass());
 }
 
 }  // namespace net