Reduced the lifetime of DownloadCreateInfo.

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 23 matching lines @@
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
+#include "chrome/browser/download/download_item.h"
 #include "chrome/browser/download/download_status_updater_delegate.h"
 #include "chrome/browser/download/download_process_handle.h"
 #include "chrome/browser/ui/shell_dialogs.h"
 #include "content/browser/browser_thread.h"
 
 class DownloadFileManager;
 class DownloadHistory;
-class DownloadItem;
 class DownloadPrefs;
 class DownloadStatusUpdater;
 class GURL;
 class Profile;
 class ResourceDispatcherHost;
 class TabContents;
 struct DownloadCreateInfo;
+struct DownloadHistoryInfo;
 struct DownloadSaveInfo;
 
 // Browser's download manager: manages all downloads and destination view.
 class DownloadManager
     : public base::RefCountedThreadSafe<DownloadManager,
                                         BrowserThread::DeleteOnUIThread>,
       public DownloadStatusUpdaterDelegate,
       public SelectFileDialog::Listener {
  public:
   explicit DownloadManager(DownloadStatusUpdater* status_updater);
@@ skipping 38 matching lines @@
 
   // Returns all non-temporary downloads matching |query|. Empty query matches
   // everything.
   void SearchDownloads(const string16& query,
                        std::vector<DownloadItem*>* result);
 
   // Returns true if initialized properly.
   bool Init(Profile* profile);
 
   // Notifications sent from the download thread to the UI thread
-  void StartDownload(DownloadCreateInfo* info);
+  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 PauseDownload(int32 download_id, bool pause);
   void RemoveDownload(int64 download_handle);
@@ skipping 55 matching lines @@
                          TabContents* tab_contents);
 
   // 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);
+      std::vector<DownloadHistoryInfo>* entries);
+  void OnCreateDownloadEntryComplete(int32 download_id, int64 db_handle);
 
   // Display a new download in the appropriate browser UI.
-  void ShowDownloadInBrowser(DownloadProcessHandle* process_handle,
-                             DownloadItem* download);
+  void ShowDownloadInBrowser(DownloadItem* download);
 
   // The number of in progress (including paused) downloads.
   int in_progress_count() const {
     return static_cast<int>(in_progress_.size());
   }
 
   Profile* profile() { return profile_; }
 
   DownloadHistory* download_history() { return download_history_.get(); }
 
@@ skipping 11 matching lines @@
   // Overridden from DownloadStatusUpdaterDelegate:
   virtual bool IsDownloadProgressKnown();
   virtual int64 GetInProgressDownloadCount();
   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
+  // marked the file type as "auto open".
+  bool IsDangerous(const DownloadItem& download,
+                   const DownloadStateInfo& state);
+
   // Called when the user has validated the download of a dangerous file.
   void DangerousDownloadValidated(DownloadItem* download);
 
   // Callback function after url is checked with safebrowsing service.
-  void CheckDownloadUrlDone(DownloadCreateInfo* info, bool is_dangerous_url);
+  void CheckDownloadUrlDone(int32 download_id, bool is_dangerous_url);
 
   // Callback function after download file hash is checked with safebrowsing
   // service.
   void CheckDownloadHashDone(int32 download_id, bool is_dangerous_hash);
 
  private:
   // For testing.
   friend class DownloadManagerTest;
   friend class MockDownloadManager;
 
@@ skipping 20 matching lines @@
 
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
   friend class DeleteTask<DownloadManager>;
   friend class OtherDownloadManagerObserver;
 
   ~DownloadManager();
 
   // 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(DownloadCreateInfo* info,
+  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.
-  void OnPathExistenceAvailable(DownloadCreateInfo* info);
+  void OnPathExistenceAvailable(int32 download_id,
+                                DownloadStateInfo new_state);
 
   // 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 AttachDownloadItem(DownloadCreateInfo* info);
+  void ContinueDownloadWithPath(DownloadItem* download,
+                                const FilePath& chosen_file);
 
   // Download cancel helper function.
   // |process_handle| is passed by value because it is ultimately passed to
   // other threads, and this way we don't have to worry about object lifetimes.
   void DownloadCancelledInternal(int download_id,
                                  DownloadProcessHandle process_handle);
 
   // All data has been downloaded.
   // |hash| is sha256 hash for the downloaded file. It is empty when the hash
   // is not available.
   void OnAllDataSaved(int32 download_id, int64 size, const std::string& hash);
 
   // An error occurred in the download.
   void OnDownloadError(int32 download_id, int64 size, int os_error);
 
   // Updates the app icon about the overall download progress.
   void UpdateAppIcon();
 
   // Makes the ResourceDispatcherHost pause/un-pause a download request.
   // Called on the IO thread.
   // |process_handle| is passed by value because this is called from other
   // threads, and this way we don't have to worry about object lifetimes.
   void PauseDownloadRequest(ResourceDispatcherHost* rdh,
                             DownloadProcessHandle process_handle,
                             bool pause);
 
   // Inform observers that the model has changed.
   void NotifyModelChanged();
 
+  // 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.
   DownloadItem* GetDownloadItem(int id);
 
+  // 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;
 
   // |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;
@@ skipping 64 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_