net: Add SetUploadStream 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 <stdint.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 65 matching lines @@
     : fetcher_(fetcher),
       original_url_(original_url),
       request_type_(request_type),
       delegate_(d),
       delegate_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       load_flags_(LOAD_NORMAL),
       response_code_(URLFetcher::RESPONSE_CODE_INVALID),
       buffer_(new IOBuffer(kBufferSize)),
       url_request_data_key_(NULL),
       was_fetched_via_proxy_(false),
-      upload_content_set_(false),
       upload_range_offset_(0),
       upload_range_length_(0),
       referrer_policy_(
           URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE),
       is_chunked_upload_(false),
       was_cancelled_(false),
       stop_on_redirect_(false),
       stopped_on_redirect_(false),
       automatically_retry_on_5xx_(true),
       num_retries_on_5xx_(0),
@@ skipping 34 matching lines @@
   } else {
     network_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&URLFetcherCore::CancelURLRequest, this, ERR_ABORTED));
   }
 }
 
 void URLFetcherCore::SetUploadData(const std::string& upload_content_type,
                                    const std::string& upload_content) {
   DCHECK(!is_chunked_upload_);
-  DCHECK(!upload_content_set_);
-  DCHECK(upload_content_.empty());
-  DCHECK(upload_file_path_.empty());
+  DCHECK(!IsUploadDataSet());
   DCHECK(upload_content_type_.empty());
 
   // Empty |upload_content_type| is allowed iff the |upload_content| is empty.
   DCHECK(upload_content.empty() || !upload_content_type.empty());
 
   upload_content_type_ = upload_content_type;
   upload_content_ = upload_content;
-  upload_content_set_ = true;
 }
 
 void URLFetcherCore::SetUploadFilePath(
     const std::string& upload_content_type,
     const base::FilePath& file_path,
     uint64 range_offset,
     uint64 range_length,
     scoped_refptr<base::TaskRunner> file_task_runner) {
   DCHECK(!is_chunked_upload_);
-  DCHECK(!upload_content_set_);
-  DCHECK(upload_content_.empty());
-  DCHECK(upload_file_path_.empty());
+  DCHECK(!IsUploadDataSet());
   DCHECK_EQ(upload_range_offset_, 0ULL);
   DCHECK_EQ(upload_range_length_, 0ULL);
   DCHECK(upload_content_type_.empty());
   DCHECK(!upload_content_type.empty());
 
   upload_content_type_ = upload_content_type;
   upload_file_path_ = file_path;
   upload_range_offset_ = range_offset;
   upload_range_length_ = range_length;
   upload_file_task_runner_ = file_task_runner;
-  upload_content_set_ = true;
+}
+
+void URLFetcherCore::SetUploadStreamFactory(
+    const std::string& upload_content_type,
+    const URLFetcher::CreateUploadStreamCallback& factory) {
+  DCHECK(!is_chunked_upload_);
+  DCHECK(!IsUploadDataSet());
+  DCHECK(upload_content_type_.empty());
+
+  upload_content_type_ = upload_content_type;
+  upload_stream_factory_ = factory;
 }
 
 void URLFetcherCore::SetChunkedUpload(const std::string& content_type) {
   DCHECK(is_chunked_upload_ ||
-         (upload_content_type_.empty() &&
-          upload_content_.empty()));
+         (upload_content_type_.empty() && upload_content_.empty() &&
+          upload_file_path_.empty() && upload_stream_factory_.is_null()));
 
   // Empty |content_type| is not allowed here, because it is impossible
   // to ensure non-empty upload content as it is not yet supplied.
   DCHECK(!content_type.empty());
 
   upload_content_type_ = content_type;
   upload_content_.clear();
   is_chunked_upload_ = true;
 }
 
@@ skipping 384 matching lines @@
   }
 
   switch (request_type_) {
     case URLFetcher::GET:
       break;
 
     case URLFetcher::POST:
     case URLFetcher::PUT:
     case URLFetcher::PATCH:
       // Upload content must be set.
-      DCHECK(is_chunked_upload_ || upload_content_set_);
+      DCHECK(is_chunked_upload_ || IsUploadDataSet());
 
       request_->set_method(
           request_type_ == URLFetcher::POST ? "POST" :
           request_type_ == URLFetcher::PUT ? "PUT" : "PATCH");
-      if (!upload_content_type_.empty()) {
-        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(
             ElementsUploadDataStream::CreateWithReader(reader.Pass(), 0));
       } else if (!upload_file_path_.empty()) {
         scoped_ptr<UploadElementReader> reader(
             new UploadFileElementReader(upload_file_task_runner_.get(),
                                         upload_file_path_,
                                         upload_range_offset_,
                                         upload_range_length_,
                                         base::Time()));
         request_->set_upload(
             ElementsUploadDataStream::CreateWithReader(reader.Pass(), 0));
+      } else if (!upload_stream_factory_.is_null()) {
+        scoped_ptr<UploadDataStream> stream = upload_stream_factory_.Run();
+        DCHECK(stream);
+        request_->set_upload(stream.Pass());
       }
-
+      if (!upload_content_type_.empty()) {
+        extra_request_headers_.SetHeader(HttpRequestHeaders::kContentType,
+                                         upload_content_type_);
+      }
       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 330 matching lines @@
           this, current_response_bytes_, total_response_bytes_));
 }
 
 void URLFetcherCore::InformDelegateDownloadProgressInDelegateThread(
     int64 current, int64 total) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchDownloadProgress(fetcher_, current, total);
 }
 
+bool URLFetcherCore::IsUploadDataSet() const {
+  return !(upload_content_.empty() && upload_file_path_.empty() &&
+           upload_stream_factory_.is_null());
+}
+
 }  // namespace net