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_net_log_parameters.h"
 #include "content/browser/download/download_request_handle.h"
 #include "content/browser/download/download_stats.h"
+#include "content/browser/download/download_url_job.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"
 #include "content/public/browser/download_url_parameters.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/common/content_features.h"
@@ skipping 174 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<DownloadUrlJob>(std::move(request_handle));
+  job_->Attach(this);
+
   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 96 matching lines @@
     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.
       return;
 
     case IN_PROGRESS_INTERNAL:
     case TARGET_PENDING_INTERNAL:
-      request_handle_->PauseRequest();
+      job_->Pause();
       is_paused_ = true;

[asanka, 2017/02/16 16:27:39]

Consider removing is_paused_ and having the job_ keep track of the paused state.

[xingliu, 2017/02/20 18:59:10]

Done. Makes sense.

       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_)
         return;
-      request_handle_->ResumeRequest();
+      job_->Resume();
       is_paused_ = false;
       UpdateObservers();
       return;
 
     case INTERRUPTED_INTERNAL:
       auto_resume_count_ = 0;  // User input resets the counter.
       ResumeInterruptedDownload(ResumptionRequestSource::USER);
       UpdateObservers();
       return;
 
@@ skipping 357 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 377 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(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());
 
   if (state_ == RESUMING_INTERNAL)
     UpdateValidatorsOnResumption(new_create_info);
 
   TransitionTo(TARGET_PENDING_INTERNAL);
 
+  job_->Attach(this);

[asanka, 2017/02/16 16:27:39]

Why is there a separate Attach() method?

It would be reasonable to assume that the job would be bound to the same
DownloadItemImpl for its entire lifetime, and that DownloadItemImpl will outlive
the job. This implies that we would be able associate a Job with a
DownloadItemImpl at creation and leave it at that.

[xingliu, 2017/02/20 18:59:10]

Done. Move to pass the item in ctor.

+  job_->Start();
+}
+
+void DownloadItemImpl::InitializeDownloadFile() {

[asanka, 2017/02/16 16:27:39]

This isn't so much initializing the download file, but setting in motion the
entire series of events that result in the file being downloaded.

[xingliu, 2017/02/20 18:59:10]

Done, renamed to 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())
+    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(job_) << "Must have active download job.";
       DCHECK(!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_)
@@ skipping 330 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