Support dragging a virtual file out of the browser.

chrome/browser/download/download_manager.h

 // Copyright (c) 2006-2009 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.
 //
 // Each download is represented by a DownloadItem, and all DownloadItems
@@ skipping 77 matching lines @@
     DANGEROUS,
     DANGEROUS_BUT_VALIDATED  // Dangerous but the user confirmed the download.
   };
 
   // Interface that observers of a particular download must implement in order
   // to receive updates to the download's status.
   class Observer {
    public:
     virtual void OnDownloadUpdated(DownloadItem* download) = 0;
 
+    // Called when a downloaded file has been completed.
+    virtual void OnDownloadFileCompleted(DownloadItem* download) = 0;
+
     // Called when a downloaded file has been opened.
     virtual void OnDownloadOpened(DownloadItem* download) = 0;
 
    protected:
     virtual ~Observer() {}
   };
 
   // Constructing from persistent store:
   explicit DownloadItem(const DownloadCreateInfo& info);
 
   // Constructing from user action:
   DownloadItem(int32 download_id,
                const FilePath& path,
                int path_uniquifier,
                const GURL& url,
                const GURL& referrer_url,
                const std::string& mime_type,
                const FilePath& original_name,
                const base::Time start_time,
                int64 download_size,
                int render_process_id,
                int request_id,
                bool is_dangerous,
                bool save_as,
-               bool is_extension_install);
+               bool is_extension_install,
+               bool is_temporary);
 
   ~DownloadItem();
 
   void Init(bool start_timer);
 
   // Public API
 
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   // Notifies our observers periodically.
   void UpdateObservers();
 
+  // Notifies our observers the downloaded file has been completed.
+  void NotifyObserversDownloadFileCompleted();
+
   // Notifies our observers the downloaded file has been opened.
   void NotifyObserversDownloadOpened();
 
   // Received a new chunk of data
   void Update(int64 bytes_so_far);
 
   // Cancel the download operation. We need to distinguish between cancels at
   // exit (DownloadManager destructor) from user interface initiated cancels
   // because at exit, the history system may not exist, and any updates to it
   // require AddRef'ing the DownloadManager in the destructor which results in
@@ skipping 64 matching lines @@
   SafetyState safety_state() const { return safety_state_; }
   void set_safety_state(SafetyState safety_state) {
     safety_state_ = safety_state;
   }
   bool auto_opened() { return auto_opened_; }
   void set_auto_opened(bool auto_opened) { auto_opened_ = auto_opened; }
   FilePath original_name() const { return original_name_; }
   void set_original_name(const FilePath& name) { original_name_ = name; }
   bool save_as() const { return save_as_; }
   bool is_extension_install() const { return is_extension_install_; }
+  bool name_finalized() const { return name_finalized_; }
+  void set_name_finalized(bool name_finalized) {
+    name_finalized_ = name_finalized;
+  }
+  bool is_temporary() const { return is_temporary_; }
+  void set_is_temporary(bool is_temporary) { is_temporary_ = is_temporary; }
 
   // Returns the file-name that should be reported to the user, which is
   // file_name_ for safe downloads and original_name_ for dangerous ones with
   // the uniquifier number.
   FilePath GetFileName() const;
 
  private:
   // Internal helper for maintaining consistent received and total sizes.
   void UpdateSize(int64 size);
 
@@ skipping 68 matching lines @@
   // For canceling or pausing requests.
   int render_process_id_;
   int request_id_;
 
   // True if the item was downloaded as a result of 'save as...'
   bool save_as_;
 
   // True if the item was downloaded for an extension installation.
   bool is_extension_install_;
 
+  // True if the filename is finalized.
+  bool name_finalized_;
+
+  // True if the item was downloaded temporarily.
+  bool is_temporary_;
+
   DISALLOW_COPY_AND_ASSIGN(DownloadItem);
 };
 
 
 // DownloadManager -------------------------------------------------------------
 
 // Browser's download manager: manages all downloads and destination view.
 class DownloadManager : public base::RefCountedThreadSafe<DownloadManager>,
                         public SelectFileDialog::Listener {
   // For testing.
@@ skipping 22 matching lines @@
   };
 
   // Public API
 
   // 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 GetDownloads(Observer* observer,
                     const std::wstring& search_text);
 
+  // Return all temporary downloads that reside in the specified directory.
+  void GetTemporaryDownloads(Observer* observer,
+                             const FilePath& dir_path);
+
   // Returns true if initialized properly.
   bool Init(Profile* profile);
 
   // Schedule a query of the history service to retrieve all downloads.
   void QueryHistoryForDownloads();
 
   // 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);
@@ skipping 20 matching lines @@
   // Remove all downloads will delete all downloads. The number of downloads
   // deleted is returned back to the caller.
   int RemoveAllDownloads();
 
   // Download the object at the URL. Used in cases such as "Save Link As..."
   void DownloadUrl(const GURL& url,
                    const GURL& referrer,
                    const std::string& referrer_encoding,
                    TabContents* tab_contents);
 
+  // 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.
+  void DownloadUrlToFile(const GURL& url,
+                         const GURL& referrer,
+                         const std::string& referrer_encoding,
+                         const FilePath& save_file_path,
+                         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);
@@ skipping 33 matching lines @@
   // 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.
-  bool IsExecutableExtension(const FilePath::StringType& extension) const;
+  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 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 donwload 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.
-  void GenerateSafeFilename(const std::string& mime_type,
-                            FilePath* file_name);
+  static void GenerateSafeFileName(const std::string& mime_type,
+                                   FilePath* file_name);
 
   // Runs the network cancel.  Must be called on the IO thread.
   static void OnCancelDownloadRequest(ResourceDispatcherHost* rdh,
                                       int render_process_id,
                                       int request_id);
 
+  // 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:
   friend class base::RefCountedThreadSafe<DownloadManager>;
 
   ~DownloadManager();
 
   // Opens a download via the Windows shell.
   void OpenDownloadInShell(const DownloadItem* download,
                            gfx::NativeView parent_window);
 
   // Opens downloaded Chrome extension file (*.crx).
@@ skipping 18 matching lines @@
   void ContinueStartDownload(DownloadCreateInfo* info,
                              const FilePath& target_path);
 
   // Update the history service for a particular download.
   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.
-  void GenerateExtension(const FilePath& file_name,
-                         const std::string& mime_type,
-                         FilePath::StringType* generated_extension);
+  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.
-  void GenerateFilename(DownloadCreateInfo* info, FilePath* generated_name);
+  static void GenerateFileNameFromInfo(DownloadCreateInfo* info,
+                                       FilePath* generated_name);
 
   // Persist the automatic opening preference.
   void SaveAutoOpens();
 
   // Download cancel helper function.
   void DownloadCancelledInternal(int download_id,
                                  int render_process_id,
                                  int request_id);
 
   // Runs the pause on the IO thread.
@@ skipping 85 matching lines @@
   // Set of file extensions to open at download completion.
   struct AutoOpenCompareFunctor {
     inline bool operator()(const FilePath::StringType& a,
                            const FilePath::StringType& b) const {
       return FilePath::CompareLessIgnoreCase(a, b);
     }
   };
   typedef std::set<FilePath::StringType, AutoOpenCompareFunctor> AutoOpenSet;
   AutoOpenSet auto_open_;
 
-  // Set of file extensions that are executables and shouldn't be auto opened.
-  std::set<std::string> exe_types_;
-
   // Keep track of downloads that are completed before the user selects the
   // destination, so that observers are appropriately notified of completion
   // 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_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadManager);
 };
 
 #endif  // CHROME_BROWSER_DOWNLOAD_DOWNLOAD_MANAGER_H_