[Resumption 7/11] Add a CanResume() method to DownloadItem.

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 60 matching lines @@
 static void DownloadFileDetach(scoped_ptr<DownloadFile> download_file) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   download_file->Detach();
 }
 
 static void DownloadFileCancel(scoped_ptr<DownloadFile> download_file) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   download_file->Cancel();
 }
 
+bool IsDownloadResumptionEnabled() {
+  return CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableDownloadResumption);
+}
+
 }  // 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,
@@ skipping 376 matching lines @@
 }
 
 bool DownloadItemImpl::IsPaused() const {
   return is_paused_;
 }
 
 bool DownloadItemImpl::IsTemporary() const {
   return is_temporary_;
 }
 
+bool DownloadItemImpl::CanResume() const {
+  if (IsInProgress() && 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);
+}
+
 // 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::IsInProgress() const {
@@ skipping 851 matching lines @@
   // Whatever happens, the first one to hit the UI thread wins.
   if (state_ != IN_PROGRESS_INTERNAL && state_ != RESUMING_INTERNAL)
     return;
 
   last_reason_ = reason;
 
   ResumeMode resume_mode = GetResumeMode();
   // 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.
-  bool resumption_enabled = CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kEnableDownloadResumption);
   ReleaseDownloadFile(resume_mode == RESUME_MODE_IMMEDIATE_RESTART ||
                       resume_mode == RESUME_MODE_USER_RESTART ||
-                      !resumption_enabled);
+                      !IsDownloadResumptionEnabled());
 
   // 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
   // b) if there were, that would probably simply result in a null range
   // request, which would generate a DestinationCompleted() notification
   // from the DownloadFile, which would behave properly with setting
@@ skipping 301 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