WIP - Refactor programmatic downloads

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 133 matching lines @@
       destination_error_(content::DOWNLOAD_INTERRUPT_REASON_NONE),
       opened_(opened),
       delegate_delayed_complete_(false),
       bound_net_log_(bound_net_log),
       weak_ptr_factory_(this) {
   delegate_->Attach();
   DCHECK_NE(IN_PROGRESS_INTERNAL, state_);
   Init(false /* not actively downloading */, SRC_HISTORY_IMPORT);
 }
 
-// Constructing for a regular download:
-DownloadItemImpl::DownloadItemImpl(
-    DownloadItemImplDelegate* delegate,
-    uint32 download_id,
-    const DownloadCreateInfo& info,
-    const net::BoundNetLog& bound_net_log)
-    : is_save_package_download_(false),
+// Constructing for a regular download (also includes SavePackage downloads):
+DownloadItemImpl::DownloadItemImpl(DownloadItemImplDelegate* delegate,
+                                   uint32 download_id,
+                                   const DownloadCreateInfo& info,
+                                   const net::BoundNetLog& bound_net_log)
+    : is_save_package_download_(info.is_save_package_download),
       download_id_(download_id),
-      target_disposition_(
-          (info.save_info->prompt_for_save_location) ?
-              TARGET_DISPOSITION_PROMPT : TARGET_DISPOSITION_OVERWRITE),
+      target_disposition_((info.save_info->prompt_for_save_location)
+                              ? TARGET_DISPOSITION_PROMPT
+                              : TARGET_DISPOSITION_OVERWRITE),
       url_chain_(info.url_chain),
       referrer_url_(info.referrer_url),
       suggested_filename_(UTF16ToUTF8(info.save_info->suggested_name)),
       forced_file_path_(info.save_info->file_path),
       transition_type_(info.transition_type),
       has_user_gesture_(info.has_user_gesture),
+      route_id_(info.route_id),
       content_disposition_(info.content_disposition),
       mime_type_(info.mime_type),
       original_mime_type_(info.original_mime_type),
       remote_address_(info.remote_address),
       total_bytes_(info.total_bytes),
       received_bytes_(0),
       bytes_per_sec_(0),
       last_modified_time_(info.last_modified),
       etag_(info.etag),
       last_reason_(DOWNLOAD_INTERRUPT_REASON_NONE),
       start_tick_(base::TimeTicks::Now()),
       state_(IN_PROGRESS_INTERNAL),
       danger_type_(DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS),
       start_time_(info.start_time),
       delegate_(delegate),
       is_paused_(false),
       auto_resume_count_(0),
       open_when_complete_(false),
       file_externally_removed_(false),
       auto_opened_(false),
       is_temporary_(!info.save_info->file_path.empty()),
       all_data_saved_(false),
       destination_error_(content::DOWNLOAD_INTERRUPT_REASON_NONE),
       opened_(false),
       delegate_delayed_complete_(false),
       bound_net_log_(bound_net_log),
       weak_ptr_factory_(this) {
   delegate_->Attach();
-  Init(true /* actively downloading */, SRC_ACTIVE_DOWNLOAD);
+  Init(true /* actively downloading */,
+       is_save_package_download_ ? SRC_SAVE_PAGE_AS : SRC_ACTIVE_DOWNLOAD);
 
-  // Link the event sources.
-  bound_net_log_.AddEvent(
-      net::NetLog::TYPE_DOWNLOAD_URL_REQUEST,
-      info.request_bound_net_log.source().ToEventParametersCallback());
+  if (is_save_package_download_) {
+    current_path_ = info.save_info->file_path;
+    target_path_ = current_path_;
+  } else {
+    // Link the event sources.
+    bound_net_log_.AddEvent(
+        net::NetLog::TYPE_DOWNLOAD_URL_REQUEST,
+        info.request_bound_net_log.source().ToEventParametersCallback());
 
   info.request_bound_net_log.AddEvent(
       net::NetLog::TYPE_DOWNLOAD_STARTED,
       bound_net_log_.source().ToEventParametersCallback());
-}
-
-// Constructing for the "Save Page As..." feature:
-DownloadItemImpl::DownloadItemImpl(
-    DownloadItemImplDelegate* delegate,
-    uint32 download_id,
-    const base::FilePath& path,
-    const GURL& url,
-    const std::string& mime_type,
-    scoped_ptr<DownloadRequestHandleInterface> request_handle,
-    const net::BoundNetLog& bound_net_log)
-    : is_save_package_download_(true),
-      request_handle_(request_handle.Pass()),
-      download_id_(download_id),
-      current_path_(path),
-      target_path_(path),
-      target_disposition_(TARGET_DISPOSITION_OVERWRITE),
-      url_chain_(1, url),
-      referrer_url_(GURL()),
-      transition_type_(PAGE_TRANSITION_LINK),
-      has_user_gesture_(false),
-      mime_type_(mime_type),
-      original_mime_type_(mime_type),
-      total_bytes_(0),
-      received_bytes_(0),
-      bytes_per_sec_(0),
-      last_reason_(DOWNLOAD_INTERRUPT_REASON_NONE),
-      start_tick_(base::TimeTicks::Now()),
-      state_(IN_PROGRESS_INTERNAL),
-      danger_type_(DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS),
-      start_time_(base::Time::Now()),
-      delegate_(delegate),
-      is_paused_(false),
-      auto_resume_count_(0),
-      open_when_complete_(false),
-      file_externally_removed_(false),
-      auto_opened_(false),
-      is_temporary_(false),
-      all_data_saved_(false),
-      destination_error_(content::DOWNLOAD_INTERRUPT_REASON_NONE),
-      opened_(false),
-      delegate_delayed_complete_(false),
-      bound_net_log_(bound_net_log),
-      weak_ptr_factory_(this) {
-  delegate_->Attach();
-  Init(true /* actively downloading */, SRC_SAVE_PAGE_AS);
+  }
 }
 
 DownloadItemImpl::~DownloadItemImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Should always have been nuked before now, at worst in
   // DownloadManager shutdown.
   DCHECK(!download_file_.get());
 
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadDestroyed(this));
@@ skipping 58 matching lines @@
   }
   current_path_.clear();
   Remove();
   // We have now been deleted.
 }
 
 void DownloadItemImpl::Pause() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Ignore irrelevant states.
-  if (state_ != IN_PROGRESS_INTERNAL || is_paused_)
+  if (state_ != IN_PROGRESS_INTERNAL || is_paused_ || !request_handle_)
     return;
 
   request_handle_->PauseRequest();
   is_paused_ = true;
   UpdateObservers();
 }
 
 void DownloadItemImpl::Resume() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (!request_handle_)
+    return;
   switch (state_) {
     case IN_PROGRESS_INTERNAL:
       if (!is_paused_)
         return;
       request_handle_->ResumeRequest();
       is_paused_ = false;
       UpdateObservers();
       return;
 
     case COMPLETING_INTERNAL:
@@ skipping 35 matching lines @@
 
   RecordDownloadCount(CANCELLED_COUNT);
 
   // TODO(rdsmith/benjhayden): Remove condition as part of
   // |SavePackage| integration.
   // |download_file_| can be NULL if Interrupt() is called after the
   // download file has been released.
   if (!is_save_package_download_ && download_file_)
     ReleaseDownloadFile(true);
 
-  if (state_ == IN_PROGRESS_INTERNAL) {
+  if (state_ == IN_PROGRESS_INTERNAL && request_handle_) {
     // Cancel the originating URL request unless it's already been cancelled
     // by interrupt.
     request_handle_->CancelRequest();
   }
 
   // Remove the intermediate file if we are cancelling an interrupted download.
   // Continuable interruptions leave the intermediate file around.
   if ((state_ == INTERRUPTED_INTERNAL || state_ == RESUMING_INTERNAL) &&
       !current_path_.empty()) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
@@ skipping 68 matching lines @@
   return is_temporary_;
 }
 
 bool DownloadItemImpl::CanResume() const {
   if ((GetState() == IN_PROGRESS) && IsPaused())
     return true;
 
   if (state_ != INTERRUPTED_INTERNAL)
     return false;
 
-  // Downloads that don't have a WebContents should still be resumable, but this
-  // isn't currently the case. See ResumeInterruptedDownload().
-  if (!GetWebContents())
-    return false;
-
   ResumeMode resume_mode = GetResumeMode();
   return IsDownloadResumptionEnabled() &&
       (resume_mode == RESUME_MODE_USER_RESTART ||
        resume_mode == RESUME_MODE_USER_CONTINUE);
 }
 
 bool DownloadItemImpl::IsDone() const {
   switch (state_) {
     case IN_PROGRESS_INTERNAL:
     case COMPLETING_INTERNAL:
@@ skipping 221 matching lines @@
 
 bool DownloadItemImpl::GetOpened() const {
   return opened_;
 }
 
 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 (route_id_ == GlobalRoutingID())
+    return NULL;
+
+  RenderViewHostImpl* render_view_host =
+      RenderViewHostImpl::FromID(route_id_.child_id, route_id_.route_id);
+  if (!render_view_host)
+    return NULL;
+
+  return render_view_host->GetDelegate()->GetAsWebContents();
 }
 
 void DownloadItemImpl::OnContentCheckCompleted(DownloadDangerType danger_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(AllDataSaved());
   VLOG(20) << __FUNCTION__ << " danger_type=" << danger_type
            << " download=" << DebugString(true);
   SetDangerType(danger_type);
   UpdateObservers();
 }
@@ skipping 46 matching lines @@
         " danger = %d"
         " all_data_saved = %c"
         " last_modified = '%s'"
         " etag = '%s'"
         " has_download_file = %s"
         " url_chain = \n\t\"%s\"\n\t"
         " full_path = \"%" PRFilePath "\"\n\t"
         " target_path = \"%" PRFilePath "\"",
         GetTotalBytes(),
         GetReceivedBytes(),
-        InterruptReasonDebugString(last_reason_).c_str(),
+        DownloadInterruptReasonToString(last_reason_).c_str(),
         IsPaused() ? 'T' : 'F',
         DebugResumeModeString(GetResumeMode()),
         auto_resume_count_,
         GetDangerType(),
         AllDataSaved() ? 'T' : 'F',
         GetLastModifiedTime().c_str(),
         GetETag().c_str(),
         download_file_.get() ? "true" : "false",
         url_list.c_str(),
         GetFullPath().value().c_str(),
@@ skipping 40 matching lines @@
     case DOWNLOAD_INTERRUPT_REASON_FILE_TOO_SHORT:
       if (force_user)
         mode = RESUME_MODE_USER_RESTART;
       else
         mode = RESUME_MODE_IMMEDIATE_RESTART;
       break;
 
     case DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED:
     case DOWNLOAD_INTERRUPT_REASON_NETWORK_DISCONNECTED:
     case DOWNLOAD_INTERRUPT_REASON_NETWORK_SERVER_DOWN:
+    case DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST:
     case DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED:
     case DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN:
     case DOWNLOAD_INTERRUPT_REASON_CRASH:
       if (force_restart)
         mode = RESUME_MODE_USER_RESTART;
       else
         mode = RESUME_MODE_USER_CONTINUE;
       break;
 
     case DOWNLOAD_INTERRUPT_REASON_FILE_FAILED:
@@ skipping 10 matching lines @@
     case DOWNLOAD_INTERRUPT_REASON_USER_CANCELED:
     case DOWNLOAD_INTERRUPT_REASON_FILE_BLOCKED:
     case DOWNLOAD_INTERRUPT_REASON_FILE_SECURITY_CHECK_FAILED:
       mode = RESUME_MODE_INVALID;
       break;
   }
 
   return mode;
 }
 
+void DownloadItemImpl::MergeOriginInfoOnResume(
+    const DownloadCreateInfo& new_create_info) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_EQ(RESUMING_INTERNAL, state_);
+  DCHECK(!new_create_info.url_chain.empty());
+
+  // We are going to tack on any new redirects to our list of redirects.
+  std::vector<GURL>::const_iterator chain_iter =
+      new_create_info.url_chain.begin();
+  if (*chain_iter == url_chain_.back())
+    ++chain_iter;
+  url_chain_.insert(
+      url_chain_.end(), chain_iter, new_create_info.url_chain.end());
+  // TODO(asanka): Measure how URL chains change with resumption. Resumption
+  // requests are issued against the actual download URL and we don't expect any
+  // redirects.
+
+  // If the server precondition failed, then the download will be resumed
+  // automatically without validators.
+  etag_ = new_create_info.etag;
+  last_modified_time_ = new_create_info.last_modified;
+  content_disposition_ = new_create_info.content_disposition;
+  // TODO(asanka): Measure how validators change with resumption. I.e. An ETag
+  // should only change if we used it and the server responded with
+  // HTTP_PRECONDITION_FAILED.
+
+  // Don't update observers. This method is expected to be called just before a
+  // DownloadFile is created and Start() is called. The observers will be
+  // notified when the download transitions to the IN_PROGRESS state.
+}
+
 void DownloadItemImpl::NotifyRemoved() {
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadRemoved(this));
 }
 
 void DownloadItemImpl::OnDownloadedFileRemoved() {
   file_externally_removed_ = true;
   VLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
   UpdateObservers();
 }
 
@@ skipping 119 matching lines @@
         net::NetLog::TYPE_DOWNLOAD_ITEM_ACTIVE, active_data);
   } else {
     bound_net_log_.AddEvent(
         net::NetLog::TYPE_DOWNLOAD_ITEM_ACTIVE, active_data);
   }
 
   VLOG(20) << __FUNCTION__ << "() " << DebugString(true);
 }
 
 // We're starting the download.
-void DownloadItemImpl::Start(
-    scoped_ptr<DownloadFile> file,
-    scoped_ptr<DownloadRequestHandleInterface> req_handle) {
+void DownloadItemImpl::Start(scoped_ptr<DownloadFile> file,
+                             scoped_ptr<DownloadRequestHandle> req_handle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!download_file_.get());
   DCHECK(file.get());
   DCHECK(req_handle.get());
 
   download_file_ = file.Pass();
   request_handle_ = req_handle.Pass();
 
   if (GetState() == CANCELLED) {
     // The download was in the process of resuming when it was cancelled. Don't
@@ skipping 276 matching lines @@
     // we still need to set it auto-opened so that it can be removed from the
     // download shelf.
     if (!IsTemporary())
       OpenDownload();
 
     auto_opened_ = true;
     UpdateObservers();
   }
 }
 
-void DownloadItemImpl::OnResumeRequestStarted(DownloadItem* item,
-                                              net::Error error) {
+void DownloadItemImpl::OnResumeRequestStarted(
+    DownloadItem* item,
+    DownloadInterruptReason interrupt_reason) {
   // If |item| is not NULL, then Start() has been called already, and nothing
   // more needs to be done here.
   if (item) {
-    DCHECK_EQ(net::OK, error);
+    DCHECK_EQ(DOWNLOAD_INTERRUPT_REASON_NONE, interrupt_reason);
     DCHECK_EQ(static_cast<DownloadItem*>(this), item);
     return;
   }
   // Otherwise, the request failed without passing through
   // DownloadResourceHandler::OnResponseStarted.
-  if (error == net::OK)
-    error = net::ERR_FAILED;
-  DownloadInterruptReason reason =
-      ConvertNetErrorToInterruptReason(error, DOWNLOAD_INTERRUPT_FROM_NETWORK);
-  DCHECK_NE(DOWNLOAD_INTERRUPT_REASON_NONE, reason);
-  Interrupt(reason);
+  DCHECK_NE(DOWNLOAD_INTERRUPT_REASON_NONE, interrupt_reason);
+  Interrupt(interrupt_reason);
 }
 
 // **** End of Download progression cascade
 
 // An error occurred somewhere.
 void DownloadItemImpl::Interrupt(DownloadInterruptReason reason) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Somewhat counter-intuitively, it is possible for us to receive an
   // interrupt after we've already been interrupted.  The generation of
@@ skipping 14 matching lines @@
 
   if (state_ == IN_PROGRESS_INTERNAL) {
     // Cancel (delete file) if we're going to restart; no point in leaving
     // data around we aren't going to use.  Also cancel if resumption isn't
     // enabled for the same reason.
     ReleaseDownloadFile(resume_mode == RESUME_MODE_IMMEDIATE_RESTART ||
                         resume_mode == RESUME_MODE_USER_RESTART ||
                         !IsDownloadResumptionEnabled());
 
     // Cancel the originating URL request.
-    request_handle_->CancelRequest();
+    if (request_handle_)
+      request_handle_->CancelRequest();
   } else {
     DCHECK(!download_file_.get());
   }
 
   // Reset all data saved, as even if we did save all the data we're going
   // to go through another round of downloading when we resume.
   // There's a potential problem here in the abstract, as if we did download
   // all the data and then run into a continuable error, on resumption we
   // won't download any more data.  However, a) there are currently no
   // continuable errors that can occur after we download all the data, and
@@ skipping 186 matching lines @@
   // If the flag for downloads resumption isn't enabled, ignore
   // this request.
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (!command_line.HasSwitch(switches::kEnableDownloadResumption))
     return;
 
   // If we're not interrupted, ignore the request; our caller is drunk.
   if (state_ != INTERRUPTED_INTERNAL)
     return;
 
-  // If we can't get a web contents, we can't resume the download.
-  // TODO(rdsmith): Find some alternative web contents to use--this
-  // means we can't restart a download if it's a download imported
-  // from the history.
-  if (!GetWebContents())
-    return;
-
   // Reset the appropriate state if restarting.
   ResumeMode mode = GetResumeMode();
   if (mode == RESUME_MODE_IMMEDIATE_RESTART ||
       mode == RESUME_MODE_USER_RESTART) {
     received_bytes_ = 0;
     hash_state_ = "";
     last_modified_time_ = "";
     etag_ = "";
   }
 
+  // Just in case we were interrupted while paused.
+  is_paused_ = false;
+
+  // TODO(asanka): The resource context may not be correct if the original
+  // request was associated with a different storage partition.
   scoped_ptr<DownloadUrlParameters> download_params(
-      DownloadUrlParameters::FromWebContents(GetWebContents(),
-                                             GetOriginalUrl()));
+      new DownloadUrlParameters(GetOriginalUrl(),
+                                route_id_.child_id,
+                                route_id_.route_id,
+                                GetBrowserContext()->GetResourceContext()));
 
   download_params->set_file_path(GetFullPath());
   download_params->set_offset(GetReceivedBytes());
   download_params->set_hash_state(GetHashState());
   download_params->set_last_modified(GetLastModifiedTime());
   download_params->set_etag(GetETag());
   download_params->set_callback(
       base::Bind(&DownloadItemImpl::OnResumeRequestStarted,
                  weak_ptr_factory_.GetWeakPtr()));
 
   delegate_->ResumeInterruptedDownload(download_params.Pass(), GetId());
-  // Just in case we were interrupted while paused.
-  is_paused_ = false;
 
   TransitionTo(RESUMING_INTERNAL, DONT_UPDATE_OBSERVERS);
 }
 
 // static
 DownloadItem::DownloadState DownloadItemImpl::InternalToExternalState(
     DownloadInternalState internal_state) {
   switch (internal_state) {
     case IN_PROGRESS_INTERNAL:
       return IN_PROGRESS;
@@ skipping 66 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