Handle the case where IAttachmentExecute::Save() deletes a downloaded file.

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
 // interfaces Start, DelayedDownloadOpened, MaybeCompleteDownload, and
 // OnDownloadCompleting are 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
@@ skipping 89 matching lines @@
   virtual void CancelRequest() const OVERRIDE {}
   virtual std::string DebugString() const OVERRIDE {
     return "Null DownloadRequestHandle";
   }
 };
 
 // Wrapper around DownloadFile::Detach and DownloadFile::Cancel that
 // takes ownership of the DownloadFile and hence implicitly destroys it
 // at the end of the function.
 static void DownloadFileDetach(
-    scoped_ptr<DownloadFile> download_file, base::Closure callback) {
+    scoped_ptr<DownloadFile> download_file,
+    const DownloadFile::DetachCompletionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   download_file->Detach(callback);
 }
 
 static void DownloadFileCancel(scoped_ptr<DownloadFile> download_file) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   download_file->Cancel();
 }
 
 }  // namespace
@@ skipping 714 matching lines @@
   // 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)
+  if (state_ != IN_PROGRESS_INTERNAL && state_ != COMPLETING_INTERNAL)
     return;
 
   last_reason_ = reason;
   TransitionTo(INTERRUPTED_INTERNAL);
 
   CancelDownloadFile();
 
   // Cancel the originating URL request.
   request_handle_->CancelRequest();
 
@@ skipping 333 matching lines @@
   VLOG(20) << __FUNCTION__ << "()"
            << " needs rename = " << NeedsRename()
            << " " << DebugString(true);
   DCHECK(!GetTargetFilePath().empty());
   DCHECK_NE(DANGEROUS, GetSafetyState());
 
   // TODO(rdsmith/benjhayden): Remove as part of SavePackage integration.
   if (is_save_package_download_) {
     // Avoid doing anything on the file thread; there's nothing we control
     // there.
-    OnDownloadFileReleased();
+    OnDownloadFileReleased(content::DOWNLOAD_INTERRUPT_REASON_NONE);
     return;
   }
 
   DCHECK(download_file_.get());
   if (NeedsRename()) {
     content::DownloadFile::RenameCompletionCallback callback =
         base::Bind(&DownloadItemImpl::OnDownloadRenamedToFinalName,
                    weak_ptr_factory_.GetWeakPtr());
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
@@ skipping 46 matching lines @@
                  base::Bind(&DownloadItemImpl::OnDownloadFileReleased,
                             weak_ptr_factory_.GetWeakPtr())));
 
   // We're not completely done with the download item yet, but at this
   // point we're committed to complete the download.  Cancels (or Interrupts,
   // though it's not clear how they could happen) after this point will be
   // ignored.
   TransitionTo(COMPLETING_INTERNAL);
 }
 
-void DownloadItemImpl::OnDownloadFileReleased() {
+void DownloadItemImpl::OnDownloadFileReleased(
+    content::DownloadInterruptReason reason) {
+  if (content::DOWNLOAD_INTERRUPT_REASON_NONE != reason) {
+    Interrupt(reason);
+    return;
+  }
   if (delegate_->ShouldOpenDownload(this))
     Completed();
   else
     delegate_delayed_complete_ = true;
 }
 
 void DownloadItemImpl::DelayedDownloadOpened(bool auto_opened) {
   auto_opened_ = auto_opened;
   Completed();
 }
@@ skipping 23 matching lines @@
     auto_opened_ = true;
     UpdateObservers();
   }
 }
 
 // **** End of Download progression cascade
 
 void DownloadItemImpl::CancelDownloadFile() {
   // TODO(rdsmith/benjhayden): Remove condition as part of
   // SavePackage integration.
-  if (!is_save_package_download_) {
-    DCHECK(download_file_.get());
+  // 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_.Pass())));
   }
 }
 
 bool DownloadItemImpl::IsDownloadReadyForCompletion() {
   // If we don't have all the data, the download is not ready for
   // completion.
@@ skipping 153 matching lines @@
       return "COMPLETE";
     case CANCELLED_INTERNAL:
       return "CANCELLED";
     case INTERRUPTED_INTERNAL:
       return "INTERRUPTED";
     default:
       NOTREACHED() << "Unknown download state " << state;
       return "unknown";
   };
 }