Clean up download code:

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 169 matching lines @@
   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:
   // 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();
 
@@ skipping 11 matching lines @@
 
   friend class base::RefCountedThreadSafe<DownloadManager>;
   friend class OtherDownloadManagerObserver;
 
   ~DownloadManager();
 
   // Opens a download via the Windows shell.
   void OpenDownloadInShell(const DownloadItem* download,
                            gfx::NativeView parent_window);
 
-  // Opens downloaded Chrome extension file (*.crx).
-  void OpenChromeExtension(const FilePath& full_path,
-                           const GURL& download_url,
-                           const GURL& referrer_url,
-                           const std::string& original_mime_type);
-
   // Shutdown the download manager.  This call is needed only after Init.
   void Shutdown();
 
   // 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);
 
   // 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);
 
-  // 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.
   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.
-  static void OnPauseDownloadRequest(ResourceDispatcherHost* rdh,
-                                     int render_process_id,
-                                     int request_id,
-                                     bool pause);
-
   // Performs the last steps required when a download has been completed.
   // It is necessary to break down the flow when a download is finished as
   // dangerous downloads are downloaded to temporary files that need to be
   // renamed on the file thread first.
   // Invoked on the UI thread.
   // Marked virtual for testing.
   virtual void ContinueDownloadFinished(DownloadItem* download);
 
   // Renames a finished dangerous download from its temporary file name to its
   // real file name.
   // Invoked on the file thread.
   void ProceedWithFinishedDangerousDownload(int64 download_handle,
                                             const FilePath& path,
                                             const FilePath& original_name);
 
   // Invoked on the UI thread when a dangerous downloaded file has been renamed.
   void DangerousDownloadRenamed(int64 download_handle,
                                 bool success,
                                 const FilePath& new_path,
                                 int new_path_uniquifier);
 
-  // Checks whether a file represents a risk if downloaded.
-  bool IsDangerous(const FilePath& file_name);
-
   // Updates the app icon about the overall download progress.
   // Marked virtual for testing.
   virtual void UpdateAppIcon();
 
   // Changes the paths and file name of the specified |download|, propagating
   // the change to the history system.
   void RenameDownload(DownloadItem* download, const FilePath& new_path);
 
   // Inform observers that the model has changed.
   void NotifyModelChanged();
@@ skipping 73 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_