Support range uploading of a file.

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/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 60 matching lines @@
       delegate_(d),
       delegate_task_runner_(
           base::ThreadTaskRunnerHandle::Get()),
       request_(NULL),
       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),
       is_chunked_upload_(false),
       was_cancelled_(false),
       file_writer_(NULL),
       response_destination_(STRING),
       stop_on_redirect_(false),
       stopped_on_redirect_(false),
       automatically_retry_on_5xx_(true),
       num_retries_on_5xx_(0),
       max_retries_on_5xx_(0),
       num_retries_on_network_changes_(0),
@@ skipping 47 matching lines @@
   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_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::SetChunkedUpload(const std::string& content_type) {
   DCHECK(is_chunked_upload_ ||
          (upload_content_type_.empty() &&
           upload_content_.empty()));
 
   // Empty |content_type| is not allowed here, because it is impossible
@@ skipping 394 matching lines @@
       }
       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)));
       } else if (!upload_file_path_.empty()) {
         scoped_ptr<UploadElementReader> reader(new UploadFileElementReader(
             upload_file_task_runner_,
             upload_file_path_,
-            0, kuint64max, base::Time()));
+            upload_range_offset_,
+            upload_range_length_,
+            base::Time()));
         request_->set_upload(make_scoped_ptr(
             UploadDataStream::CreateWithReader(reader.Pass(), 0)));
       }
 
       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(
@@ skipping 317 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