[Resumption 10/12] Use DI::IsDone to check for terminal 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 262 matching lines @@
 }
 
 void DownloadItemImpl::UpdateObservers() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadUpdated(this));
 }
 
 void DownloadItemImpl::ValidateDangerousDownload() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK_EQ(IN_PROGRESS, GetState());
+  DCHECK(!IsDone());
   DCHECK(IsDangerous());
 
   VLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
 
-  if (GetState() != IN_PROGRESS)
+  if (IsDone() || !IsDangerous())
     return;
 
   RecordDangerousDownloadAccept(GetDangerType());
 
   danger_type_ = DOWNLOAD_DANGER_TYPE_USER_VALIDATED;
 
   bound_net_log_.AddEvent(
       net::NetLog::TYPE_DOWNLOAD_ITEM_SAFETY_STATE_UPDATED,
       base::Bind(&ItemCheckedNetLogCallback, GetDangerType()));
 
@@ skipping 117 matching lines @@
   delegate_->AssertStateConsistent(this);
 
   NotifyRemoved();
   delegate_->DownloadRemoved(this);
   // We have now been deleted.
 }
 
 void DownloadItemImpl::OpenDownload() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (state_ == IN_PROGRESS_INTERNAL) {
+  if (!IsDone()) {
     // We don't honor the open_when_complete_ flag for temporary
     // downloads. Don't set it because it shows up in the UI.
     if (!IsTemporary())
       open_when_complete_ = !open_when_complete_;
     return;
   }
 
   if (state_ != COMPLETE_INTERNAL || file_externally_removed_)
     return;
 
@@ skipping 49 matching lines @@
   // 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);
 }
 
-// TODO(rdsmith): Figure out whether or not we want this probe routine
-// to consider interrupted (resumably) downloads partial downloads.
-// Conceptually the answer is probably yes, but everywhere that currently
-// uses the routine is using it as a synonym for IsInProgress().
-bool DownloadItemImpl::IsPartialDownload() const {
-  DownloadState state = InternalToExternalState(state_);
-  return (state == IN_PROGRESS);
+bool DownloadItemImpl::IsDone() const {
+  switch (state_) {
+    case IN_PROGRESS_INTERNAL:
+    case COMPLETING_INTERNAL:
+      return false;
+
+    case COMPLETE_INTERNAL:
+    case CANCELLED_INTERNAL:
+      return true;
+
+    case INTERRUPTED_INTERNAL:
+      return !CanResume();
+
+    case RESUMING_INTERNAL:
+      return false;
+
+    case MAX_DOWNLOAD_INTERNAL_STATE:
+      break;
+  }
+  NOTREACHED();
+  return true;
 }
 
 bool DownloadItemImpl::IsInProgress() const {
   return InternalToExternalState(state_) == IN_PROGRESS;
 }
 
 bool DownloadItemImpl::IsCancelled() const {
   return  InternalToExternalState(state_) == CANCELLED;
 }
 
@@ skipping 169 matching lines @@
 bool DownloadItemImpl::CanShowInFolder() {
   // A download can be shown in the folder if the downloaded file is in a known
   // location.
   return CanOpenDownload() && !GetFullPath().empty();
 }
 
 bool DownloadItemImpl::CanOpenDownload() {
   // We can open the file or mark it for opening on completion if the download
   // is expected to complete successfully. Exclude temporary downloads, since
   // they aren't owned by the download system.
-  return (IsInProgress() || IsComplete()) && !IsTemporary() &&
-      !file_externally_removed_;
+  return (!IsDone() || IsComplete()) && !IsTemporary() &&
+         !file_externally_removed_;
 }
 
 bool DownloadItemImpl::ShouldOpenFileBasedOnExtension() {
   return delegate_->ShouldOpenFileBasedOnExtension(GetTargetFilePath());
 }
 
 bool DownloadItemImpl::GetOpenWhenComplete() const {
   return open_when_complete_;
 }
 
@@ skipping 973 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