[downloads] Move platform specific code out of DownloadTargetDeterminer.

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 553 matching lines @@
 std::string DownloadItemImpl::GetOriginalMimeType() const {
   return original_mime_type_;
 }
 
 std::string DownloadItemImpl::GetRemoteAddress() const {
   return remote_address_;
 }
 
 bool DownloadItemImpl::HasUserGesture() const {
   return has_user_gesture_;
-};
+}
 
 ui::PageTransition DownloadItemImpl::GetTransitionType() const {
   return transition_type_;
-};
+}
 
 const std::string& DownloadItemImpl::GetLastModifiedTime() const {
   return last_modified_time_;
 }
 
 const std::string& DownloadItemImpl::GetETag() const {
   return etag_;
 }
 
 bool DownloadItemImpl::IsSavePackageDownload() const {
@@ skipping 260 matching lines @@
   // 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_);
 
-  switch(last_reason_) {
+  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:
     // The file on disk was found to not match the expected hash. Discard and
     // start from beginning.
@@ skipping 40 matching lines @@
     case DOWNLOAD_INTERRUPT_REASON_NONE:
     case DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST:
     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:
     case DOWNLOAD_INTERRUPT_REASON_SERVER_UNAUTHORIZED:
     case DOWNLOAD_INTERRUPT_REASON_SERVER_CERT_PROBLEM:
     case DOWNLOAD_INTERRUPT_REASON_SERVER_FORBIDDEN:
-      // Unhandled.
       return RESUME_MODE_INVALID;
   }
 
   if (user_action_required && restart_required)
     return RESUME_MODE_USER_RESTART;
 
   if (restart_required)
     return RESUME_MODE_IMMEDIATE_RESTART;
 
   if (user_action_required)
@@ skipping 316 matching lines @@
   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 base::FilePath& target_path,
     TargetDisposition disposition,
     DownloadDangerType danger_type,
-    const base::FilePath& intermediate_path) {
+    const base::FilePath& intermediate_path,
+    DownloadInterruptReason interrupt_reason) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(state_ == TARGET_PENDING_INTERNAL ||
          state_ == INTERRUPTED_TARGET_PENDING_INTERNAL);
 
-  // If the |target_path| is empty, then we consider this download to be
-  // canceled.
-  if (target_path.empty()) {
+  if (interrupt_reason == DOWNLOAD_INTERRUPT_REASON_USER_CANCELED ||
+      target_path.empty()) {
     Cancel(true);
     return;
   }
 
+  if (interrupt_reason != DOWNLOAD_INTERRUPT_REASON_NONE) {
+    InterruptAndDiscardPartialState(interrupt_reason);
+    UpdateObservers();
+    return;
+  }
+
   DVLOG(20) << __func__ << "() target_path:" << target_path.value()

[svaldez, 2016/10/28 17:29:36]

Should be moved up since otherwise this will never get non-REASON_NONE
interruptions.

[asanka, 2016/11/07 19:50:15]

Done.

             << " disposition:" << disposition << " danger_type:" << danger_type
+            << " interrupt_reason:"
+            << DownloadInterruptReasonToString(interrupt_reason)
             << " this:" << DebugString(true);
-
   target_path_ = target_path;
   target_disposition_ = disposition;
   SetDangerType(danger_type);
 
   // This was an interrupted download that was looking for a filename. Now that
   // it has one, transition to interrupted.
   if (state_ == INTERRUPTED_TARGET_PENDING_INTERNAL) {
     InterruptWithPartialState(
         received_bytes_, std::move(hash_state_), destination_error_);
     destination_error_ = DOWNLOAD_INTERRUPT_REASON_NONE;
@@ skipping 270 matching lines @@
 
     case INTERRUPTED_TARGET_PENDING_INTERNAL:
     case IN_PROGRESS_INTERNAL:
     case TARGET_PENDING_INTERNAL:
     case TARGET_RESOLVED_INTERNAL:
       // last_reason_ needs to be set for GetResumeMode() to work.
       last_reason_ = reason;
 
       if (download_file_) {
         ResumeMode resume_mode = GetResumeMode();
-        ReleaseDownloadFile(resume_mode != RESUME_MODE_IMMEDIATE_CONTINUE &&
-                            resume_mode != RESUME_MODE_USER_CONTINUE);
+        bool destroy_file = bytes_so_far == 0 ||
+                            (resume_mode != RESUME_MODE_IMMEDIATE_CONTINUE &&
+                             resume_mode != RESUME_MODE_USER_CONTINUE);
+        ReleaseDownloadFile(destroy_file);
       }
       break;
 
     case RESUMING_INTERNAL:
     case INTERRUPTED_INTERNAL:
       DCHECK(!download_file_);
       // The first non-cancel interrupt reason wins in cases where multiple
       // things go wrong.
       if (reason != DOWNLOAD_INTERRUPT_REASON_USER_CANCELED &&
           reason != DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN)
@@ skipping 40 matching lines @@
       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());
     }
 
     RecordDownloadCount(CANCELLED_COUNT);
+    DCHECK_EQ(last_reason_, reason);
     TransitionTo(CANCELLED_INTERNAL);
     return;
   }
 
   RecordDownloadInterrupted(reason, received_bytes_, total_bytes_);
   if (!GetWebContents())
     RecordDownloadCount(INTERRUPTED_WITHOUT_WEBCONTENTS);
 
+  // TODO(asanka): This is not good. We can transition to interrupted from
+  // target-pending, which is something we don't want to do. Perhaps we should
+  // explicitly transition to target-resolved prior to switching to interrupted.
+  DCHECK_EQ(last_reason_, reason);
   TransitionTo(INTERRUPTED_INTERNAL);
   AutoResumeIfValid();
 }
 
 void DownloadItemImpl::UpdateProgress(int64_t bytes_so_far,
                                       int64_t bytes_per_sec) {
   received_bytes_ = bytes_so_far;
   bytes_per_sec_ = bytes_per_sec;
 
   // If we've received more data than we were expecting (bad server info?),
@@ skipping 427 matching lines @@
     case COMPLETE_INTERNAL:
       return "COMPLETE";
     case CANCELLED_INTERNAL:
       return "CANCELLED";
     case INTERRUPTED_INTERNAL:
       return "INTERRUPTED";
     case RESUMING_INTERNAL:
       return "RESUMING";
     case MAX_DOWNLOAD_INTERNAL_STATE:
       break;
-  };
+  }
   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