Download resumption - Preliminary

content/browser/download/download_item_impl.h

 // Copyright (c) 2012 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.
 
 #ifndef CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_IMPL_H_
 #define CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_IMPL_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 10 matching lines @@
 #include "content/public/browser/download_item.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 
 class DownloadItemImplDelegate;
 
 // See download_item.h for usage.
 class CONTENT_EXPORT DownloadItemImpl : public content::DownloadItem {
  public:
+  // The maximum number of attempts we will make to resume automatically.
+  static const int kMaxAutoResumeAttempts;
+
   // Note that it is the responsibility of the caller to ensure that a
   // DownloadItemImplDelegate passed to a DownloadItemImpl constructor
   // outlives the DownloadItemImpl.
 
   // Constructing from persistent store:
   // |bound_net_log| is constructed externally for our use.
   DownloadItemImpl(DownloadItemImplDelegate* delegate,
                    content::DownloadId download_id,
                    const content::DownloadPersistentStoreInfo& info,
                    const net::BoundNetLog& bound_net_log);
 
   // Constructing for a regular download.
   // |bound_net_log| is constructed externally for our use.
   DownloadItemImpl(DownloadItemImplDelegate* delegate,
                    const DownloadCreateInfo& info,
-                   scoped_ptr<DownloadRequestHandleInterface> request_handle,

[Randy Smith (Not in Mondays), 2012/10/15 00:36:08]

Why?  (This question applies to DownloadItemFactory::CreateActiveItem as well). 
It looks as if Resume() takes a request_handle, so I don't see the reason to
remove this from the constructor (and thus require the addition of
SetRequest()).  

One possible design would be to create the DownloadItemImpl in (effectively) an
already cancelled/interrupted state, and use the same accessor on it (presumably
Start() or something like it) to start it, passing in a request_handle.  I'm
open to such designs, but they're a little tricky, as the set of state
transitions that the DII would go through would look weird to an outsider
observer (CANCELLED -> IN_PROGRESS).  That might be soluble by an
internal/external state dichotomy (I recently split the DII internal state away
from the external state, so this wouldn't be hard to do), but I'm not sure it's
worth picking up that particular can of worms right now.  So I'd be more
inclined to have the creation pathway be as it currently is, and have the
resumption pathway pass in the request handle.

                    const net::BoundNetLog& bound_net_log);
 
   // Constructing for the "Save Page As..." feature:
   // |bound_net_log| is constructed externally for our use.
   DownloadItemImpl(DownloadItemImplDelegate* delegate,
                    const FilePath& path,
                    const GURL& url,
                    content::DownloadId download_id,
                    const std::string& mime_type,
                    const net::BoundNetLog& bound_net_log);
@@ skipping 10 matching lines @@
   virtual void Delete(DeleteReason reason) OVERRIDE;
   virtual void Remove() OVERRIDE;
   virtual void OpenDownload() OVERRIDE;
   virtual void ShowDownloadInShell() OVERRIDE;
   virtual int32 GetId() const OVERRIDE;
   virtual content::DownloadId GetGlobalId() const OVERRIDE;
   virtual int64 GetDbHandle() const OVERRIDE;
   virtual DownloadState GetState() const OVERRIDE;
   virtual content::DownloadInterruptReason GetLastReason() const OVERRIDE;
   virtual bool IsPaused() const OVERRIDE;
+  virtual ResumeMode CanResumeInterrupted() const OVERRIDE;
   virtual bool IsTemporary() const OVERRIDE;
   virtual bool IsPersisted() const OVERRIDE;
   virtual bool IsPartialDownload() const OVERRIDE;
   virtual bool IsInProgress() const OVERRIDE;
   virtual bool IsCancelled() const OVERRIDE;
   virtual bool IsInterrupted() const OVERRIDE;
   virtual bool IsComplete() const OVERRIDE;
   virtual const GURL& GetURL() const OVERRIDE;
   virtual const std::vector<GURL>& GetUrlChain() const OVERRIDE;
   virtual const GURL& GetOriginalUrl() const OVERRIDE;
@@ skipping 23 matching lines @@
   virtual bool TimeRemaining(base::TimeDelta* remaining) const OVERRIDE;
   virtual int64 CurrentSpeed() const OVERRIDE;
   virtual int PercentComplete() const OVERRIDE;
   virtual bool AllDataSaved() const OVERRIDE;
   virtual int64 GetTotalBytes() const OVERRIDE;
   virtual int64 GetReceivedBytes() const OVERRIDE;
   virtual base::Time GetStartTime() const OVERRIDE;
   virtual base::Time GetEndTime() const OVERRIDE;
   virtual bool CanShowInFolder() OVERRIDE;
   virtual bool CanOpenDownload() OVERRIDE;
+  virtual bool CanResumeDownload() const OVERRIDE;
   virtual bool ShouldOpenFileBasedOnExtension() OVERRIDE;
   virtual bool GetOpenWhenComplete() const OVERRIDE;
   virtual bool GetAutoOpened() OVERRIDE;
   virtual bool GetOpened() const OVERRIDE;
   virtual content::DownloadPersistentStoreInfo
       GetPersistentStoreInfo() const OVERRIDE;
   virtual content::BrowserContext* GetBrowserContext() const OVERRIDE;
   virtual content::WebContents* GetWebContents() const OVERRIDE;
   virtual void DelayedDownloadOpened(bool auto_opened) OVERRIDE;
   virtual void OnContentCheckCompleted(
       content::DownloadDangerType danger_type) OVERRIDE;
   virtual void SetOpenWhenComplete(bool open) OVERRIDE;
   virtual void SetIsTemporary(bool temporary) OVERRIDE;
   virtual void SetOpened(bool opened) OVERRIDE;
   virtual void SetDisplayName(const FilePath& name) OVERRIDE;
   virtual std::string DebugString(bool verbose) const OVERRIDE;
   virtual void MockDownloadOpenForTesting() OVERRIDE;
+  virtual const net::BoundNetLog& GetBoundNetLog() const OVERRIDE;
+
+  void SetRequest(scoped_ptr<DownloadRequestHandleInterface> request_handle);
+  bool IsResuming() const;

[Randy Smith (Not in Mondays), 2012/10/15 00:36:08]

This (including the underlying state variable) doesn't appear to be used
anywhere; can we delete it?

 
   // All remaining public interfaces virtual to allow for DownloadItemImpl
   // mocks.
 
   // Main entry points for regular downloads, in order -------------------------
 
   // TODO(rdsmith): Fold the process that uses these fully into
   // DownloadItemImpl and pass callbacks to the delegate so that all of
   // these can be made private
 
@@ skipping 25 matching lines @@
 
   // Cancels the off-thread aspects of the download (such as
   // the corresponding URLRequest).
   // TODO(rdsmith): This should be private and only called from
   // DownloadItem::Cancel/Interrupt; it isn't now because we can't
   // call those functions from
   // DownloadManager::FileSelectionCancelled() without doing some
   // rewrites of the DownloadManager queues.
   virtual void OffThreadCancel();
 
+  // Completes the off-thread aspects of the download interruption.
+  virtual void OffThreadInterrupt();
+
   // Indicate that an error has occurred on the download.
   virtual void Interrupt(content::DownloadInterruptReason reason);
 
+  // User has resumed a download after an interruption.
+  // |req_handle| is the new request handle associated with the download.
+  virtual void Resume(scoped_ptr<DownloadRequestHandleInterface> req_handle);
+
   // DownloadItemImpl routines only needed by SavePackage ----------------------
 
   // Called by SavePackage to set the total number of bytes on the item.
   virtual void SetTotalBytes(int64 total_bytes);
 
   // Indicate progress in saving data to its destination.
   // |bytes_so_far| is the number of bytes received so far.
   // |hash_state| is the current hash state.
   virtual void UpdateProgress(int64 bytes_so_far,
                               int64 bytes_per_sec,
@@ skipping 84 matching lines @@
                         const std::string& final_hash);
 
   // Call to transition state; all state transitions should go through this.
   void TransitionTo(DownloadInternalState new_state);
 
   // Set the |danger_type_| and invoke obserers if necessary.
   void SetDangerType(content::DownloadDangerType danger_type);
 
   void SetFullPath(const FilePath& new_path);
 
-  // Mapping between internal and external states.
+  void AutoResumeIfValid();
+
   static DownloadState InternalToExternalState(
       DownloadInternalState internal_state);
   static DownloadInternalState ExternalToInternalState(
       DownloadState external_state);
 
   // Debugging routines --------------------------------------------------------
   static const char* DebugDownloadStateString(DownloadInternalState state);
+  static const char* DebugResumeModeString(DownloadItem::ResumeMode mode);
 
   // The handle to the request information.  Used for operations outside the
   // download system.
   scoped_ptr<DownloadRequestHandleInterface> request_handle_;
 
   // Download ID assigned by DownloadResourceHandler.
   content::DownloadId download_id_;
 
   // Display name for the download. If this is empty, then the display name is
   // considered to be |target_path_.BaseName()|.
@@ skipping 101 matching lines @@
 
   // Our persistent store handle.
   int64 db_handle_;
 
   // Our delegate.
   DownloadItemImplDelegate* delegate_;
 
   // In progress downloads may be paused by the user, we note it here.
   bool is_paused_;
 
+  // A download has been resumed.
+  bool is_resuming_;
+
+  // The number of times this download has been resumed automatically.
+  int auto_resume_count_;
+
   // 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_;
 
   // 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_;
 
+  // The download has been added to the history DB.
   bool is_persisted_;
 
   // True if the item was downloaded temporarily.
   bool is_temporary_;
 
   // True if we've saved all the data for the download.
   bool all_data_saved_;
 
   // Did the user open the item either directly or indirectly (such as by
   // setting always open files of this type)? The shelf also sets this field
   // when the user closes the shelf before the item has been opened but should
   // be treated as though the user opened it.
   bool opened_;
 
   // Do we actually open downloads when requested?  For testing purposes only.
   bool open_enabled_;
 
   // Did the delegate delay calling Complete on this download?
   bool delegate_delayed_complete_;
 
   // Net log to use for this download.
   const net::BoundNetLog bound_net_log_;
 
   base::WeakPtrFactory<DownloadItemImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItemImpl);
 };
 
 #endif  // CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_IMPL_H_