chrome.experimental.downloads

chrome/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 profile in Chrome.
 //
 // Download observers:
@@ skipping 35 matching lines @@
 #include "chrome/browser/download/download_request_handle.h"
 #include "chrome/browser/download/download_status_updater_delegate.h"
 #include "chrome/browser/ui/shell_dialogs.h"
 #include "content/browser/browser_thread.h"
 
 class DownloadFileManager;
 class DownloadHistory;
 class DownloadPrefs;
 class DownloadStatusUpdater;
 class GURL;
+class ListValue;
 class Profile;
 class ResourceDispatcherHost;
 class TabContents;
 struct DownloadCreateInfo;
 struct DownloadHistoryInfo;
 struct DownloadSaveInfo;
+namespace download_util {
+// Try to avoid including download_query.h because it defines some macros.
+class DownloadQuery;
+}  // namespace download_util
 
 // Browser's download manager: manages all downloads and destination view.
 class DownloadManager
     : public base::RefCountedThreadSafe<DownloadManager,
                                         BrowserThread::DeleteOnUIThread>,
       public DownloadStatusUpdaterDelegate,
       public SelectFileDialog::Listener {
  public:
+  typedef std::vector<DownloadItem*> ItemVector;
+
   explicit DownloadManager(DownloadStatusUpdater* status_updater);
 
   // Shutdown the download manager. Must be called before destruction.
   void Shutdown();
 
   // 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;
 
     // Called when the DownloadManager is being destroyed to prevent Observers
     // from calling back to a stale pointer.
     virtual void ManagerGoingDown() {}
 
     // Called immediately after the DownloadManager puts up a select file
     // dialog.
     // |id| indicates which download opened the dialog.
     virtual void SelectFileDialogDisplayed(int32 id) {}
 
    protected:
     virtual ~Observer() {}
   };
 
   // Return all temporary downloads that reside in the specified directory.
   void GetTemporaryDownloads(const FilePath& dir_path,
-                             std::vector<DownloadItem*>* result);
+                             ItemVector* result);
 
   // Return all non-temporary downloads in the specified directory that are
   // are in progress or have completed.
   void GetAllDownloads(const FilePath& dir_path,
-                       std::vector<DownloadItem*>* result);
+                       ItemVector* result);
 
   // Return all non-temporary downloads in the specified directory that are
   // in-progress (including dangerous downloads waiting for user confirmation).
   void GetCurrentDownloads(const FilePath& dir_path,
-                           std::vector<DownloadItem*>* result);
+                           ItemVector* result);
+
+  bool Search(const download_util::DownloadQuery& query,
+              ItemVector* results = NULL,
+              bool merge_parent_manager = true,
+              std::string* error_msg = NULL,
+              ListValue* json_results = NULL) const;
 
   // Returns all non-temporary downloads matching |query|. Empty query matches
   // everything.
   void SearchDownloads(const string16& query,
-                       std::vector<DownloadItem*>* result);
+                       ItemVector* result);
 
   // Returns true if initialized properly.
   bool Init(Profile* profile);
 
   // Notifications sent from the download thread to the UI thread
   void StartDownload(int32 id);
   void UpdateDownload(int32 download_id, int64 size);
   // |hash| is sha256 hash for the downloaded file. It is empty when the hash
   // is not available.
   void OnResponseCompleted(int32 download_id, int64 size, int os_error,
                            const std::string& hash);
 
   // Called from a view when a user clicks a UI button or link.
   void DownloadCancelled(int32 download_id);
-  void RemoveDownload(int64 download_handle);
+  void RemoveDownload(int64 id);
 
   // Determine if the download is ready for completion, i.e. has had
   // all data saved, and completed the filename determination and
   // history insertion.
   bool IsDownloadReadyForCompletion(DownloadItem* download);
 
   // 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.)
@@ skipping 46 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<DownloadHistoryInfo>* entries);
-  void OnCreateDownloadEntryComplete(int32 download_id, int64 db_handle);
+  void OnCreateDownloadEntryComplete(int32 download_id);
 
   // Display a new download in the appropriate browser UI.
   void ShowDownloadInBrowser(DownloadItem* download);
 
   // The number of in progress (including paused) downloads.
   int in_progress_count() const {
-    return static_cast<int>(in_progress_.size());
+    return GetInProgressDownloadCount();
   }
 
   Profile* profile() { return profile_; }
 
   DownloadPrefs* download_prefs() { return download_prefs_.get(); }
 
   // Creates the download item.  Must be called on the UI thread.
   void CreateDownloadItem(DownloadCreateInfo* info);
 
   // Clears the last download path, used to initialize "save as" dialogs.
   void ClearLastDownloadPath();
 
   // Tests if a file type should be opened automatically.
   bool ShouldOpenFileBasedOnExtension(const FilePath& path) const;
 
   // Overridden from DownloadStatusUpdaterDelegate:
   virtual bool IsDownloadProgressKnown();
-  virtual int64 GetInProgressDownloadCount();
+  virtual int64 GetInProgressDownloadCount() const;
   virtual int64 GetReceivedDownloadBytes();
   virtual int64 GetTotalDownloadBytes();
 
   // Overridden from SelectFileDialog::Listener:
   virtual void FileSelected(const FilePath& path, int index, void* params);
   virtual void FileSelectionCanceled(void* params);
 
   // Returns true if this download should show the "dangerous file" warning.
   // Various factors are considered, such as the type of the file, whether a
   // user action initiated the download, and whether the user has explicitly
@@ skipping 60 matching lines @@
     // The original profile's download manager.
     DownloadManager* observed_download_manager_;
   };
 
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
   friend class DeleteTask<DownloadManager>;
   friend class OtherDownloadManagerObserver;
 
   virtual ~DownloadManager();
 
+  void MergeItems(bool merge_parent_manager,
+                  ItemVector* items) const;
+
   // Called on the FILE thread to check the existence of a downloaded file.
-  void CheckForFileRemovalOnFileThread(int64 db_handle, const FilePath& path);
+  void CheckForFileRemovalOnFileThread(int64 id, const FilePath& path);
 
   // Called on the UI thread if the FILE thread detects the removal of
   // the downloaded file. The UI thread updates the state of the file
   // and then notifies this update to the file's observer.
-  void OnFileRemovalDetected(int64 db_handle);
+  void OnFileRemovalDetected(int64 id);
 
   // Called on the download thread to check whether the suggested file path
   // exists.  We don't check if the file exists on the UI thread to avoid UI
   // stalls from interacting with the file system.
   void CheckIfSuggestedPathExists(int32 download_id,
                                   DownloadStateInfo state,
                                   const FilePath& default_path);
 
   // Called on the UI thread once the DownloadManager has determined whether the
   // suggested file path exists.
@@ skipping 26 matching lines @@
 
   // Get the download item from the active map.  Useful when the item is not
   // yet in the history map.
   DownloadItem* GetActiveDownloadItem(int id);
 
   // Debugging routine to confirm relationship between below
   // containers; no-op if NDEBUG.
   void AssertContainersConsistent() const;
 
   // Add a DownloadItem to history_downloads_.
-  void AddDownloadItemToHistory(DownloadItem* item, int64 db_handle);
+  void AddDownloadItemToHistory(DownloadItem* item);
 
-  // |downloads_| is the owning set for all downloads known to the
-  // DownloadManager.  This includes downloads started by the user in
-  // this session, downloads initialized from the history system, and
-  // "save page as" downloads.  All other DownloadItem containers in
-  // the DownloadManager are maps; they do not own the DownloadItems.
-  // Note that this is the only place (with any functional implications;
-  // see save_page_as_downloads_ below) that "save page as" downloads are
-  // kept, as the DownloadManager's only job is to hold onto those
-  // until destruction.
-  //
-  // |history_downloads_| is map of all downloads in this profile. The key
-  // is the handle returned by the history system, which is unique
-  // across sessions.
-  //
-  // |active_downloads_| is a map of all downloads that are currently being
-  // processed. The key is the ID assigned by the ResourceDispatcherHost,
-  // which is unique for the current session.
-  //
-  // |in_progress_| is a map of all downloads that are in progress and that have
-  // not yet received a valid history handle. The key is the ID assigned by the
-  // ResourceDispatcherHost, which is unique for the current session.
-  //
-  // |save_page_as_downloads_| (if defined) is a collection of all the
-  // downloads the "save page as" system has given to us to hold onto
-  // until we are destroyed.  It is only used for debugging.
-  //
-  // When a download is created through a user action, the corresponding
-  // DownloadItem* is placed in |active_downloads_| and remains there until the
-  // download is in a terminal state (COMPLETE or CANCELLED).  It is also
-  // placed in |in_progress_| and remains there until it has received a
-  // valid handle from the history system. Once it has a valid handle, the
-  // DownloadItem* is placed in the |history_downloads_| map.  When the
-  // download reaches a terminal state, it is removed from |in_progress_|.
-  // Downloads from past sessions read from a persisted state from the
-  // history system are placed directly into |history_downloads_| since
-  // they have valid handles in the history system.
   typedef std::set<DownloadItem*> DownloadSet;
   typedef base::hash_map<int64, DownloadItem*> DownloadMap;
 
-  DownloadSet downloads_;
-  DownloadMap history_downloads_;
-  DownloadMap in_progress_;
-  DownloadMap active_downloads_;
 #if !defined(NDEBUG)
   DownloadSet save_page_as_downloads_;
 #endif
 
+  // Map from id to DownloadItem. Owns the DownloadItem.
+  DownloadMap downloads_;
+
   // 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_ptr<DownloadHistory> download_history_;
@@ skipping 13 matching lines @@
   // The "Save As" dialog box used to ask the user where a file should be
   // saved.
   scoped_refptr<SelectFileDialog> select_file_dialog_;
 
   scoped_ptr<OtherDownloadManagerObserver> other_download_manager_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadManager);
 };
 
 #endif  // CHROME_BROWSER_DOWNLOAD_DOWNLOAD_MANAGER_H_