Initial CL for Downloads resumption.

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.
 
 // A regular DownloadItem (created for a download in this session of the
 // browser) normally goes through the following states:
 //      * Created (when download starts)
 //      * Destination filename determined
 //      * Entered into the history database.
 //      * Made visible in the download shelf.
 //      * All the data is saved.  Note that the actual data download occurs
 //        in parallel with the above steps, but until those steps are
 //        complete, the state of the data save will be ignored.
 //      * Download file is renamed to its final name, and possibly
 //        auto-opened.
 
 #include "content/browser/download/download_item_impl.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "base/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_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_interrupt_reasons.h"
+#include "content/public/browser/download_url_parameters.h"
+#include "content/public/common/content_switches.h"
+#include "content/public/common/referrer.h"
 #include "net/base/net_util.h"
 
 namespace content {
+
 namespace {
 
-static void DeleteDownloadedFile(const FilePath& path) {
+void DeleteDownloadedFile(const FilePath& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // Make sure we only delete files.
   if (!file_util::DirectoryExists(path))
     file_util::Delete(path, false);
 }
 
 const char* DebugSafetyStateString(DownloadItem::SafetyState state) {
   switch (state) {
     case DownloadItem::SAFE:
@@ skipping 42 matching lines @@
 
 static void DownloadFileCancel(scoped_ptr<DownloadFile> download_file) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   download_file->Cancel();
 }
 
 }  // namespace
 
 const char DownloadItem::kEmptyFileHash[] = "";
 
+// The maximum number of attempts we will make to resume automatically.
+const int DownloadItemImpl::kMaxAutoResumeAttempts = 5;
+
 // Constructor for reading from the history service.
 DownloadItemImpl::DownloadItemImpl(DownloadItemImplDelegate* delegate,
                                    DownloadId download_id,
                                    const FilePath& path,
                                    const GURL& url,
                                    const GURL& referrer_url,
                                    const base::Time& start_time,
                                    const base::Time& end_time,
                                    int64 received_bytes,
                                    int64 total_bytes,
@@ skipping 13 matching lines @@
       received_bytes_(received_bytes),
       bytes_per_sec_(0),
       last_reason_(DOWNLOAD_INTERRUPT_REASON_NONE),
       start_tick_(base::TimeTicks()),
       state_(ExternalToInternalState(state)),
       danger_type_(DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS),
       start_time_(start_time),
       end_time_(end_time),
       delegate_(delegate),
       is_paused_(false),
+      auto_resume_count_(0),
       open_when_complete_(false),
       file_externally_removed_(false),
       safety_state_(SAFE),
       auto_opened_(false),
       is_temporary_(false),
       all_data_saved_(false),
       opened_(opened),
       open_enabled_(true),
       delegate_delayed_complete_(false),
       bound_net_log_(bound_net_log),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   delegate_->Attach();
   if (state_ == IN_PROGRESS_INTERNAL)
     state_ = CANCELLED_INTERNAL;
   if (state_ == COMPLETE_INTERNAL)
     all_data_saved_ = true;
   Init(false /* not actively downloading */, SRC_HISTORY_IMPORT);
 }
 
 // Constructing for a regular download:
 DownloadItemImpl::DownloadItemImpl(
     DownloadItemImplDelegate* delegate,
     const DownloadCreateInfo& info,
-    scoped_ptr<DownloadRequestHandleInterface> request_handle,
     const net::BoundNetLog& bound_net_log)
     : is_save_package_download_(false),
-      request_handle_(request_handle.Pass()),
       download_id_(info.download_id),
       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),
       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_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),
       safety_state_(SAFE),
       auto_opened_(false),
       is_temporary_(!info.save_info->file_path.empty()),
       all_data_saved_(false),
       opened_(false),
       open_enabled_(true),
       delegate_delayed_complete_(false),
       bound_net_log_(bound_net_log),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   delegate_->Attach();
-  Init(true /* actively downloading */, SRC_NEW_DOWNLOAD);
+  Init(true /* actively downloading */, SRC_ACTIVE_DOWNLOAD);
 
   // 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());
 }
@@ skipping 20 matching lines @@
       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),
       safety_state_(SAFE),
       auto_opened_(false),
       is_temporary_(false),
       all_data_saved_(false),
       opened_(false),
       open_enabled_(true),
       delegate_delayed_complete_(false),
       bound_net_log_(bound_net_log),
@@ skipping 67 matching lines @@
 
   request_handle_->PauseRequest();
   is_paused_ = true;
   UpdateObservers();
 }
 
 void DownloadItemImpl::Resume() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Ignore irrelevant states.
-  if (state_ != IN_PROGRESS_INTERNAL || !is_paused_)
+  if (state_ == COMPLETE_INTERNAL || state_ == COMPLETING_INTERNAL ||
+      !is_paused_)
     return;
 
+  if (state_ == INTERRUPTED_INTERNAL) {
+    auto_resume_count_ = 0;  // User input resets the counter.
+    ResumeInterruptedDownload();
+    return;
+  }
+  DCHECK_EQ(IN_PROGRESS_INTERNAL, state_);
+
   request_handle_->ResumeRequest();
   is_paused_ = false;
   UpdateObservers();
 }
 
 void DownloadItemImpl::Cancel(bool user_cancel) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  VLOG(20) << __FUNCTION__ << "() download = " << DebugString(true);
+  if (state_ != IN_PROGRESS_INTERNAL && state_ != INTERRUPTED_INTERNAL) {
+    // Small downloads might be complete before this method has
+    // a chance to run.
+    return;
+  }
+
   last_reason_ = user_cancel ?
       DOWNLOAD_INTERRUPT_REASON_USER_CANCELED :
       DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN;
 
-  VLOG(20) << __FUNCTION__ << "() download = " << DebugString(true);
-  if (state_ != IN_PROGRESS_INTERNAL) {
-    // Small downloads might be complete before this method has
-    // a chance to run.
-    return;
-  }
-
   RecordDownloadCount(CANCELLED_COUNT);
 
   TransitionTo(CANCELLED_INTERNAL);
 
   CancelDownloadFile();
 
   // Cancel the originating URL request.
   request_handle_->CancelRequest();
 }
 
 void DownloadItemImpl::Delete(DeleteReason reason) {
+  VLOG(20) << __FUNCTION__ << "() download = " << DebugString(true);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   switch (reason) {
     case DELETE_DUE_TO_USER_DISCARD:
       UMA_HISTOGRAM_ENUMERATION(
           "Download.UserDiscard", GetDangerType(),
           DOWNLOAD_DANGER_TYPE_MAX);
       break;
     case DELETE_DUE_TO_BROWSER_SHUTDOWN:
       UMA_HISTOGRAM_ENUMERATION(
           "Download.Discard", GetDangerType(),
           DOWNLOAD_DANGER_TYPE_MAX);
       break;
     default:
       NOTREACHED();
   }
 
   // Delete the file if it exists and is not owned by a DownloadFile object.
   // (In the latter case the DownloadFile object will delete it on cancel.)
   if (!current_path_.empty() && download_file_.get() == NULL) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                             base::Bind(&DeleteDownloadedFile, current_path_));
   }
   Remove();
   // We have now been deleted.
 }
 
 void DownloadItemImpl::Remove() {
+  VLOG(20) << __FUNCTION__ << "() download = " << DebugString(true);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   delegate_->AssertStateConsistent(this);
   Cancel(true);
   delegate_->AssertStateConsistent(this);
 
   NotifyRemoved();
   delegate_->DownloadRemoved(this);
   // We have now been deleted.
 }
@@ skipping 53 matching lines @@
 }
 
 bool DownloadItemImpl::IsPaused() const {
   return is_paused_;
 }
 
 bool DownloadItemImpl::IsTemporary() const {
   return is_temporary_;
 }
 
-// TODO(ahendrickson) -- Move |INTERRUPTED| from |IsCancelled()| to
-// |IsPartialDownload()|, when resuming interrupted downloads is implemented.
 bool DownloadItemImpl::IsPartialDownload() const {
-  return InternalToExternalState(state_) == IN_PROGRESS;
+  DownloadState state = InternalToExternalState(state_);
+  return (state == IN_PROGRESS) || (state == INTERRUPTED);
 }
 
 bool DownloadItemImpl::IsInProgress() const {
   return InternalToExternalState(state_) == IN_PROGRESS;
 }
 
 bool DownloadItemImpl::IsCancelled() const {
-  DownloadState external_state = InternalToExternalState(state_);
-  return  external_state == CANCELLED || external_state == INTERRUPTED;
+  return  InternalToExternalState(state_) == CANCELLED;
 }
 
 bool DownloadItemImpl::IsInterrupted() const {
   return InternalToExternalState(state_) == INTERRUPTED;
 }
 
 bool DownloadItemImpl::IsComplete() const {
   return InternalToExternalState(state_) == COMPLETE;
 }
 
@@ skipping 255 matching lines @@
       url_list += next_url.spec();
     }
   }
 
   if (verbose) {
     description += base::StringPrintf(
         " total = %" PRId64
         " received = %" PRId64
         " reason = %s"
         " paused = %c"
+        " resume_mode = %s"
+        " auto_resume_count = %d"
         " safety = %s"
+        " all_data_saved = %c"
         " last_modified = '%s'"
         " etag = '%s'"
+        " has_download_file = %s"
         " url_chain = \n\t\"%s\"\n\t"
-        " full_path = \"%" PRFilePath "\""
-        " target_path = \"%" PRFilePath "\""
-        " has download file = %s",
+        " full_path = \"%" PRFilePath "\"\n\t"
+        " target_path = \"%" PRFilePath "\"",
         GetTotalBytes(),
         GetReceivedBytes(),
         InterruptReasonDebugString(last_reason_).c_str(),
         IsPaused() ? 'T' : 'F',
+        DebugResumeModeString(GetResumeMode()),
+        auto_resume_count_,
         DebugSafetyStateString(GetSafetyState()),
+        AllDataSaved() ? 'T' : 'F',
         GetLastModifiedTime().c_str(),
         GetETag().c_str(),
+        download_file_.get() ? "true" : "false",
         url_list.c_str(),
         GetFullPath().value().c_str(),
-        GetTargetFilePath().value().c_str(),
-        download_file_.get() ? "true" : "false");
+        GetTargetFilePath().value().c_str());
   } else {
     description += base::StringPrintf(" url = \"%s\"", url_list.c_str());
   }
 
   description += " }";
 
   return description;
 }
 
 void DownloadItemImpl::MockDownloadOpenForTesting() {
   open_enabled_ = false;
 }
 
+DownloadItemImpl::ResumeMode DownloadItemImpl::GetResumeMode() const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (!IsInterrupted())
+    return RESUME_MODE_INVALID;
+
+  // We can't continue without a handle on the intermediate file.
+  const bool force_restart = current_path_.empty();
+
+  // We won't auto-restart if we've used up our attempts or the
+  // download has been paused by user action.
+  const bool force_user =
+      (auto_resume_count_ >= kMaxAutoResumeAttempts || is_paused_);
+
+  ResumeMode mode = RESUME_MODE_INVALID;
+
+  switch(last_reason_) {
+    case DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR:
+    case DOWNLOAD_INTERRUPT_REASON_NETWORK_TIMEOUT:
+      if (force_restart && force_user)
+        mode = RESUME_MODE_USER_RESTART;
+      else if (force_restart)
+        mode = RESUME_MODE_IMMEDIATE_RESTART;
+      else if (force_user)
+        mode = RESUME_MODE_USER_CONTINUE;
+      else
+        mode = RESUME_MODE_IMMEDIATE_CONTINUE;
+      break;
+
+    case DOWNLOAD_INTERRUPT_REASON_SERVER_PRECONDITION:
+    case DOWNLOAD_INTERRUPT_REASON_SERVER_NO_RANGE:
+    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_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:
+    case DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED:
+    case DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE:
+    case DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG:
+    case DOWNLOAD_INTERRUPT_REASON_FILE_TOO_LARGE:
+      mode = RESUME_MODE_USER_RESTART;
+      break;
+
+    case DOWNLOAD_INTERRUPT_REASON_NONE:
+    case DOWNLOAD_INTERRUPT_REASON_FILE_VIRUS_INFECTED:
+    case DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT:
+    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::ResumeInterruptedDownload() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // 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;
+
+  // Handle the case of clicking 'Resume' in the download shelf.
+  DCHECK(IsInterrupted());
+
+  DVLOG(20) << __FUNCTION__ << "()" << DebugString(true);
+
+  // 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_ = "";
+  }
+
+  scoped_ptr<DownloadUrlParameters> download_params(
+      DownloadUrlParameters::FromWebContents(GetWebContents(),
+                                             GetOriginalUrl()));
+
+  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());
+
+  delegate_->ResumeInterruptedDownload(download_params.Pass(), GetGlobalId());
+
+  // Just in case we were interrupted while paused.
+  is_paused_ = false;
+}
+
 void DownloadItemImpl::NotifyRemoved() {
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadRemoved(this));
 }
 
 void DownloadItemImpl::OnDownloadedFileRemoved() {
   file_externally_removed_ = true;
   VLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
   UpdateObservers();
 }
 
 base::WeakPtr<DownloadDestinationObserver>
 DownloadItemImpl::DestinationObserverAsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
+const net::BoundNetLog& DownloadItemImpl::GetBoundNetLog() const {
+  return bound_net_log_;
+}
+
 void DownloadItemImpl::SetTotalBytes(int64 total_bytes) {
   total_bytes_ = total_bytes;
 }
 
 // Updates from the download thread may have been posted while this download
 // was being cancelled in the UI thread, so we'll accept them unless we're
 // complete.
 void DownloadItemImpl::UpdateProgress(int64 bytes_so_far,
                                       int64 bytes_per_sec,
                                       const std::string& hash_state) {
@@ skipping 136 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) {
+void DownloadItemImpl::Start(
+    scoped_ptr<DownloadFile> file,
+    scoped_ptr<DownloadRequestHandleInterface> 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();
+
+  TransitionTo(IN_PROGRESS_INTERNAL);
+
+  last_reason_ = DOWNLOAD_INTERRUPT_REASON_NONE;
 
   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(
     DownloadInterruptReason result) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (result != DOWNLOAD_INTERRUPT_REASON_NONE) {
     Interrupt(result);
     // TODO(rdsmith): It makes no sense to continue along the
     // regular download path after we've gotten an error.  But it's
     // the way the code has historically worked, and this allows us
     // to get the download persisted and observers of the download manager
     // notified, so tests work.  When we execute all side effects of cancel
-    // (including queue removal) immedately rather than waiting for
+    // (including queue removal) immediately rather than waiting for
     // persistence we should replace this comment with a "return;".
   }
 
+  // If we're resuming an interrupted download, we may already know
+  // the download target so we can skip target name determination.
+  if (!GetTargetFilePath().empty() && !GetFullPath().empty()) {
+    delegate_->ShowDownloadInBrowser(this);
+    MaybeCompleteDownload();
+    return;
+  }
+
+  // The target path might be set and the full path empty if we failed
+  // the intermediate rename--re-do file name determination in this case.
+  // TODO(rdsmith,asanka): Clean up this logic.
+  target_path_ = FilePath();
+
   delegate_->DetermineDownloadTarget(
       this, base::Bind(&DownloadItemImpl::OnDownloadTargetDetermined,
                        weak_ptr_factory_.GetWeakPtr()));
 }
 
 // Called by delegate_ when the download target path has been
 // determined.
 void DownloadItemImpl::OnDownloadTargetDetermined(
     const FilePath& target_path,
     TargetDisposition disposition,
     DownloadDangerType danger_type,
     const FilePath& intermediate_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If the |target_path| is empty, then we consider this download to be
   // canceled.
   if (target_path.empty()) {
     Cancel(true);
     return;
   }
 
+  // TODO(rdsmith,asanka): We are ignoring the possibility that the download
+  // has been interrupted at this point until we finish the intermediate
+  // rename and set the full path.  That's dangerous, because we might race
+  // with resumption, either manual (because the interrupt is visible to the
+  // UI) or automatic.  If we keep the "ignore an error on download until file
+  // name determination complete" semantics, we need to make sure that the
+  // error is kept completely invisible until that point.
+
   VLOG(20) << __FUNCTION__ << " " << target_path.value() << " " << disposition
            << " " << danger_type << " " << DebugString(true);
 
   target_path_ = target_path;
   target_disposition_ = disposition;
   SetDangerType(danger_type);
   // TODO(asanka): SetDangerType() doesn't need to send a notification here.
 
   // We want the intermediate and target paths to refer to the same directory so
   // that they are both on the same device and subject to same
   // space/permission/availability constraints.
   DCHECK(intermediate_path.DirName() == target_path.DirName());
 
-  if (state_ != IN_PROGRESS_INTERNAL) {
-    // If we've been cancelled or interrupted while the target was being
-    // determined, continue the cascade with a null name.
-    // The error doesn't matter as the cause of download stoppage
-    // will already have been recorded and will be retained, but we use
-    // whatever was recorded for consistency.
-    OnDownloadRenamedToIntermediateName(last_reason_, FilePath());
-    return;
-  }
-
   // Rename to intermediate name.
   // TODO(asanka): Skip this rename if AllDataSaved() is true. This avoids a
   //               spurious rename when we can just rename to the final
   //               filename. Unnecessary renames may cause bugs like
   //               http://crbug.com/74187.
   DCHECK(!is_save_package_download_);
   DCHECK(download_file_.get());
   DownloadFile::RenameCompletionCallback callback =
       base::Bind(&DownloadItemImpl::OnDownloadRenamedToIntermediateName,
                  weak_ptr_factory_.GetWeakPtr());
@@ skipping 131 matching lines @@
   if (delegate_->ShouldOpenDownload(
           this, base::Bind(&DownloadItemImpl::DelayedDownloadOpened,
                            weak_ptr_factory_.GetWeakPtr()))) {
     Completed();
   } else {
     delegate_delayed_complete_ = true;
   }
 }
 
 void DownloadItemImpl::DelayedDownloadOpened(bool auto_opened) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   auto_opened_ = auto_opened;
   Completed();
 }
 
 void DownloadItemImpl::Completed() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   VLOG(20) << __FUNCTION__ << "() " << DebugString(false);
 
   DCHECK(all_data_saved_);
@@ skipping 14 matching lines @@
 
     auto_opened_ = true;
     UpdateObservers();
   }
 }
 
 // **** 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
   // interrupts from the file thread Renames and the generation of
   // interrupts from disk writes go through two different mechanisms (driven
   // by rename requests from UI thread and by write requests from IO thread,
   // respectively), and since we choose not to keep state on the File thread,
   // this is the place where the races collide.  It's also possible for
   // interrupts to race with cancels.
 
   // Whatever happens, the first one to hit the UI thread wins.
   if (state_ != IN_PROGRESS_INTERNAL)
     return;
 
   last_reason_ = reason;
+
   TransitionTo(INTERRUPTED_INTERNAL);
 
-  CancelDownloadFile();
+  ResumeMode resume_mode = GetResumeMode();
+  if (resume_mode == RESUME_MODE_IMMEDIATE_RESTART ||
+      resume_mode == RESUME_MODE_USER_RESTART) {
+    // Remove the download file; no point in leaving data around we
+    // aren't going to use.
+    CancelDownloadFile();
+  } else {
+    // Keep the file around and maybe re-use it.
+    BrowserThread::PostTask(
+        BrowserThread::FILE, FROM_HERE,
+        base::Bind(&DownloadFileDetach, base::Passed(&download_file_)));
+  }
 
   // Cancel the originating URL request.
   request_handle_->CancelRequest();
 
   RecordDownloadInterrupted(reason, received_bytes_, total_bytes_);
+  AutoResumeIfValid();
 }
 
 void DownloadItemImpl::CancelDownloadFile() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   // 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.
+  // |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_.get()) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         // Will be deleted at end of task execution.
         base::Bind(&DownloadFileCancel, base::Passed(&download_file_)));
   }
 }
 
 bool DownloadItemImpl::IsDownloadReadyForCompletion(
     const base::Closure& state_change_notification) {
@@ skipping 24 matching lines @@
 
   // Give the delegate a chance to hold up a stop sign.  It'll call
   // use back through the passed callback if it does and that state changes.
   if (!delegate_->ShouldCompleteDownload(this, state_change_notification))
     return false;
 
   return true;
 }
 
 void DownloadItemImpl::TransitionTo(DownloadInternalState new_state) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   if (state_ == new_state)
     return;
 
   DownloadInternalState old_state = state_;
   state_ = new_state;
 
   switch (state_) {
     case COMPLETING_INTERNAL:
       bound_net_log_.AddEvent(
           net::NetLog::TYPE_DOWNLOAD_ITEM_COMPLETING,
           base::Bind(&ItemCompletingNetLogCallback, received_bytes_, &hash_));
       break;
     case COMPLETE_INTERNAL:
       bound_net_log_.AddEvent(
           net::NetLog::TYPE_DOWNLOAD_ITEM_FINISHED,
           base::Bind(&ItemFinishedNetLogCallback, auto_opened_));
       break;
     case INTERRUPTED_INTERNAL:
       bound_net_log_.AddEvent(
           net::NetLog::TYPE_DOWNLOAD_ITEM_INTERRUPTED,
           base::Bind(&ItemInterruptedNetLogCallback, last_reason_,
                      received_bytes_, &hash_state_));
       break;
+    case IN_PROGRESS_INTERNAL:
+      if (old_state == INTERRUPTED_INTERNAL) {
+        bound_net_log_.AddEvent(
+            net::NetLog::TYPE_DOWNLOAD_ITEM_RESUMED,
+            base::Bind(&ItemResumingNetLogCallback,
+                       false, last_reason_, received_bytes_, &hash_state_));
+      }
+      break;
     case CANCELLED_INTERNAL:
       bound_net_log_.AddEvent(
           net::NetLog::TYPE_DOWNLOAD_ITEM_CANCELED,
           base::Bind(&ItemCanceledNetLogCallback, received_bytes_,
                      &hash_state_));
       break;
     default:
       break;
   }
 
   VLOG(20) << " " << __FUNCTION__ << "()" << " this = " << DebugString(true)
     << " " << InternalToExternalState(old_state)
     << " " << InternalToExternalState(state_);
 
   // Only update observers on user visible state changes.
-  if (InternalToExternalState(old_state) != InternalToExternalState(state_))
+  if (InternalToExternalState(state_) != InternalToExternalState(old_state))
     UpdateObservers();
 
   bool is_done = (state_ != IN_PROGRESS_INTERNAL &&
                   state_ != COMPLETING_INTERNAL);
   bool was_done = (old_state != IN_PROGRESS_INTERNAL &&
                    old_state != COMPLETING_INTERNAL);
+  // Termination
   if (is_done && !was_done)
     bound_net_log_.EndEvent(net::NetLog::TYPE_DOWNLOAD_ITEM_ACTIVE);
+
+  // Resumption
+  if (was_done && !is_done) {
+    std::string file_name(target_path_.BaseName().AsUTF8Unsafe());
+    bound_net_log_.BeginEvent(net::NetLog::TYPE_DOWNLOAD_ITEM_ACTIVE,
+                              base::Bind(&ItemActivatedNetLogCallback,
+                                         this, SRC_ACTIVE_DOWNLOAD,
+                                         &file_name));
+  }
 }
 
 void DownloadItemImpl::SetDangerType(DownloadDangerType danger_type) {
   danger_type_ = danger_type;
   // Notify observers if the safety state has changed as a result of the new
   // danger type.
   SafetyState updated_value = IsDangerous() ?
       DownloadItem::DANGEROUS : DownloadItem::SAFE;
   if (updated_value != safety_state_) {
     safety_state_ = updated_value;
@@ skipping 12 matching lines @@
   DCHECK(!new_path.empty());
 
   bound_net_log_.AddEvent(
       net::NetLog::TYPE_DOWNLOAD_ITEM_RENAMED,
       base::Bind(&ItemRenamedNetLogCallback, &current_path_, &new_path));
 
   current_path_ = new_path;
   UpdateObservers();
 }
 
+void DownloadItemImpl::AutoResumeIfValid() {
+  DVLOG(20) << __FUNCTION__ << "() " << DebugString(true);
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  ResumeMode mode = GetResumeMode();
+
+  if (mode != RESUME_MODE_IMMEDIATE_RESTART &&
+      mode != RESUME_MODE_IMMEDIATE_CONTINUE) {
+    return;
+  }
+
+  auto_resume_count_++;
+
+  ResumeInterruptedDownload();
+}
+
 // static
 DownloadItem::DownloadState DownloadItemImpl::InternalToExternalState(
     DownloadInternalState internal_state) {
   switch (internal_state) {
     case IN_PROGRESS_INTERNAL:
       return IN_PROGRESS;
     case COMPLETING_INTERNAL:
       return IN_PROGRESS;
     case COMPLETE_INTERNAL:
       return COMPLETE;
@@ skipping 38 matching lines @@
     case CANCELLED_INTERNAL:
       return "CANCELLED";
     case INTERRUPTED_INTERNAL:
       return "INTERRUPTED";
     default:
       NOTREACHED() << "Unknown download state " << state;
       return "unknown";
   };
 }
 
+const char* DownloadItemImpl::DebugResumeModeString(ResumeMode mode) {
+  switch (mode) {
+    case RESUME_MODE_INVALID:
+      return "INVALID";
+    case RESUME_MODE_IMMEDIATE_CONTINUE:
+      return "IMMEDIATE_CONTINUE";
+    case RESUME_MODE_IMMEDIATE_RESTART:
+      return "IMMEDIATE_RESTART";
+    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