Implement chrome.experimental.downloads.search()

content/browser/download/download_item.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.
 //
 // 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:
 //   DownloadItem::Observer:
 //     - allows observers to receive notifications about one download from start
 //       to completion
 // Use AddObserver() / RemoveObserver() on the appropriate download object to
 // receive state updates.
 
 #ifndef CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_H_
 #define CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_H_
 #pragma once
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/observer_list.h"
 #include "base/time.h"
 #include "base/timer.h"
+#include "content/browser/download/download_item_interface.h"
 #include "content/browser/download/download_request_handle.h"
 #include "content/browser/download/download_state_info.h"
 #include "content/browser/download/interrupt_reasons.h"
 #include "content/common/content_export.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_errors.h"
 
 class DownloadFileManager;
 class DownloadId;
 class DownloadManager;
 struct DownloadCreateInfo;
 struct DownloadPersistentStoreInfo;
 
 // One DownloadItem per download. This is the model class that stores all the
 // state for a download. Multiple views, such as a tab's download shelf and the
 // Destination tab's download view, may refer to a given DownloadItem.
 //
 // This is intended to be used only on the UI thread.
-class CONTENT_EXPORT DownloadItem {
+class CONTENT_EXPORT DownloadItem : public DownloadItemInterface {

[cbentzel, 2011/10/20 18:18:53]

Naming issue: we usually don't have Interface appended to interfaces. More
commonly it's something like

class DownloadItemImpl : public DownloadItem {
};

Another advantage of this change is that most of the consumers of DownloadItem
only care about the interface, so you won't have to change them.

It also might be a good idea to do this very simple refactor in a separate CL. 

  public:
-  enum DownloadState {
-    // Download is actively progressing.
-    IN_PROGRESS = 0,
-
-    // Download is completely finished.
-    COMPLETE,
-
-    // Download has been cancelled.
-    CANCELLED,
-
-    // This state indicates that the download item is about to be destroyed,
-    // and observers seeing this state should release all references.
-    REMOVING,
-
-    // This state indicates that the download has been interrupted.
-    INTERRUPTED,
-
-    // Maximum value.
-    MAX_DOWNLOAD_STATE
-  };
-
-  enum SafetyState {
-    SAFE = 0,
-    DANGEROUS,
-    DANGEROUS_BUT_VALIDATED  // Dangerous but the user confirmed the download.
-  };
-
-  // This enum is used by histograms.  Do not change the ordering or remove
-  // items.
-  enum DangerType {
-    NOT_DANGEROUS = 0,
-
-    // A dangerous file to the system (e.g.: an executable or extension from
-    // places other than gallery).
-    DANGEROUS_FILE,
-
-    // Safebrowsing service shows this URL leads to malicious file download.
-    DANGEROUS_URL,
-
-    // Memory space for histograms is determined by the max.
-    // ALWAYS ADD NEW VALUES BEFORE THIS ONE.
-    DANGEROUS_TYPE_MAX
-  };
-
   // Reason for deleting the download.  Passed to Delete().
   enum DeleteReason {
     DELETE_DUE_TO_BROWSER_SHUTDOWN = 0,
     DELETE_DUE_TO_USER_DISCARD
   };
 
   // A fake download table ID which represents a download that has started,
   // but is not yet in the table.
   static const int kUninitializedHandle;
 
   // Interface that observers of a particular download must implement in order
   // to receive updates to the download's status.
   class CONTENT_EXPORT Observer {
    public:
     virtual void OnDownloadUpdated(DownloadItem* download) = 0;
 
     // Called when a downloaded file has been opened.
     virtual void OnDownloadOpened(DownloadItem* download) = 0;
 
    protected:
     virtual ~Observer() {}
   };
 
   // Constructing from persistent store:
   DownloadItem(DownloadManager* download_manager,
-               const DownloadPersistentStoreInfo& info);
+               const DownloadPersistentStoreInfo& info,
+               int 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,
                const GURL& url,
@@ skipping 103 matching lines @@
 
   // Called when the download is ready to complete.
   // This may perform final rename if necessary and will eventually call
   // DownloadItem::Completed().
   void OnDownloadCompleting(DownloadFileManager* file_manager);
 
   // Called when the file name for the download is renamed to its final name.
   void OnDownloadRenamedToFinalName(const FilePath& full_path);
 
   // Returns true if this item matches |query|. |query| must be lower-cased.
-  bool MatchesQuery(const string16& query) const;
+  virtual bool MatchesQuery(const string16& query) const OVERRIDE;
 
   // Returns true if the download needs more data.
-  bool IsPartialDownload() const;
+  virtual bool IsPartialDownload() const OVERRIDE;
 
   // Returns true if the download is still receiving data.
-  bool IsInProgress() const;
+  virtual bool IsInProgress() const OVERRIDE;
 
   // Returns true if the download has been cancelled or was interrupted.
-  bool IsCancelled() const;
+  virtual bool IsCancelled() const OVERRIDE;
 
   // Returns true if the download was interrupted.
-  bool IsInterrupted() const;
+  virtual bool IsInterrupted() const OVERRIDE;
 
   // Returns true if we have all the data and know the final file name.
-  bool IsComplete() const;
+  virtual bool IsComplete() const OVERRIDE;
 
   // Accessors
-  DownloadState state() const { return state_; }
-  const FilePath& full_path() const { return full_path_; }
+  virtual DownloadItemInterface::DownloadState state() const OVERRIDE {
+    return state_;
+  }
+  virtual const FilePath& full_path() const OVERRIDE { return full_path_; }
   void set_path_uniquifier(int uniquifier) {
     state_info_.path_uniquifier = uniquifier;
   }
-  const GURL& GetURL() const;
+  virtual const GURL& GetURL() const OVERRIDE;
 
   const std::vector<GURL>& url_chain() const { return url_chain_; }
-  const GURL& original_url() const { return url_chain_.front(); }
-  const GURL& referrer_url() const { return referrer_url_; }
-  std::string suggested_filename() const { return suggested_filename_; }
-  std::string content_disposition() const { return content_disposition_; }
-  std::string mime_type() const { return mime_type_; }
-  std::string original_mime_type() const { return original_mime_type_; }
-  std::string referrer_charset() const { return referrer_charset_; }
-  int64 total_bytes() const { return total_bytes_; }
+  virtual const GURL& original_url() const OVERRIDE {
+    return url_chain_.front();
+  }
+  virtual const GURL& referrer_url() const OVERRIDE { return referrer_url_; }
+  virtual std::string suggested_filename() const OVERRIDE {
+    return suggested_filename_;
+  }
+  virtual std::string content_disposition() const OVERRIDE {
+    return content_disposition_;
+  }
+  virtual std::string mime_type() const OVERRIDE { return mime_type_; }
+  virtual std::string original_mime_type() const OVERRIDE {
+    return original_mime_type_;
+  }
+  virtual std::string referrer_charset() const OVERRIDE {
+    return referrer_charset_;
+  }
+  virtual int64 total_bytes() const OVERRIDE { 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 download_id_; }
-  DownloadId global_id() const;
-  base::Time start_time() const { return start_time_; }
-  base::Time end_time() const { return end_time_; }
+  virtual int64 received_bytes() const OVERRIDE { return received_bytes_; }
+  virtual int32 id() const OVERRIDE { return download_id_; }
+  virtual DownloadId global_id() const OVERRIDE;
+  virtual base::Time start_time() const OVERRIDE { return start_time_; }
+  virtual base::Time end_time() const { return end_time_; }
   void set_db_handle(int64 handle) { db_handle_ = handle; }
-  int64 db_handle() const { return db_handle_; }
-  DownloadManager* download_manager() { return download_manager_; }
-  bool is_paused() const { return is_paused_; }
-  bool open_when_complete() const { return open_when_complete_; }
+  virtual int64 db_handle() const OVERRIDE { return db_handle_; }
+  virtual DownloadManager* download_manager() OVERRIDE {
+    return download_manager_;
+  }
+  virtual bool is_paused() const OVERRIDE { return is_paused_; }
+  virtual bool open_when_complete() const OVERRIDE {
+    return open_when_complete_;
+  }
   void set_open_when_complete(bool open) { open_when_complete_ = open; }
-  bool file_externally_removed() const { return file_externally_removed_; }
-  SafetyState safety_state() const { return safety_state_; }
+  virtual bool file_externally_removed() const OVERRIDE {
+    return file_externally_removed_;
+  }
+  virtual DownloadItemInterface::SafetyState safety_state() const OVERRIDE {
+    return safety_state_;
+  }
   // Why |safety_state_| is not SAFE.
-  DangerType GetDangerType() const;
-  bool IsDangerous() const;
+  virtual DownloadItemInterface::DangerType GetDangerType() const OVERRIDE;
+  virtual bool IsDangerous() const OVERRIDE;
   void MarkFileDangerous();
   void MarkUrlDangerous();
 
-  bool auto_opened() { return auto_opened_; }
-  const FilePath& target_name() const { return state_info_.target_name; }
-  bool prompt_user_for_save_location() const {
+  virtual bool auto_opened() const OVERRIDE { return auto_opened_; }
+  virtual const FilePath& target_name() const OVERRIDE {
+    return state_info_.target_name;
+  }
+  virtual bool prompt_user_for_save_location() const OVERRIDE {
     return state_info_.prompt_user_for_save_location;
   }
-  bool is_otr() const { return is_otr_; }
-  const FilePath& suggested_path() const { return state_info_.suggested_path; }
-  bool is_temporary() const { return is_temporary_; }
+  virtual bool is_otr() const { return is_otr_; }
+  virtual const FilePath& suggested_path() const OVERRIDE {
+    return state_info_.suggested_path;
+  }
+  virtual bool is_temporary() const OVERRIDE { return is_temporary_; }
   void set_opened(bool opened) { opened_ = opened; }
-  bool opened() const { return opened_; }
+  virtual bool opened() const OVERRIDE { return opened_; }
 
-  InterruptReason last_reason() const { return last_reason_; }
+  virtual InterruptReason last_reason() const OVERRIDE { return last_reason_; }
 
   DownloadPersistentStoreInfo GetPersistentStoreInfo() const;
   DownloadStateInfo state_info() const { return state_info_; }
   const DownloadRequestHandle& request_handle() const {
     return request_handle_;
   }
 
   // Returns the final target file path for the download.
   FilePath GetTargetFilePath() const;
 
@@ skipping 33 matching lines @@
 
   // Called when the entire download operation (including renaming etc)
   // is completed.
   void Completed();
 
   // Start/stop sending periodic updates to our observers
   void StartProgressTimer();
   void StopProgressTimer();
 
   // Call to transition state; all state transitions should go through this.
-  void TransitionTo(DownloadState new_state);
+  void TransitionTo(DownloadItemInterface::DownloadState new_state);
 
   // Called when safety_state_ should be recomputed from is_dangerous_file
   // and is_dangerous_url.
   void UpdateSafetyState();
 
   // Helper function to recompute |state_info_.target_name| when
   // it may have changed.  (If it's non-null it should be left alone,
   // otherwise updated from |full_path_|.)
   void UpdateTarget();
 
@@ skipping 46 matching lines @@
   // Current received bytes
   int64 received_bytes_;
 
   // Last reason.
   InterruptReason last_reason_;
 
   // Start time for calculating remaining time
   base::TimeTicks start_tick_;
 
   // The current state of this download
-  DownloadState state_;
+  DownloadItemInterface::DownloadState state_;
 
   // The views of this item in the download shelf and download tab
   ObserverList<Observer> observers_;
 
   // Time the download was started
   base::Time start_time_;
 
   // Time the download completed
   base::Time end_time_;
 
@@ skipping 10 matching lines @@
   bool is_paused_;
 
   // A flag for indicating if the download should be opened at completion.
   bool open_when_complete_;
 
   // A flag for indicating if the downloaded file is externally removed.
   bool file_externally_removed_;
 
   // Indicates if the download is considered potentially safe or dangerous
   // (executable files are typically considered dangerous).
-  SafetyState safety_state_;
+  DownloadItemInterface::SafetyState safety_state_;
 
   // True if the download was auto-opened. We set this rather than using
   // an observer as it's frequently possible for the download to be auto opened
   // before the observer is added.
   bool auto_opened_;
 
   // True if the download was initiated in an incognito window.
   bool is_otr_;
 
   // True if the item was downloaded temporarily.
@@ skipping 12 matching lines @@
   // only.
   bool open_enabled_;
 
   // Did the delegate delay calling Complete on this download?
   bool delegate_delayed_complete_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItem);
 };
 
 #endif  // CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_H_