[Downloads] Always call DM::StartDownload() for explicit downloads.

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 <stdint.h>
 
 #include <string>
@@ skipping 55 matching lines @@
                    int64_t received_bytes,
                    int64_t total_bytes,
                    DownloadItem::DownloadState state,
                    DownloadDangerType danger_type,
                    DownloadInterruptReason interrupt_reason,
                    bool opened,
                    const net::BoundNetLog& bound_net_log);
 
   // Constructing for a regular download.
   // |bound_net_log| is constructed externally for our use.
+  // TODO(asanka): Get rid of the DownloadCreateInfo parameter since active
+  // downloads end up at Start() immediately after creation.
   DownloadItemImpl(DownloadItemImplDelegate* delegate,
                    uint32_t id,
                    const DownloadCreateInfo& info,
                    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,
                    uint32_t id,
                    const base::FilePath& path,
@@ skipping 74 matching lines @@
   std::string DebugString(bool verbose) const override;
 
   // All remaining public interfaces virtual to allow for DownloadItemImpl
   // mocks.
 
   // Determines the resume mode for an interrupted download. Requires
   // last_reason_ to be set, but doesn't require the download to be in
   // INTERRUPTED state.
   virtual ResumeMode GetResumeMode() const;
 
-  // Notify the download item that new origin information is available due to a
-  // resumption request receiving a response.
-  virtual void MergeOriginInfoOnResume(
-      const DownloadCreateInfo& new_create_info);
-
   // State transition operations on regular downloads --------------------------
 
   // Start the download.
   // |download_file| is the associated file on the storage medium.
   // |req_handle| is the new request handle associated with the download.
+  // |new_create_info| is a DownloadCreateInfo containing the new response
+  // parameters. It may be different from the DownloadCreateInfo used to create
+  // the DownloadItem if Start() is being called in response for a download
+  // resumption request.
   virtual void Start(scoped_ptr<DownloadFile> download_file,
-                     scoped_ptr<DownloadRequestHandleInterface> req_handle);
+                     scoped_ptr<DownloadRequestHandleInterface> req_handle,
+                     const DownloadCreateInfo& new_create_info);
 
   // Needed because of intertwining with DownloadManagerImpl -------------------
 
   // TODO(rdsmith): Unwind DownloadManagerImpl and DownloadItemImpl,
   // removing these from the public interface.
 
   // Notify observers that this item is being removed by the user.
   virtual void NotifyRemoved();
 
   virtual void OnDownloadedFileRemoved();
@@ skipping 40 matching lines @@
   // On debug builds, state transitions can be verified via
   // IsValidStateTransition() and IsValidSavePackageStateTransition(). Allowed
   // state transitions are described below, both for normal downloads and
   // SavePackage downloads.
   enum DownloadInternalState {
     // Initial state. Regular downloads are created in this state until the
     // Start() call is received.
     //
     // Transitions to (regular):
     //   TARGET_PENDING_INTERNAL: After a successful Start() call.
-    //   INTERRUPTED_INTERNAL:    Afater a failed Start() call.
+    //   INTERRUPTED_TARGET_PENDING_INTERNAL: After a failed Start() call.
     //
     // Transitions to (SavePackage):
     //   <n/a>                    SavePackage downloads never reach this state.
     INITIAL_INTERNAL,
 
     // Embedder is in the process of determining the target of the download.
     // Since the embedder is sensitive to state transitions during this time,
     // any DestinationError/DestinationCompleted events are deferred until
     // TARGET_RESOLVED_INTERNAL.
     //
     // Transitions to (regular):
     //   TARGET_RESOLVED_INTERNAL: Once the embedder invokes the callback.
+    //   INTERRUPTED_TARGET_PENDING_INTERNAL: An error occurred prior to target
+    //                            determination.
     //   CANCELLED_INTERNAL:      Cancelled.
     //
     // Transitions to (SavePackage):
     //   <n/a>                    SavePackage downloads never reach this state.
     TARGET_PENDING_INTERNAL,
 
+    // Embedder is in the process of determining the target of the download, and
+    // the download is in an interrupted state. The interrupted state is not
+    // exposed to the emedder until target determination is complete.
+    //
+    // Transitions to (regular):
+    //   INTERRUPTED_INTERNAL:    Once the target is determined, the download
+    //                            is marked as interrupted.
+    //   CANCELLED_INTERNAL:      Cancelled.
+    //
+    // Transitions to (SavePackage):
+    //   <n/a>                    SavePackage downloads never reach this state.
+    INTERRUPTED_TARGET_PENDING_INTERNAL,
+
     // Embedder has completed target determination. It is now safe to resolve
     // the download target as well as process deferred DestinationError events.
     // This state is differs from TARGET_PENDING_INTERNAL due to it being
     // allowed to transition to INTERRUPTED_INTERNAL, and it's different from
     // IN_PROGRESS_INTERNAL in that entering this state doesn't require having
     // a valid target. This state is transient (i.e. DownloadItemImpl will
     // transition out of it before yielding execution). It's only purpose in
     // life is to ensure the integrity of state transitions.
     //
     // Transitions to (regular):
@@ skipping 50 matching lines @@
     //
     // Transitions to (SavePackage):
     //   <n/a>                    SavePackage downloads never reach this state.
     INTERRUPTED_INTERNAL,
 
     // A request to resume this interrupted download is in progress.
     //
     // Transitions to (regular):
     //   TARGET_PENDING_INTERNAL: Once a server response is received from a
     //                            resumption.
+    //   INTERRUPTED_TARGET_PENDING_INTERNAL: A server response was received,
+    //                            but it indicated an error, and the download
+    //                            needs to go through target determination.
+    //   TARGET_RESOLVED_INTERNAL: A resumption attempt received an error
+    //                            but it was not necessary to go through target
+    //                            determination.
     //   CANCELLED_INTERNAL:      On cancel.
     //
     // Transitions to (SavePackage):
     //   <n/a>                    SavePackage downloads never reach this state.
     RESUMING_INTERNAL,
 
     // User has cancelled the download.
     // TODO(asanka): Merge interrupted and cancelled states.
     //
     // Transitions to (regular):
     //   <none>                   Terminal state.
     //
     // Transitions to (SavePackage):
     //   <none>                   Terminal state.
     CANCELLED_INTERNAL,
 
     MAX_DOWNLOAD_INTERNAL_STATE,
   };
 
-  // Used with TransitionTo() to indicate whether or not to call
-  // UpdateObservers() after the state transition.
-  enum ShouldUpdateObservers {
-    UPDATE_OBSERVERS,
-    DONT_UPDATE_OBSERVERS
-  };
-
   // Normal progression of a download ------------------------------------------
 
   // These are listed in approximately chronological order.  There are also
   // public methods involved in normal download progression; see
   // the implementation ordering in download_item_impl.cc.
 
   // Construction common to all constructors. |active| should be true for new
   // downloads and false for downloads from the history.
   // |download_type| indicates to the net log system what kind of download
   // this is.
   void Init(bool active, DownloadType download_type);
 
+  // Callback from file thread when we initialize the DownloadFile.
+  void OnDownloadFileInitialized(DownloadInterruptReason result);
+
+  // Called to determine the target path. Will cause OnDownloadTargetDetermined
+  // to be called when the target information is available.
+  void DetermineDownloadTarget();
+
   // Called when the target path has been determined. |target_path| is the
   // suggested target path. |disposition| indicates how the target path should
   // be used (see TargetDisposition). |danger_type| is the danger level of
   // |target_path| as determined by the caller. |intermediate_path| is the path
   // to use to store the download until OnDownloadCompleting() is called.
   virtual void OnDownloadTargetDetermined(
       const base::FilePath& target_path,
       TargetDisposition disposition,
       DownloadDangerType danger_type,
       const base::FilePath& intermediate_path);
 
-  // Callback from file thread when we initialize the DownloadFile.
-  void OnDownloadFileInitialized(DownloadInterruptReason result);
-
   void OnDownloadRenamedToIntermediateName(
       DownloadInterruptReason reason, const base::FilePath& full_path);
 
   // If all pre-requisites have been met, complete download processing, i.e. do
   // internal cleanup, file rename, and potentially auto-open.  (Dangerous
   // downloads still may block on user acceptance after this point.)
   void MaybeCompleteDownload();
 
   // Called when the download is ready to complete.
   // This may perform final rename if necessary and will eventually call
   // DownloadItem::Completed().
   void OnDownloadCompleting();
 
   void OnDownloadRenamedToFinalName(DownloadInterruptReason reason,
                                     const base::FilePath& full_path);
 
   // Called if the embedder took over opening a download, to indicate that
   // the download has been opened.
   void DelayedDownloadOpened(bool auto_opened);
 
   // Called when the entire download operation (including renaming etc.)
   // is completed.
   void Completed();
 
-  // Callback invoked when the URLRequest for a download resumption has started.
-  void OnResumeRequestStarted(DownloadItem* item,
-                              DownloadInterruptReason interrupt_reason);
-
   // Helper routines -----------------------------------------------------------
 
   // Indicate that an error has occurred on the download.
   void Interrupt(DownloadInterruptReason reason);
 
   // Destroy the DownloadFile object.  If |destroy_file| is true, the file is
   // destroyed with it.  Otherwise, DownloadFile::Detach() is called before
   // object destruction to prevent file destruction. Destroying the file also
   // resets |current_path_|.
   void ReleaseDownloadFile(bool destroy_file);
 
   // Check if a download is ready for completion.  The callback provided
   // may be called at some point in the future if an external entity
   // state has change s.t. this routine should be checked again.
   bool IsDownloadReadyForCompletion(const base::Closure& state_change_notify);
 
   // Call to transition state; all state transitions should go through this.
   // |notify_action| specifies whether or not to call UpdateObservers() after
   // the state transition.
-  void TransitionTo(DownloadInternalState new_state,
-                    ShouldUpdateObservers notify_action);
+  void TransitionTo(DownloadInternalState new_state);
 
   // Set the |danger_type_| and invoke observers if necessary.
   void SetDangerType(DownloadDangerType danger_type);
 
   void SetFullPath(const base::FilePath& new_path);
 
   void AutoResumeIfValid();
 
   void ResumeInterruptedDownload();
 
+  // Update origin information based on the response to a download resumption
+  // request. Should only be called if the resumption request was successful.
+  virtual void UpdateValidatorsOnResumption(
+      const DownloadCreateInfo& new_create_info);
+
   static DownloadState InternalToExternalState(
       DownloadInternalState internal_state);
   static DownloadInternalState ExternalToInternalState(
       DownloadState external_state);
 
   // Debugging routines --------------------------------------------------------
   static const char* DebugDownloadStateString(DownloadInternalState state);
   static const char* DebugResumeModeString(ResumeMode mode);
   static bool IsValidSavePackageStateTransition(DownloadInternalState from,
                                                 DownloadInternalState to);
@@ skipping 166 matching lines @@
   const net::BoundNetLog bound_net_log_;
 
   base::WeakPtrFactory<DownloadItemImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItemImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_IMPL_H_