Reland DownloadItem::Observer::OnDownloadDestroyed() replaces DownloadItem::REMOVING

chrome/browser/download/download_path_reservation_tracker.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.
 
 #include "chrome/browser/download/download_path_reservation_tracker.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 29 matching lines @@
 // and destroyed on the UI thread.
 class DownloadItemObserver : public DownloadItem::Observer {
  public:
   explicit DownloadItemObserver(DownloadItem& download_item);
 
  private:
   virtual ~DownloadItemObserver();
 
   // DownloadItem::Observer
   virtual void OnDownloadUpdated(DownloadItem* download) OVERRIDE;
-  virtual void OnDownloadOpened(DownloadItem* download) OVERRIDE;
+  virtual void OnDownloadDestroyed(DownloadItem* download) OVERRIDE;
 
   DownloadItem& download_item_;
 
   // Last known target path for the download.
   FilePath last_target_path_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItemObserver);
 };
 
 // Returns true if the given path is in use by a path reservation.
@@ skipping 155 matching lines @@
     }
 
     case DownloadItem::COMPLETE:
       // If the download is complete, then it has already been renamed to the
       // final name. The existence of the file on disk is sufficient to prevent
       // conflicts from now on.
 
     case DownloadItem::CANCELLED:
       // We no longer need the reservation if the download is being removed.
 
-    case DownloadItem::REMOVING:
-      // Ditto, but this case shouldn't happen in practice. We should have
-      // received another notification beforehand.
-
     case DownloadItem::INTERRUPTED:
       // The download filename will need to be re-generated when the download is
       // restarted. Holding on to the reservation now would prevent the name
       // from being used for a subsequent retry attempt.
 
       BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE,
           base::Bind(&RevokeReservation, download->GetGlobalId()));
       delete this;
       break;
 
     case DownloadItem::MAX_DOWNLOAD_STATE:
       // Compiler appeasement.
       NOTREACHED();
   }
 }
 
-void DownloadItemObserver::OnDownloadOpened(DownloadItem* download) {
-  // We shouldn't be tracking reservations for a download that has been
-  // externally opened. The tracker should have detached itself when the
-  // download was complete.
+void DownloadItemObserver::OnDownloadDestroyed(DownloadItem* download) {
+  // This shouldn't happen. We should catch either COMPLETE, CANCELLED, or
+  // INTERRUPTED first.
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+      base::Bind(&RevokeReservation, download->GetGlobalId()));
+  delete this;
 }
 
 }  // namespace
 
 // static
 void DownloadPathReservationTracker::GetReservedPath(
     DownloadItem& download_item,
     const FilePath& target_path,
     const FilePath& default_path,
     bool uniquify_path,
     const ReservedPathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Attach an observer to the download item so that we know when the target
   // path changes and/or the download is no longer active.
   new DownloadItemObserver(download_item);
   // DownloadItemObserver deletes itself.
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&CreateReservation, download_item.GetGlobalId(),
                  target_path, default_path, uniquify_path, callback));
 }
 
 // static
 bool DownloadPathReservationTracker::IsPathInUseForTesting(
     const FilePath& path) {
   return IsPathInUse(path);
 }