Make DownloadHistory observe manager, items

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 "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
@@ skipping 18 matching lines @@
  public:
   DownloadItemObserver(DownloadItem& download_item,
                        base::Closure revoke,
                        base::Callback<void(const FilePath&)> update);
 
  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_;
 
   // Callback to invoke to revoke the path reseration.
   base::Closure revoke_callback_;
 
   // Callback to invoke to update the path reservation.
@@ skipping 32 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, revoke_callback_);
       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, revoke_callback_);
+  delete this;
 }
 
 }  // namespace
 
 // static
 void DownloadPathReservationTracker::GetReservedPath(
     DownloadItem& download_item,
     const FilePath& target_path,
     const FilePath& default_path,
     bool uniquify_path,
@@ skipping 124 matching lines @@
   reservations_.erase(download_id);
 }
 
 // static
 DownloadPathReservationTracker* DownloadPathReservationTracker::GetInstance() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   static base::LazyInstance<DownloadPathReservationTracker>
       reservation_tracker = LAZY_INSTANCE_INITIALIZER;
   return reservation_tracker.Pointer();
 }