Introduce ParallelDownloadJob.

content/browser/download/download_item_impl.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.
 
 // File method ordering: Methods in this file are in the same order as
 // in download_item_impl.h, with the following exception: The public
 // interface Start is placed in chronological order with the other
 // (private) routines that together define a DownloadItem's state
 // transitions as the download progresses.  See "Download progression
 // cascade" later in this file.
@@ skipping 22 matching lines @@
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_file.h"
 #include "content/browser/download/download_interrupt_reasons_impl.h"
 #include "content/browser/download/download_item_impl_delegate.h"
+#include "content/browser/download/download_job_factory.h"
+#include "content/browser/download/download_job_impl.h"
 #include "content/browser/download/download_net_log_parameters.h"
 #include "content/browser/download/download_request_handle.h"
 #include "content/browser/download/download_stats.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/download_danger_type.h"
 #include "content/public/browser/download_interrupt_reasons.h"
@@ skipping 177 matching lines @@
 // Constructing for the "Save Page As..." feature:
 DownloadItemImpl::DownloadItemImpl(
     DownloadItemImplDelegate* delegate,
     uint32_t download_id,
     const base::FilePath& path,
     const GURL& url,
     const std::string& mime_type,
     std::unique_ptr<DownloadRequestHandleInterface> request_handle,
     const net::NetLogWithSource& net_log)
     : is_save_package_download_(true),
-      request_handle_(std::move(request_handle)),
       guid_(base::ToUpperASCII(base::GenerateGUID())),
       download_id_(download_id),
       target_path_(path),
       url_chain_(1, url),
       mime_type_(mime_type),
       original_mime_type_(mime_type),
       start_tick_(base::TimeTicks::Now()),
       state_(IN_PROGRESS_INTERNAL),
       start_time_(base::Time::Now()),
       delegate_(delegate),
       current_path_(path),
       net_log_(net_log),
       weak_ptr_factory_(this) {
+  job_ = base::MakeUnique<DownloadJobImpl>(this, std::move(request_handle));
   delegate_->Attach();
   Init(true /* actively downloading */, SRC_SAVE_PAGE_AS);
 }
 
 DownloadItemImpl::~DownloadItemImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Should always have been nuked before now, at worst in
   // DownloadManager shutdown.
   DCHECK(!download_file_.get());
@@ skipping 76 matching lines @@
         base::Bind(&MakeCopyOfDownloadFile, download_file_.get()), callback);
   } else {
     callback.Run(current_path_);
   }
 }
 
 void DownloadItemImpl::Pause() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Ignore irrelevant states.
-  if (is_paused_)
+  if (IsPaused())
     return;
 
   switch (state_) {
     case CANCELLED_INTERNAL:
     case COMPLETE_INTERNAL:
     case COMPLETING_INTERNAL:
     case INITIAL_INTERNAL:
     case INTERRUPTED_INTERNAL:
     case INTERRUPTED_TARGET_PENDING_INTERNAL:
     case RESUMING_INTERNAL:
       // No active request.
       // TODO(asanka): In the case of RESUMING_INTERNAL, consider setting
-      // is_paused_ even if there's no request currently associated with this
-      // DII. When a request is assigned (due to a resumption, for example) we
-      // can honor the is_paused_ setting.
+      // |DownloadJob::is_paused_| even if there's no request currently
+      // associated with this DII. When a request is assigned (due to a
+      // resumption, for example) we can honor the |DownloadJob::is_paused_|
+      // setting.
       return;
 
     case IN_PROGRESS_INTERNAL:
     case TARGET_PENDING_INTERNAL:
-      request_handle_->PauseRequest();
-      is_paused_ = true;
+      job_->Pause();
       UpdateObservers();
       return;
 
     case MAX_DOWNLOAD_INTERNAL_STATE:
     case TARGET_RESOLVED_INTERNAL:
       NOTREACHED();
   }
 }
 
 void DownloadItemImpl::Resume() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DVLOG(20) << __func__ << "() download = " << DebugString(true);
   switch (state_) {
     case CANCELLED_INTERNAL:  // Nothing to resume.
     case COMPLETE_INTERNAL:
     case COMPLETING_INTERNAL:
     case INITIAL_INTERNAL:
     case INTERRUPTED_TARGET_PENDING_INTERNAL:
     case RESUMING_INTERNAL:   // Resumption in progress.
       return;
 
     case TARGET_PENDING_INTERNAL:
     case IN_PROGRESS_INTERNAL:
-      if (!is_paused_)
+      if (!IsPaused())
         return;
-      request_handle_->ResumeRequest();
-      is_paused_ = false;
+      if (job_)
+        job_->Resume();
       UpdateObservers();
       return;
 
     case INTERRUPTED_INTERNAL:
       auto_resume_count_ = 0;  // User input resets the counter.
       ResumeInterruptedDownload(ResumptionRequestSource::USER);
       UpdateObservers();
       return;
 
     case MAX_DOWNLOAD_INTERNAL_STATE:
@@ skipping 67 matching lines @@
 
 DownloadItem::DownloadState DownloadItemImpl::GetState() const {
   return InternalToExternalState(state_);
 }
 
 DownloadInterruptReason DownloadItemImpl::GetLastReason() const {
   return last_reason_;
 }
 
 bool DownloadItemImpl::IsPaused() const {
-  return is_paused_;
+  return job_ ? job_->is_paused() : false;
 }
 
 bool DownloadItemImpl::IsTemporary() const {
   return is_temporary_;
 }
 
 bool DownloadItemImpl::CanResume() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   switch (state_) {
     case INITIAL_INTERNAL:
     case COMPLETING_INTERNAL:
     case COMPLETE_INTERNAL:
     case CANCELLED_INTERNAL:
     case RESUMING_INTERNAL:
     case INTERRUPTED_TARGET_PENDING_INTERNAL:
       return false;
 
     case TARGET_PENDING_INTERNAL:
     case TARGET_RESOLVED_INTERNAL:
     case IN_PROGRESS_INTERNAL:
-      return is_paused_;
+      return IsPaused();
 
     case INTERRUPTED_INTERNAL: {
       ResumeMode resume_mode = GetResumeMode();
       // Only allow Resume() calls if the resumption mode requires a user
       // action.
       return resume_mode == RESUME_MODE_USER_RESTART ||
              resume_mode == RESUME_MODE_USER_CONTINUE;
     }
 
     case MAX_DOWNLOAD_INTERNAL_STATE:
@@ skipping 173 matching lines @@
   int64_t speed = CurrentSpeed();
   if (speed == 0)
     return false;
 
   *remaining = base::TimeDelta::FromSeconds(
       (total_bytes_ - received_bytes_) / speed);
   return true;
 }
 
 int64_t DownloadItemImpl::CurrentSpeed() const {
-  if (is_paused_)
+  if (IsPaused())
     return 0;
   return bytes_per_sec_;
 }
 
 int DownloadItemImpl::PercentComplete() const {
   // If the delegate is delaying completion of the download, then we have no
   // idea how long it will take.
   if (delegate_delayed_complete_ || total_bytes_ <= 0)
     return -1;
 
@@ skipping 53 matching lines @@
 
 BrowserContext* DownloadItemImpl::GetBrowserContext() const {
   return delegate_->GetBrowserContext();
 }
 
 WebContents* DownloadItemImpl::GetWebContents() const {
   // TODO(rdsmith): Remove null check after removing GetWebContents() from
   // paths that might be used by DownloadItems created from history import.
   // Currently such items have null request_handle_s, where other items
   // (regular and SavePackage downloads) have actual objects off the pointer.
-  if (request_handle_)
-    return request_handle_->GetWebContents();
-  return NULL;
+  if (job_)
+    return job_->GetWebContents();
+  return nullptr;
 }
 
 void DownloadItemImpl::OnContentCheckCompleted(DownloadDangerType danger_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(AllDataSaved());
 
   // Danger type is only allowed to be set on an active download after all data
   // has been saved. This excludes all other states. In particular,
   // OnContentCheckCompleted() isn't allowed on an INTERRUPTED download since
   // such an interruption would need to happen between OnAllDataSaved() and
@@ skipping 84 matching lines @@
 
   // We can't continue without a handle on the intermediate file.
   // We also can't continue if we don't have some verifier to make sure
   // we're getting the same file.
   bool restart_required =
       (current_path_.empty() || (etag_.empty() && last_modified_time_.empty()));
 
   // We won't auto-restart if we've used up our attempts or the
   // download has been paused by user action.
   bool user_action_required =
-      (auto_resume_count_ >= kMaxAutoResumeAttempts || is_paused_);
+      (auto_resume_count_ >= kMaxAutoResumeAttempts || IsPaused());
 
   switch(last_reason_) {
     case DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR:
     case DOWNLOAD_INTERRUPT_REASON_NETWORK_TIMEOUT:
       break;
 
     case DOWNLOAD_INTERRUPT_REASON_SERVER_NO_RANGE:
     // The server disagreed with the file offset that we sent.
 
     case DOWNLOAD_INTERRUPT_REASON_FILE_HASH_MISMATCH:
@@ skipping 272 matching lines @@
 // We're starting the download.
 void DownloadItemImpl::Start(
     std::unique_ptr<DownloadFile> file,
     std::unique_ptr<DownloadRequestHandleInterface> req_handle,
     const DownloadCreateInfo& new_create_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!download_file_.get());
   DVLOG(20) << __func__ << "() this=" << DebugString(true);
 
   download_file_ = std::move(file);
-  request_handle_ = std::move(req_handle);
+  job_ = DownloadJobFactory::CreateJob(this, std::move(req_handle),
+                                       new_create_info);
   destination_error_ = DOWNLOAD_INTERRUPT_REASON_NONE;
 
   if (state_ == CANCELLED_INTERNAL) {
     // The download was in the process of resuming when it was cancelled. Don't
     // proceed.
     ReleaseDownloadFile(true);
-    if (request_handle_)
-      request_handle_->CancelRequest();
+    job_->Cancel(true);
     return;
   }
 
   // The state could be one of the following:
   //
   // INITIAL_INTERNAL: A normal download attempt.
   //
   // RESUMING_INTERNAL: A resumption attempt. May or may not have been
   //     successful.
   DCHECK(state_ == INITIAL_INTERNAL || state_ == RESUMING_INTERNAL);
@@ skipping 31 matching lines @@
     // interruption. Continue with current target path.
     TransitionTo(TARGET_RESOLVED_INTERNAL);
     InterruptWithPartialState(
         offset, std::move(hash_state), new_create_info.result);
     UpdateObservers();
     return;
   }
 
   // Successful download start.
   DCHECK(download_file_.get());
-  DCHECK(request_handle_.get());
+  DCHECK(job_.get());

[qinmin, 2017/02/23 07:26:56]

nit: DCHECK(job_);

[xingliu, 2017/02/24 23:43:13]

Done.

 
   if (state_ == RESUMING_INTERNAL)
     UpdateValidatorsOnResumption(new_create_info);
 
   TransitionTo(TARGET_PENDING_INTERNAL);
 
+  job_->Start();
+}
+
+void DownloadItemImpl::StartDownloadProgress() {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DownloadFile::Initialize,
                  // Safe because we control download file lifetime.
                  base::Unretained(download_file_.get()),
                  base::Bind(&DownloadItemImpl::OnDownloadFileInitialized,
                             weak_ptr_factory_.GetWeakPtr())));
 }
 
 void DownloadItemImpl::OnDownloadFileInitialized(
@@ skipping 376 matching lines @@
 
   if (current_path_.empty()) {
     hash_state_.reset();
     hash_.clear();
     received_bytes_ = 0;
   } else {
     UpdateProgress(bytes_so_far, 0);
     SetHashState(std::move(hash_state));
   }
 
-  if (request_handle_)
-    request_handle_->CancelRequest();
+  if (job_.get())

[qinmin, 2017/02/23 07:26:57]

nit: if (job_) 

[xingliu, 2017/02/24 23:43:13]

Done.

+    job_->Cancel(false);
 
   if (reason == DOWNLOAD_INTERRUPT_REASON_USER_CANCELED ||
       reason == DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN) {
     if (IsDangerous()) {
       RecordDangerousDownloadDiscard(
           reason == DOWNLOAD_INTERRUPT_REASON_USER_CANCELED
               ? DOWNLOAD_DISCARD_DUE_TO_USER_ACTION
               : DOWNLOAD_DISCARD_DUE_TO_SHUTDOWN,
           GetDangerType(), GetTargetFilePath());
     }
@@ skipping 119 matching lines @@
     case TARGET_RESOLVED_INTERNAL:
     case INTERRUPTED_TARGET_PENDING_INTERNAL:
       break;
 
     case IN_PROGRESS_INTERNAL:
       DCHECK(!current_path_.empty()) << "Current output path must be known.";
       DCHECK(!target_path_.empty()) << "Target path must be known.";
       DCHECK(current_path_.DirName() == target_path_.DirName())
           << "Current output directory must match target directory.";
       DCHECK(download_file_) << "Output file must be owned by download item.";
-      DCHECK(request_handle_) << "Download source must be active.";
-      DCHECK(!is_paused_) << "At the time a download enters IN_PROGRESS state, "
-                             "it must not be paused.";
+      DCHECK(job_) << "Must have active download job.";
+      DCHECK(!job_->is_paused())
+          << "At the time a download enters IN_PROGRESS state, "
+             "it must not be paused.";
       break;
 
     case COMPLETING_INTERNAL:
       DCHECK(all_data_saved_) << "All data must be saved prior to completion.";
       DCHECK(!download_file_)
           << "Download file must be released prior to completion.";
       DCHECK(!target_path_.empty()) << "Target path must be known.";
       DCHECK(current_path_ == target_path_)
           << "Current output path must match target path.";
 
@@ skipping 147 matching lines @@
   // (which is the contents of the Referer header for the last download request)
   // will only be sent to the URL returned by GetURL().
   download_params->set_referrer(
       Referrer(GetReferrerUrl(), blink::WebReferrerPolicyAlways));
 
   TransitionTo(RESUMING_INTERNAL);
   RecordDownloadSource(source == ResumptionRequestSource::USER
                            ? INITIATED_BY_MANUAL_RESUMPTION
                            : INITIATED_BY_AUTOMATIC_RESUMPTION);
   delegate_->ResumeInterruptedDownload(std::move(download_params), GetId());
-  // Just in case we were interrupted while paused.
-  is_paused_ = false;
+  // Just in case we were interrupted while paused. |job_| may be null
+  // when no WebContents is associated with a download resumption.
+  if (job_)
+    job_->set_is_paused(false);

[qinmin, 2017/02/23 07:26:57]

shouldn't this be calling job_->Resume()?

[xingliu, 2017/02/24 23:43:13]

Done, not sure if this is totally correct.

job_ may contains a living request, then job_->Resume may resume the request and
continue to pull some data and set is_pause to false.

The previous call will asychronously swap the item with a new job which contains
a new request handle by eventually calling DownloadItemImpl::Start.

So probably the old request will continue to download some data and be killed
when the previous call callback to UI thread, and new request will download
those data again.

[xingliu, 2017/02/25 00:12:13]

Maybe we should just remove this call, since the previous call will swap a new
job_ with is_pause set to initial value, false.

The time between this line and a new job_ coming, the state will always be
RESUMING_INTERNAL, it doesn't use is_pause in the existing code. So we probably
don't need to worry about this.

[qinmin, 2017/02/27 17:15:46]

I would rather change the DownloadJob::Resume() call to take a boolean param,
something like start_new_request, so that we don't remove the logic here.

[xingliu, 2017/02/27 20:44:52]

Done, now job_->Resume(false) will set is_paused to false without resuming the
request.

 }
 
 // static
 DownloadItem::DownloadState DownloadItemImpl::InternalToExternalState(
     DownloadInternalState internal_state) {
   switch (internal_state) {
     case INITIAL_INTERNAL:
     case TARGET_PENDING_INTERNAL:
     case TARGET_RESOLVED_INTERNAL:
     case INTERRUPTED_TARGET_PENDING_INTERNAL:
@@ skipping 159 matching lines @@
     case RESUME_MODE_USER_CONTINUE:
       return "USER_CONTINUE";
     case RESUME_MODE_USER_RESTART:
       return "USER_RESTART";
   }
   NOTREACHED() << "Unknown resume mode " << mode;
   return "unknown";
 }
 
 }  // namespace content