Revert 113007 - DownloadManager intereface refactoring to allow cleaner DownloadItem unit tests.

content/browser/download/download_manager.h

 // Copyright (c) 2011 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.
 //
 // The DownloadManager object manages the process of downloading, including
 // updates to the history system and providing the information for displaying
 // the downloads view in the Destinations tab. There is one DownloadManager per
 // active browser context in Chrome.
 //
 // Download observers:
@@ skipping 106 matching lines @@
 
   // Offthread target for cancelling a particular download.  Will be a no-op
   // if the download has already been cancelled.
   virtual void CancelDownload(int32 download_id) = 0;
 
   // Called when there is an error in the download.
   // |download_id| is the ID of the download.
   // |size| is the number of bytes that are currently downloaded.
   // |reason| is a download interrupt reason code.
   virtual void OnDownloadInterrupted(int32 download_id, int64 size,
-                                     InterruptReason reason) = 0;
+                             InterruptReason reason) = 0;
+
+  // Called from DownloadItem to handle the DownloadManager portion of a
+  // Cancel; should not be called from other locations.
+  virtual void DownloadCancelledInternal(DownloadItem* download) = 0;
+
+  // Called from a view when a user clicks a UI button or link.
+  virtual void RemoveDownload(int64 download_handle) = 0;
+
+  // Determine if the download is ready for completion, i.e. has had
+  // all data saved, and completed the filename determination and
+  // history insertion.
+  virtual bool IsDownloadReadyForCompletion(DownloadItem* download) = 0;
+
+  // If all pre-requisites have been met, complete download processing, i.e.
+  // do internal cleanup, file rename, and potentially auto-open.
+  // (Dangerous downloads still may block on user acceptance after this
+  // point.)
+  virtual void MaybeCompleteDownload(DownloadItem* download) = 0;
 
   // Called when the download is renamed to its final name.
   // |uniquifier| is a number used to make unique names for the file.  It is
   // only valid for the DANGEROUS_BUT_VALIDATED state of the download item.
   virtual void OnDownloadRenamedToFinalName(int download_id,
                                     const FilePath& full_path,
                                     int uniquifier) = 0;
 
   // Remove downloads after remove_begin (inclusive) and before remove_end
   // (exclusive). You may pass in null Time values to do an unbounded delete
   // in either direction.
   virtual int RemoveDownloadsBetween(const base::Time remove_begin,
                              const base::Time remove_end) = 0;
 
   // Remove downloads will delete all downloads that have a timestamp that is
   // the same or more recent than |remove_begin|. The number of downloads
   // deleted is returned back to the caller.
   virtual int RemoveDownloads(const base::Time remove_begin) = 0;
 
   // Remove all downloads will delete all downloads. The number of downloads
   // deleted is returned back to the caller.
   virtual int RemoveAllDownloads() = 0;
 
+  // Final download manager transition for download: Update the download
+  // history and remove the download from |active_downloads_|.
+  virtual void DownloadCompleted(int32 download_id) = 0;
+
   // Download the object at the URL. Used in cases such as "Save Link As..."
   virtual void DownloadUrl(const GURL& url,
                    const GURL& referrer,
                    const std::string& referrer_encoding,
                    TabContents* tab_contents) = 0;
 
   // Download the object at the URL and save it to the specified path. The
   // download is treated as the temporary download and thus will not appear
   // in the download history. Used in cases such as drag and drop.
   virtual void DownloadUrlToFile(const GURL& url,
@@ skipping 11 matching lines @@
   // Called by the embedder, after creating the download manager, to let it know
   // about downloads from previous runs of the browser.
   virtual void OnPersistentStoreQueryComplete(
       std::vector<DownloadPersistentStoreInfo>* entries) = 0;
 
   // Called by the embedder, in response to
   // DownloadManagerDelegate::AddItemToPersistentStore.
   virtual void OnItemAddedToPersistentStore(int32 download_id,
                                             int64 db_handle) = 0;
 
+  // Display a new download in the appropriate browser UI.
+  virtual void ShowDownloadInBrowser(DownloadItem* download) = 0;
+
   // The number of in progress (including paused) downloads.
   virtual int InProgressCount() const = 0;
 
-  virtual content::BrowserContext* BrowserContext() const = 0;
+  virtual content::BrowserContext* BrowserContext() = 0;
 
   virtual FilePath LastDownloadPath() = 0;
 
   // Creates the download item.  Must be called on the UI thread.
-  virtual void CreateDownloadItem(
-      DownloadCreateInfo* info,
-      const DownloadRequestHandle& request_handle) = 0;
-
-  // Creates a download item for the SavePackage system.
-  // Must be called on the UI thread.  Note that the DownloadManager
-  // retains ownership.
-  virtual DownloadItem* CreateSavePackageDownloadItem(
-      const FilePath& main_file_path,
-      const GURL& page_url,
-      bool is_otr,
-      DownloadItem::Observer* observer) = 0;
+  virtual void CreateDownloadItem(DownloadCreateInfo* info,
+                          const DownloadRequestHandle& request_handle) = 0;
 
   // Clears the last download path, used to initialize "save as" dialogs.
   virtual void ClearLastDownloadPath() = 0;
 
   // Called by the delegate after the save as dialog is closed.
   virtual void FileSelected(const FilePath& path, void* params) = 0;
   virtual void FileSelectionCanceled(void* params) = 0;
 
   // Called by the delegate if it delayed the download in
   // DownloadManagerDelegate::ShouldStartDownload and now is ready.
   virtual void RestartDownload(int32 download_id) = 0;
 
+  // Mark the download opened in the persistent store.
+  virtual void MarkDownloadOpened(DownloadItem* download) = 0;
+
   // Checks whether downloaded files still exist. Updates state of downloads
   // that refer to removed files. The check runs in the background and may
   // finish asynchronously after this method returns.
   virtual void CheckForHistoryFilesRemoval() = 0;
 
+  // Checks whether a downloaded file still exists and updates the file's state
+  // if the file is already removed. The check runs in the background and may
+  // finish asynchronously after this method returns.
+  virtual void CheckForFileRemoval(DownloadItem* download_item) = 0;
+
+  // Assert the named download item is on the correct queues
+  // in the DownloadManager.  For debugging.
+  virtual void AssertQueueStateConsistent(DownloadItem* download) = 0;
+
   // Get the download item from the history map.  Useful after the item has
   // been removed from the active map, or was retrieved from the history DB.
   virtual DownloadItem* GetDownloadItem(int id) = 0;
 
+  // Called when Save Page download starts. Transfers ownership of |download|
+  // to the DownloadManager.
+  virtual void SavePageDownloadStarted(DownloadItem* download) = 0;
+
   // Called when Save Page download is done.
   virtual void SavePageDownloadFinished(DownloadItem* download) = 0;
 
   // Get the download item from the active map.  Useful when the item is not
   // yet in the history map.
   virtual DownloadItem* GetActiveDownloadItem(int id) = 0;
 
   virtual content::DownloadManagerDelegate* delegate() const = 0;
 
   // For testing only.  May be called from tests indirectly (through
   // other for testing only methods).
   virtual void SetDownloadManagerDelegate(
       content::DownloadManagerDelegate* delegate) = 0;
 
+  virtual DownloadId GetNextId() = 0;
+
  protected:
   // These functions are here for unit tests.
 
   // Called back after a target path for the file to be downloaded to has been
   // determined, either automatically based on the suggested file name, or by
   // the user in a Save As dialog box.
   virtual void ContinueDownloadWithPath(DownloadItem* download,
                                         const FilePath& chosen_file) = 0;
 
   // Retrieves the download from the |download_id|.
   // Returns NULL if the download is not active.
   virtual DownloadItem* GetActiveDownload(int32 download_id) = 0;
 
   virtual void SetFileManager(DownloadFileManager* file_manager) = 0;
 
  private:
   // For testing.
   friend class DownloadManagerTest;
 
   friend class base::RefCountedThreadSafe<
       DownloadManager, content::BrowserThread::DeleteOnUIThread>;
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::UI>;
   friend class DeleteTask<DownloadManager>;
 };
 
 #endif  // CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_MANAGER_H_