Download code cleanup patch of death:

chrome/browser/download/download_manager.h

 // Copyright (c) 2010 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 profile in Chrome.
 //
 // Download observers:
@@ skipping 19 matching lines @@
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/observer_list.h"
 #include "base/ref_counted.h"
+#include "base/scoped_ptr.h"
 #include "base/time.h"
-#include "chrome/browser/cancelable_request.h"
-#include "chrome/browser/history/history.h"
+#include "chrome/browser/download/download_history.h"
 #include "chrome/browser/pref_member.h"
 #include "chrome/browser/shell_dialogs.h"
 
 class DownloadFileManager;
 class DownloadItem;
 class GURL;
 class PrefService;
 class Profile;
 class ResourceDispatcherHost;
 class URLRequestContextGetter;
 class TabContents;
+struct DownloadCreateInfo;
 struct DownloadSaveInfo;
 
 // Browser's download manager: manages all downloads and destination view.
 class DownloadManager : public base::RefCountedThreadSafe<DownloadManager>,
+                        public DownloadHistory::DownloadItemMapper,
                         public SelectFileDialog::Listener {
   // For testing.
   friend class DownloadManagerTest;
   friend class MockDownloadManager;
 
  public:
-  // A fake download table ID which representas a download that has started,
-  // but is not yet in the table.
-  static const int kUninitializedHandle;
-
   DownloadManager();
 
   static void RegisterUserPrefs(PrefService* prefs);
 
   // Interface to implement for observers that wish to be informed of changes
   // to the DownloadManager's collection of downloads.
   class Observer {
    public:
     // New or deleted download, observers should query us for the current set
     // of downloads.
     virtual void ModelChanged() = 0;
 
-    // A callback once the DownloadManager has retrieved the requested set of
-    // downloads. The DownloadManagerObserver must copy the vector, but does not
-    // own the individual DownloadItems, when this call is made.
-    virtual void SetDownloads(std::vector<DownloadItem*>& downloads) = 0;
-
     // Called when the DownloadManager is being destroyed to prevent Observers
     // from calling back to a stale pointer.
     virtual void ManagerGoingDown() {}
 
    protected:
     virtual ~Observer() {}
   };
 
-  // Public API
-
-  // If this download manager has an incognito profile, find all incognito
-  // downloads and pass them along to the parent profile's download manager
-  // via DoGetDownloads. Otherwise, just call DoGetDownloads().
-  void GetDownloads(Observer* observer,
-                    const std::wstring& search_text);
-
-  // Begin a search for all downloads matching 'search_text'. If 'search_text'
-  // is empty, return all known downloads. The results are returned in the
-  // 'SetDownloads' observer callback.
-  void DoGetDownloads(Observer* observer,
-                      const std::wstring& search_text,
-                      std::vector<DownloadItem*>& otr_downloads);
-
   // Return all temporary downloads that reside in the specified directory.
-  void GetTemporaryDownloads(Observer* observer,
-                             const FilePath& dir_path);
+  void GetTemporaryDownloads(const FilePath& dir_path,
+                             std::vector<DownloadItem*>* result);
 
   // Return all non-temporary downloads in the specified directory that are
   // are in progress or have finished.
-  void GetAllDownloads(Observer* observer, const FilePath& dir_path);
+  void GetAllDownloads(const FilePath& dir_path,
+                       std::vector<DownloadItem*>* result);
 
   // Return all non-temporary downloads in the specified directory that are
   // either in-progress or finished but still waiting for user confirmation.
-  void GetCurrentDownloads(Observer* observer, const FilePath& dir_path);
+  void GetCurrentDownloads(const FilePath& dir_path,
+                           std::vector<DownloadItem*>* result);
 
   // Returns true if initialized properly.
   bool Init(Profile* profile);
 
-  // Schedule a query of the history service to retrieve all downloads.
-  void QueryHistoryForDownloads();
-
-  // Cleans up IN_PROGRESS history entries as these entries are corrupt because
-  // of the sudden exit. Changes them to CANCELED. Executed only when called
-  // first time, subsequent calls a no op.
-  void CleanUpInProgressHistoryEntries();
-
   // Notifications sent from the download thread to the UI thread
   void StartDownload(DownloadCreateInfo* info);
   void UpdateDownload(int32 download_id, int64 size);
   void DownloadFinished(int32 download_id, int64 size);
 
   // Called from a view when a user clicks a UI button or link.
   void DownloadCancelled(int32 download_id);
   void PauseDownload(int32 download_id, bool pause);
   void RemoveDownload(int64 download_handle);
 
@@ skipping 33 matching lines @@
   // Allow objects to observe the download creation process.
   void AddObserver(Observer* observer);
 
   // Remove a download observer from ourself.
   void RemoveObserver(Observer* observer);
 
   // Methods called on completion of a query sent to the history system.
   void OnQueryDownloadEntriesComplete(
       std::vector<DownloadCreateInfo>* entries);
   void OnCreateDownloadEntryComplete(DownloadCreateInfo info, int64 db_handle);
-  void OnSearchComplete(HistoryService::Handle handle,
-                        std::vector<int64>* results);
 
   // Display a new download in the appropriate browser UI.
   void ShowDownloadInBrowser(const DownloadCreateInfo& info,
                              DownloadItem* download);
 
   // Opens a download. For Chrome extensions call
   // ExtensionsServices::InstallExtension, for everything else call
   // OpenDownloadInShell.
   void OpenDownload(const DownloadItem* download,
                     gfx::NativeView parent_window);
 
   // Show a download via the Windows shell.
   void ShowDownloadInShell(const DownloadItem* download);
 
   // The number of in progress (including paused) downloads.
   int in_progress_count() const {
     return static_cast<int>(in_progress_.size());
   }
 
   FilePath download_path() { return *download_path_; }
 
+  DownloadHistory* download_history() { return download_history_.get(); }
+
   // Clears the last download path, used to initialize "save as" dialogs.
   void ClearLastDownloadPath();
 
   // Registers this file extension for automatic opening upon download
   // completion if 'open' is true, or prevents the extension from automatic
   // opening if 'open' is false.
   void OpenFilesBasedOnExtension(const FilePath& path, bool open);
 
   // Tests if a file type should be opened automatically.
   bool ShouldOpenFileBasedOnExtension(const FilePath& path) const;
 
   // Tests if we think the server means for this mime_type to be executable.
   static bool IsExecutableMimeType(const std::string& mime_type);
 
   // Tests if a file is considered executable, based on its type.
   bool IsExecutableFile(const FilePath& path) const;
 
   // Tests if a file type is considered executable.
   static bool IsExecutableExtension(const FilePath::StringType& extension);
 
   // Resets the automatic open preference.
   void ResetAutoOpenFiles();
 
   // Returns true if there are automatic handlers registered for any file
   // types.
   bool HasAutoOpenFileTypesRegistered() const;
 
+  // Overridden from DownloadHistory::DownloadItemMapper:
+  virtual DownloadItem* GetDownloadItemFromDbHandle(int64 db_handle);
+
   // Overridden from SelectFileDialog::Listener:
   virtual void FileSelected(const FilePath& path, int index, void* params);
   virtual void FileSelectionCanceled(void* params);
 
   // Deletes the specified path on the file thread.
   void DeleteDownload(const FilePath& path);
 
   // Called when the user has validated the download of a dangerous file.
   void DangerousDownloadValidated(DownloadItem* download);
 
   // Used to make sure we have a safe file extension and filename for a
   // download.  |file_name| can either be just the file name or it can be a
   // full path to a file.
   static void GenerateSafeFileName(const std::string& mime_type,
                                    FilePath* file_name);
 
   // Create a file name based on the response from the server.
   static void GenerateFileName(const GURL& url,
                                const std::string& content_disposition,
                                const std::string& referrer_charset,
                                const std::string& mime_type,
                                FilePath* generated_name);
 
  private:
-  class FakeDbHandleGenerator {
-   public:
-    explicit FakeDbHandleGenerator(int64 start_value) : value_(start_value) {}
-
-    int64 GetNext() { return value_--; }
-   private:
-    int64 value_;
-  };
-
   // This class is used to let an incognito DownloadManager observe changes to
   // a normal DownloadManager, to propagate ModelChanged() calls from the parent
   // DownloadManager to the observers of the incognito DownloadManager.
   class OtherDownloadManagerObserver : public Observer {
    public:
     explicit OtherDownloadManagerObserver(
         DownloadManager* observing_download_manager);
     virtual ~OtherDownloadManagerObserver();
 
     // Observer interface.
     virtual void ModelChanged();
-    virtual void SetDownloads(std::vector<DownloadItem*>& downloads);
     virtual void ManagerGoingDown();
 
    private:
     // The incognito download manager.
     DownloadManager* observing_download_manager_;
 
     // The original profile's download manager.
     DownloadManager* observed_download_manager_;
   };
 
@@ skipping 23 matching lines @@
   // Called on the UI thread once the DownloadManager has determined whether the
   // suggested file path exists.
   void OnPathExistenceAvailable(DownloadCreateInfo* info);
 
   // 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.
   void ContinueStartDownload(DownloadCreateInfo* info,
                              const FilePath& target_path);
 
-  // Update the history service for a particular download.
-  // Marked virtual for testing.
-  virtual void UpdateHistoryForDownload(DownloadItem* download);
-  void RemoveDownloadFromHistory(DownloadItem* download);
-  void RemoveDownloadsFromHistoryBetween(const base::Time remove_begin,
-                                         const base::Time remove_before);
-
   // Create an extension based on the file name and mime type.
   static void GenerateExtension(const FilePath& file_name,
                                 const std::string& mime_type,
                                 FilePath::StringType* generated_extension);
 
   // Create a file name based on the response from the server.
   static void GenerateFileNameFromInfo(DownloadCreateInfo* info,
                                        FilePath* generated_name);
 
   // Persist the automatic opening preference.
@@ skipping 79 matching lines @@
   // True if the download manager has been initialized and requires a shutdown.
   bool shutdown_needed_;
 
   // Observers that want to be notified of changes to the set of downloads.
   ObserverList<Observer> observers_;
 
   // The current active profile.
   Profile* profile_;
   scoped_refptr<URLRequestContextGetter> request_context_getter_;
 
-  // Used for history service request management.
-  CancelableRequestConsumerTSimple<Observer*> cancelable_consumer_;
+  scoped_ptr<DownloadHistory> download_history_;
 
   // Non-owning pointer for handling file writing on the download_thread_.
   DownloadFileManager* file_manager_;
 
   // User preferences
   BooleanPrefMember prompt_for_download_;
   FilePathPrefMember download_path_;
 
   // The user's last choice for download directory. This is only used when the
   // user wants us to prompt for a save location for each download.
@@ skipping 14 matching lines @@
   // after this determination is made.
   // The map is of download_id->remaining size (bytes), both of which are
   // required when calling DownloadFinished.
   typedef std::map<int32, int64> PendingFinishedMap;
   PendingFinishedMap pending_finished_downloads_;
 
   // The "Save As" dialog box used to ask the user where a file should be
   // saved.
   scoped_refptr<SelectFileDialog> select_file_dialog_;
 
-  // In case we don't have a valid db_handle, we use |fake_db_handle_| instead.
-  // This is useful for incognito mode or when the history database is offline.
-  // Downloads are expected to have unique handles, so FakeDbHandleGenerator
-  // automatically decrement the handle value on every use.
-  FakeDbHandleGenerator fake_db_handle_;
-
   scoped_ptr<OtherDownloadManagerObserver> other_download_manager_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadManager);
 };
 
 #endif  // CHROME_BROWSER_DOWNLOAD_DOWNLOAD_MANAGER_H_