src/content/browser/download/download_item_impl.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_IMPL_H_
   6 #define CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_IMPL_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/callback_forward.h"
  12 #include "base/files/file_path.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "base/observer_list.h"
  16 #include "base/time/time.h"
  17 #include "base/timer/timer.h"
  18 #include "content/browser/download/download_net_log_parameters.h"
  19 #include "content/browser/download/download_request_handle.h"
  20 #include "content/common/content_export.h"
  21 #include "content/public/browser/download_destination_observer.h"
  22 #include "content/public/browser/download_interrupt_reasons.h"
  23 #include "content/public/browser/download_item.h"
  24 #include "net/base/net_log.h"
  25 #include "url/gurl.h"
  26
  27 namespace content {
  28 class DownloadFile;
  29 class DownloadItemImplDelegate;
  30
  31 // See download_item.h for usage.
  32 class CONTENT_EXPORT DownloadItemImpl
  33     : public DownloadItem,
  34       public DownloadDestinationObserver {
  35  public:
  36   enum ResumeMode {
  37     RESUME_MODE_INVALID = 0,
  38     RESUME_MODE_IMMEDIATE_CONTINUE,
  39     RESUME_MODE_IMMEDIATE_RESTART,
  40     RESUME_MODE_USER_CONTINUE,
  41     RESUME_MODE_USER_RESTART
  42   };
  43
  44   // The maximum number of attempts we will make to resume automatically.
  45   static const int kMaxAutoResumeAttempts;
  46
  47   // Note that it is the responsibility of the caller to ensure that a
  48   // DownloadItemImplDelegate passed to a DownloadItemImpl constructor
  49   // outlives the DownloadItemImpl.
  50
  51   // Constructing from persistent store:
  52   // |bound_net_log| is constructed externally for our use.
  53   DownloadItemImpl(DownloadItemImplDelegate* delegate,
  54                    uint32 id,
  55                    const base::FilePath& current_path,
  56                    const base::FilePath& target_path,
  57                    const std::vector<GURL>& url_chain,
  58                    const GURL& referrer_url,
  59                    const std::string& mime_type,
  60                    const std::string& original_mime_type,
  61                    const base::Time& start_time,
  62                    const base::Time& end_time,
  63                    const std::string& etag,
  64                    const std::string& last_modified,
  65                    int64 received_bytes,
  66                    int64 total_bytes,
  67                    DownloadItem::DownloadState state,
  68                    DownloadDangerType danger_type,
  69                    DownloadInterruptReason interrupt_reason,
  70                    bool opened,
  71                    const net::BoundNetLog& bound_net_log);
  72
  73   // Constructing for a regular download.
  74   // |bound_net_log| is constructed externally for our use.
  75   DownloadItemImpl(DownloadItemImplDelegate* delegate,
  76                    uint32 id,
  77                    const DownloadCreateInfo& info,
  78                    const net::BoundNetLog& bound_net_log);
  79
  80   // Constructing for the "Save Page As..." feature:
  81   // |bound_net_log| is constructed externally for our use.
  82   DownloadItemImpl(DownloadItemImplDelegate* delegate,
  83                    uint32 id,
  84                    const base::FilePath& path,
  85                    const GURL& url,
  86                    const std::string& mime_type,
  87                    scoped_ptr<DownloadRequestHandleInterface> request_handle,
  88                    const net::BoundNetLog& bound_net_log);
  89
  90   virtual ~DownloadItemImpl();
  91
  92   // DownloadItem
  93   virtual void AddObserver(DownloadItem::Observer* observer) OVERRIDE;
  94   virtual void RemoveObserver(DownloadItem::Observer* observer) OVERRIDE;
  95   virtual void UpdateObservers() OVERRIDE;
  96   virtual void ValidateDangerousDownload() OVERRIDE;
  97   virtual void StealDangerousDownload(const AcquireFileCallback& callback)
  98       OVERRIDE;
  99   virtual void Pause() OVERRIDE;
 100   virtual void Resume() OVERRIDE;
 101   virtual void Cancel(bool user_cancel) OVERRIDE;
 102   virtual void Remove() OVERRIDE;
 103   virtual void OpenDownload() OVERRIDE;
 104   virtual void ShowDownloadInShell() OVERRIDE;
 105   virtual uint32 GetId() const OVERRIDE;
 106   virtual DownloadState GetState() const OVERRIDE;
 107   virtual DownloadInterruptReason GetLastReason() const OVERRIDE;
 108   virtual bool IsPaused() const OVERRIDE;
 109   virtual bool IsTemporary() const OVERRIDE;
 110   virtual bool CanResume() const OVERRIDE;
 111   virtual bool IsDone() const OVERRIDE;
 112   virtual const GURL& GetURL() const OVERRIDE;
 113   virtual const std::vector<GURL>& GetUrlChain() const OVERRIDE;
 114   virtual const GURL& GetOriginalUrl() const OVERRIDE;
 115   virtual const GURL& GetReferrerUrl() const OVERRIDE;
 116   virtual const GURL& GetTabUrl() const OVERRIDE;
 117   virtual const GURL& GetTabReferrerUrl() const OVERRIDE;
 118   virtual std::string GetSuggestedFilename() const OVERRIDE;
 119   virtual std::string GetContentDisposition() const OVERRIDE;
 120   virtual std::string GetMimeType() const OVERRIDE;
 121   virtual std::string GetOriginalMimeType() const OVERRIDE;
 122   virtual std::string GetRemoteAddress() const OVERRIDE;
 123   virtual bool HasUserGesture() const OVERRIDE;
 124   virtual ui::PageTransition GetTransitionType() const OVERRIDE;
 125   virtual const std::string& GetLastModifiedTime() const OVERRIDE;
 126   virtual const std::string& GetETag() const OVERRIDE;
 127   virtual bool IsSavePackageDownload() const OVERRIDE;
 128   virtual const base::FilePath& GetFullPath() const OVERRIDE;
 129   virtual const base::FilePath& GetTargetFilePath() const OVERRIDE;
 130   virtual const base::FilePath& GetForcedFilePath() const OVERRIDE;
 131   virtual base::FilePath GetFileNameToReportUser() const OVERRIDE;
 132   virtual TargetDisposition GetTargetDisposition() const OVERRIDE;
 133   virtual const std::string& GetHash() const OVERRIDE;
 134   virtual const std::string& GetHashState() const OVERRIDE;
 135   virtual bool GetFileExternallyRemoved() const OVERRIDE;
 136   virtual void DeleteFile(const base::Callback<void(bool)>& callback) OVERRIDE;
 137   virtual bool IsDangerous() const OVERRIDE;
 138   virtual DownloadDangerType GetDangerType() const OVERRIDE;
 139   virtual bool TimeRemaining(base::TimeDelta* remaining) const OVERRIDE;
 140   virtual int64 CurrentSpeed() const OVERRIDE;
 141   virtual int PercentComplete() const OVERRIDE;
 142   virtual bool AllDataSaved() const OVERRIDE;
 143   virtual int64 GetTotalBytes() const OVERRIDE;
 144   virtual int64 GetReceivedBytes() const OVERRIDE;
 145   virtual base::Time GetStartTime() const OVERRIDE;
 146   virtual base::Time GetEndTime() const OVERRIDE;
 147   virtual bool CanShowInFolder() OVERRIDE;
 148   virtual bool CanOpenDownload() OVERRIDE;
 149   virtual bool ShouldOpenFileBasedOnExtension() OVERRIDE;
 150   virtual bool GetOpenWhenComplete() const OVERRIDE;
 151   virtual bool GetAutoOpened() OVERRIDE;
 152   virtual bool GetOpened() const OVERRIDE;
 153   virtual BrowserContext* GetBrowserContext() const OVERRIDE;
 154   virtual WebContents* GetWebContents() const OVERRIDE;
 155   virtual void OnContentCheckCompleted(DownloadDangerType danger_type) OVERRIDE;
 156   virtual void SetOpenWhenComplete(bool open) OVERRIDE;
 157   virtual void SetIsTemporary(bool temporary) OVERRIDE;
 158   virtual void SetOpened(bool opened) OVERRIDE;
 159   virtual void SetDisplayName(const base::FilePath& name) OVERRIDE;
 160   virtual std::string DebugString(bool verbose) const OVERRIDE;
 161
 162   // All remaining public interfaces virtual to allow for DownloadItemImpl
 163   // mocks.
 164
 165   // Determines the resume mode for an interrupted download. Requires
 166   // last_reason_ to be set, but doesn't require the download to be in
 167   // INTERRUPTED state.
 168   virtual ResumeMode GetResumeMode() const;
 169
 170   // Notify the download item that new origin information is available due to a
 171   // resumption request receiving a response.
 172   virtual void MergeOriginInfoOnResume(
 173       const DownloadCreateInfo& new_create_info);
 174
 175   // State transition operations on regular downloads --------------------------
 176
 177   // Start the download.
 178   // |download_file| is the associated file on the storage medium.
 179   // |req_handle| is the new request handle associated with the download.
 180   virtual void Start(scoped_ptr<DownloadFile> download_file,
 181                      scoped_ptr<DownloadRequestHandleInterface> req_handle);
 182
 183   // Needed because of intertwining with DownloadManagerImpl -------------------
 184
 185   // TODO(rdsmith): Unwind DownloadManagerImpl and DownloadItemImpl,
 186   // removing these from the public interface.
 187
 188   // Notify observers that this item is being removed by the user.
 189   virtual void NotifyRemoved();
 190
 191   virtual void OnDownloadedFileRemoved();
 192
 193   // Provide a weak pointer reference to a DownloadDestinationObserver
 194   // for use by download destinations.
 195   virtual base::WeakPtr<DownloadDestinationObserver>
 196       DestinationObserverAsWeakPtr();
 197
 198   // Get the download's BoundNetLog.
 199   virtual const net::BoundNetLog& GetBoundNetLog() const;
 200
 201   // DownloadItemImpl routines only needed by SavePackage ----------------------
 202
 203   // Called by SavePackage to set the total number of bytes on the item.
 204   virtual void SetTotalBytes(int64 total_bytes);
 205
 206   virtual void OnAllDataSaved(const std::string& final_hash);
 207
 208   // Called by SavePackage to display progress when the DownloadItem
 209   // should be considered complete.
 210   virtual void MarkAsComplete();
 211
 212   // DownloadDestinationObserver
 213   virtual void DestinationUpdate(int64 bytes_so_far,
 214                                  int64 bytes_per_sec,
 215                                  const std::string& hash_state) OVERRIDE;
 216   virtual void DestinationError(DownloadInterruptReason reason) OVERRIDE;
 217   virtual void DestinationCompleted(const std::string& final_hash) OVERRIDE;
 218
 219  private:
 220   // Fine grained states of a download. Note that active downloads are created
 221   // in IN_PROGRESS_INTERNAL state. However, downloads creates via history can
 222   // be created in COMPLETE_INTERNAL, CANCELLED_INTERNAL and
 223   // INTERRUPTED_INTERNAL.
 224
 225   enum DownloadInternalState {
 226     // Includes both before and after file name determination, and paused
 227     // downloads.
 228     // TODO(rdsmith): Put in state variable for file name determination.
 229     // Transitions from:
 230     //   <Initial creation>    Active downloads are created in this state.
 231     //   RESUMING_INTERNAL
 232     // Transitions to:
 233     //   COMPLETING_INTERNAL   On final rename completion.
 234     //   CANCELLED_INTERNAL    On cancel.
 235     //   INTERRUPTED_INTERNAL  On interrupt.
 236     //   COMPLETE_INTERNAL     On SavePackage download completion.
 237     IN_PROGRESS_INTERNAL,
 238
 239     // Between commit point (dispatch of download file release) and completed.
 240     // Embedder may be opening the file in this state.
 241     // Transitions from:
 242     //   IN_PROGRESS_INTERNAL
 243     // Transitions to:
 244     //   COMPLETE_INTERNAL     On successful completion.
 245     COMPLETING_INTERNAL,
 246
 247     // After embedder has had a chance to auto-open.  User may now open
 248     // or auto-open based on extension.
 249     // Transitions from:
 250     //   COMPLETING_INTERNAL
 251     //   IN_PROGRESS_INTERNAL  SavePackage only.
 252     //   <Initial creation>    Completed persisted downloads.
 253     // Transitions to:
 254     //   <none>                Terminal state.
 255     COMPLETE_INTERNAL,
 256
 257     // User has cancelled the download.
 258     // Transitions from:
 259     //   IN_PROGRESS_INTERNAL
 260     //   INTERRUPTED_INTERNAL
 261     //   RESUMING_INTERNAL
 262     //   <Initial creation>    Canceleld persisted downloads.
 263     // Transitions to:
 264     //   <none>                Terminal state.
 265     CANCELLED_INTERNAL,
 266
 267     // An error has interrupted the download.
 268     // Transitions from:
 269     //   IN_PROGRESS_INTERNAL
 270     //   RESUMING_INTERNAL
 271     //   <Initial creation>    Interrupted persisted downloads.
 272     // Transitions to:
 273     //   RESUMING_INTERNAL     On resumption.
 274     INTERRUPTED_INTERNAL,
 275
 276     // A request to resume this interrupted download is in progress.
 277     // Transitions from:
 278     //   INTERRUPTED_INTERNAL
 279     // Transitions to:
 280     //   IN_PROGRESS_INTERNAL  Once a server response is received from a
 281     //                         resumption.
 282     //   INTERRUPTED_INTERNAL  If the resumption request fails.
 283     //   CANCELLED_INTERNAL    On cancel.
 284     RESUMING_INTERNAL,
 285
 286     MAX_DOWNLOAD_INTERNAL_STATE,
 287   };
 288
 289   // Used with TransitionTo() to indicate whether or not to call
 290   // UpdateObservers() after the state transition.
 291   enum ShouldUpdateObservers {
 292     UPDATE_OBSERVERS,
 293     DONT_UPDATE_OBSERVERS
 294   };
 295
 296   // Normal progression of a download ------------------------------------------
 297
 298   // These are listed in approximately chronological order.  There are also
 299   // public methods involved in normal download progression; see
 300   // the implementation ordering in download_item_impl.cc.
 301
 302   // Construction common to all constructors. |active| should be true for new
 303   // downloads and false for downloads from the history.
 304   // |download_type| indicates to the net log system what kind of download
 305   // this is.
 306   void Init(bool active, DownloadType download_type);
 307
 308   // Called when the target path has been determined. |target_path| is the
 309   // suggested target path. |disposition| indicates how the target path should
 310   // be used (see TargetDisposition). |danger_type| is the danger level of
 311   // |target_path| as determined by the caller. |intermediate_path| is the path
 312   // to use to store the download until OnDownloadCompleting() is called.
 313   virtual void OnDownloadTargetDetermined(
 314       const base::FilePath& target_path,
 315       TargetDisposition disposition,
 316       DownloadDangerType danger_type,
 317       const base::FilePath& intermediate_path);
 318
 319   // Callback from file thread when we initialize the DownloadFile.
 320   void OnDownloadFileInitialized(DownloadInterruptReason result);
 321
 322   void OnDownloadRenamedToIntermediateName(
 323       DownloadInterruptReason reason, const base::FilePath& full_path);
 324
 325   // If all pre-requisites have been met, complete download processing, i.e. do
 326   // internal cleanup, file rename, and potentially auto-open.  (Dangerous
 327   // downloads still may block on user acceptance after this point.)
 328   void MaybeCompleteDownload();
 329
 330   // Called when the download is ready to complete.
 331   // This may perform final rename if necessary and will eventually call
 332   // DownloadItem::Completed().
 333   void OnDownloadCompleting();
 334
 335   void OnDownloadRenamedToFinalName(DownloadInterruptReason reason,
 336                                     const base::FilePath& full_path);
 337
 338   // Called if the embedder took over opening a download, to indicate that
 339   // the download has been opened.
 340   void DelayedDownloadOpened(bool auto_opened);
 341
 342   // Called when the entire download operation (including renaming etc)
 343   // is completed.
 344   void Completed();
 345
 346   // Callback invoked when the URLRequest for a download resumption has started.
 347   void OnResumeRequestStarted(DownloadItem* item,
 348                               DownloadInterruptReason interrupt_reason);
 349
 350   // Helper routines -----------------------------------------------------------
 351
 352   // Indicate that an error has occurred on the download.
 353   void Interrupt(DownloadInterruptReason reason);
 354
 355   // Destroy the DownloadFile object.  If |destroy_file| is true, the file is
 356   // destroyed with it.  Otherwise, DownloadFile::Detach() is called before
 357   // object destruction to prevent file destruction. Destroying the file also
 358   // resets |current_path_|.
 359   void ReleaseDownloadFile(bool destroy_file);
 360
 361   // Check if a download is ready for completion.  The callback provided
 362   // may be called at some point in the future if an external entity
 363   // state has change s.t. this routine should be checked again.
 364   bool IsDownloadReadyForCompletion(const base::Closure& state_change_notify);
 365
 366   // Call to transition state; all state transitions should go through this.
 367   // |notify_action| specifies whether or not to call UpdateObservers() after
 368   // the state transition.
 369   void TransitionTo(DownloadInternalState new_state,
 370                     ShouldUpdateObservers notify_action);
 371
 372   // Set the |danger_type_| and invoke obserers if necessary.
 373   void SetDangerType(DownloadDangerType danger_type);
 374
 375   void SetFullPath(const base::FilePath& new_path);
 376
 377   void AutoResumeIfValid();
 378
 379   void ResumeInterruptedDownload();
 380
 381   static DownloadState InternalToExternalState(
 382       DownloadInternalState internal_state);
 383   static DownloadInternalState ExternalToInternalState(
 384       DownloadState external_state);
 385
 386   // Debugging routines --------------------------------------------------------
 387   static const char* DebugDownloadStateString(DownloadInternalState state);
 388   static const char* DebugResumeModeString(ResumeMode mode);
 389
 390   // Will be false for save package downloads retrieved from the history.
 391   // TODO(rdsmith): Replace with a generalized enum for "download source".
 392   const bool is_save_package_download_;
 393
 394   // The handle to the request information.  Used for operations outside the
 395   // download system.
 396   scoped_ptr<DownloadRequestHandleInterface> request_handle_;
 397
 398   uint32 download_id_;
 399
 400   // Display name for the download. If this is empty, then the display name is
 401   // considered to be |target_path_.BaseName()|.
 402   base::FilePath display_name_;
 403
 404   // Full path to the downloaded or downloading file. This is the path to the
 405   // physical file, if one exists. The final target path is specified by
 406   // |target_path_|. |current_path_| can be empty if the in-progress path hasn't
 407   // been determined.
 408   base::FilePath current_path_;
 409
 410   // Target path of an in-progress download. We may be downloading to a
 411   // temporary or intermediate file (specified by |current_path_|.  Once the
 412   // download completes, we will rename the file to |target_path_|.
 413   base::FilePath target_path_;
 414
 415   // Whether the target should be overwritten, uniquified or prompted for.
 416   TargetDisposition target_disposition_;
 417
 418   // The chain of redirects that leading up to and including the final URL.
 419   std::vector<GURL> url_chain_;
 420
 421   // The URL of the page that initiated the download.
 422   GURL referrer_url_;
 423
 424   // The URL of the tab that initiated the download.
 425   GURL tab_url_;
 426
 427   // The URL of the referrer of the tab that initiated the download.
 428   GURL tab_referrer_url_;
 429
 430   // Filename suggestion from DownloadSaveInfo. It could, among others, be the
 431   // suggested filename in 'download' attribute of an anchor. Details:
 432   // http://www.whatwg.org/specs/web-apps/current-work/#downloading-hyperlinks
 433   std::string suggested_filename_;
 434
 435   // If non-empty, contains an externally supplied path that should be used as
 436   // the target path.
 437   base::FilePath forced_file_path_;
 438
 439   // Page transition that triggerred the download.
 440   ui::PageTransition transition_type_;
 441
 442   // Whether the download was triggered with a user gesture.
 443   bool has_user_gesture_;
 444
 445   // Information from the request.
 446   // Content-disposition field from the header.
 447   std::string content_disposition_;
 448
 449   // Mime-type from the header.  Subject to change.
 450   std::string mime_type_;
 451
 452   // The value of the content type header sent with the downloaded item.  It
 453   // may be different from |mime_type_|, which may be set based on heuristics
 454   // which may look at the file extension and first few bytes of the file.
 455   std::string original_mime_type_;
 456
 457   // The remote IP address where the download was fetched from.  Copied from
 458   // DownloadCreateInfo::remote_address.
 459   std::string remote_address_;
 460
 461   // Total bytes expected.
 462   int64 total_bytes_;
 463
 464   // Current received bytes.
 465   int64 received_bytes_;
 466
 467   // Current speed. Calculated by the DownloadFile.
 468   int64 bytes_per_sec_;
 469
 470   // Sha256 hash of the content.  This might be empty either because
 471   // the download isn't done yet or because the hash isn't needed
 472   // (ChromeDownloadManagerDelegate::GenerateFileHash() returned false).
 473   std::string hash_;
 474
 475   // A blob containing the state of the hash algorithm.  Only valid while the
 476   // download is in progress.
 477   std::string hash_state_;
 478
 479   // Server's time stamp for the file.
 480   std::string last_modified_time_;
 481
 482   // Server's ETAG for the file.
 483   std::string etag_;
 484
 485   // Last reason.
 486   DownloadInterruptReason last_reason_;
 487
 488   // Start time for recording statistics.
 489   base::TimeTicks start_tick_;
 490
 491   // The current state of this download.
 492   DownloadInternalState state_;
 493
 494   // Current danger type for the download.
 495   DownloadDangerType danger_type_;
 496
 497   // The views of this item in the download shelf and download contents.
 498   ObserverList<Observer> observers_;
 499
 500   // Time the download was started.
 501   base::Time start_time_;
 502
 503   // Time the download completed.
 504   base::Time end_time_;
 505
 506   // Our delegate.
 507   DownloadItemImplDelegate* delegate_;
 508
 509   // In progress downloads may be paused by the user, we note it here.
 510   bool is_paused_;
 511
 512   // The number of times this download has been resumed automatically.
 513   int auto_resume_count_;
 514
 515   // A flag for indicating if the download should be opened at completion.
 516   bool open_when_complete_;
 517
 518   // A flag for indicating if the downloaded file is externally removed.
 519   bool file_externally_removed_;
 520
 521   // True if the download was auto-opened. We set this rather than using
 522   // an observer as it's frequently possible for the download to be auto opened
 523   // before the observer is added.
 524   bool auto_opened_;
 525
 526   // True if the item was downloaded temporarily.
 527   bool is_temporary_;
 528
 529   // True if we've saved all the data for the download.
 530   bool all_data_saved_;
 531
 532   // Error return from DestinationError.  Stored separately from
 533   // last_reason_ so that we can avoid handling destination errors until
 534   // after file name determination has occurred.
 535   DownloadInterruptReason destination_error_;
 536
 537   // Did the user open the item either directly or indirectly (such as by
 538   // setting always open files of this type)? The shelf also sets this field
 539   // when the user closes the shelf before the item has been opened but should
 540   // be treated as though the user opened it.
 541   bool opened_;
 542
 543   // Did the delegate delay calling Complete on this download?
 544   bool delegate_delayed_complete_;
 545
 546   // DownloadFile associated with this download.  Note that this
 547   // pointer may only be used or destroyed on the FILE thread.
 548   // This pointer will be non-null only while the DownloadItem is in
 549   // the IN_PROGRESS state.
 550   scoped_ptr<DownloadFile> download_file_;
 551
 552   // Net log to use for this download.
 553   const net::BoundNetLog bound_net_log_;
 554
 555   base::WeakPtrFactory<DownloadItemImpl> weak_ptr_factory_;
 556
 557   DISALLOW_COPY_AND_ASSIGN(DownloadItemImpl);
 558 };
 559
 560 }  // namespace content
 561
 562 #endif  // CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_IMPL_H_