Download code cleanup:

chrome/browser/download/download_item.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.
 //
 // Each download is represented by a DownloadItem, and all DownloadItems
 // are owned by the DownloadManager which maintains a global list of all
 // downloads. DownloadItems are created when a user initiates a download,
 // and exist for the duration of the browser life time.
 //
 // Download observers:
@@ skipping 47 matching lines @@
     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);
+  DownloadItem(DownloadManager* download_manager,
+               const DownloadCreateInfo& info);
 
-  // Constructing from user action:
-  DownloadItem(int32 download_id,
+  // Constructing for a regular download:
+  DownloadItem(DownloadManager* download_manager,
+               const DownloadCreateInfo& info,
+               bool is_otr);
+
+  // Constructing for the "Save Page As..." feature:
+  DownloadItem(DownloadManager* download_manager,
                const FilePath& path,
-               int path_uniquifier,
                const GURL& url,
-               const GURL& referrer_url,
-               const std::string& mime_type,
-               const std::string& original_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_otr,
-               bool is_extension_install,
-               bool is_temporary);
+               bool is_otr);
 
   ~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();
+  // Whether it is OK to open this download.
+  bool CanOpenDownload();
+
+  // Tests if a file type should be opened automatically.
+  bool ShouldOpenFileBasedOnExtension();
+
+  // 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(bool open);
+
+  // Open the file associated with this download (wait for the download to
+  // complete if it is in progress).
+  void OpenDownload();
+
+  // Show the download via the OS shell.
+  void ShowDownloadInShell();
+
+  // Called when the user has validated the download of a dangerous file.
+  void DangerousDownloadValidated();
 
   // 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
   // a DCHECK failure. Set 'update_history' to false when canceling from at
   // exit to prevent this crash. This may result in a difference between the
@@ skipping 40 matching lines @@
   GURL referrer_url() const { return referrer_url_; }
   std::string mime_type() const { return mime_type_; }
   std::string original_mime_type() const { return original_mime_type_; }
   int64 total_bytes() const { return total_bytes_; }
   void set_total_bytes(int64 total_bytes) { total_bytes_ = total_bytes; }
   int64 received_bytes() const { return received_bytes_; }
   int32 id() const { return id_; }
   base::Time start_time() const { return start_time_; }
   void set_db_handle(int64 handle) { db_handle_ = handle; }
   int64 db_handle() const { return db_handle_; }
-  DownloadManager* manager() const { return manager_; }
-  void set_manager(DownloadManager* manager) { manager_ = manager; }
   bool is_paused() const { return is_paused_; }
   void set_is_paused(bool pause) { is_paused_ = pause; }
   bool open_when_complete() const { return open_when_complete_; }
   void set_open_when_complete(bool open) { open_when_complete_ = open; }
   int render_process_id() const { return render_process_id_; }
   int request_id() const { return request_id_; }
   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_; }
   bool save_as() const { return save_as_; }
   bool is_otr() const { return is_otr_; }
   bool is_extension_install() const { return is_extension_install_; }
   bool name_finalized() const { return name_finalized_; }
   bool is_temporary() const { return is_temporary_; }
   bool need_final_rename() const { return need_final_rename_; }
   void set_need_final_rename(bool need_final_rename) {
     need_final_rename_ = need_final_rename;
   }
 
   // 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:
+  void Init(bool start_timer);
+
   // Internal helper for maintaining consistent received and total sizes.
   void UpdateSize(int64 size);
 
   // Start/stop sending periodic updates to our observers
   void StartProgressTimer();
   void StopProgressTimer();
 
   // Request ID assigned by the ResourceDispatcherHost.
   int32 id_;
 
@@ skipping 38 matching lines @@
   // Time the download was started
   base::Time start_time_;
 
   // Our persistent store handle
   int64 db_handle_;
 
   // Timer for regularly updating our observers
   base::RepeatingTimer<DownloadItem> update_timer_;
 
   // Our owning object
-  DownloadManager* manager_;
+  DownloadManager* download_manager_;
 
   // In progress downloads may be paused by the user, we note it here
   bool is_paused_;
 
   // A flag for indicating if the download should be opened at completion.
   bool open_when_complete_;
 
   // Whether the download is considered potentially safe or dangerous
   // (executable files are typically considered dangerous).
   SafetyState safety_state_;
@@ skipping 26 matching lines @@
   // True if the item was downloaded temporarily.
   bool is_temporary_;
 
   // True if the file needs final rename.
   bool need_final_rename_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItem);
 };
 
 #endif  // CHROME_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_H_