Added member data to classes to support download resumption.

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:
@@ skipping 145 matching lines @@
   // 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);
+  // Received a new chunk of data.
+  // |bytes_so_far| is the number of bytes received so far.
+  // |partial_hash| is the hash up to this point.  It will be an empty string
+  // if we are not calculating hashes.
+  void Update(int64 bytes_so_far, const std::string& partial_hash);
 
   // 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 |user_cancel| to false when canceling from at
   // exit to prevent this crash. This may result in a difference between the
   // downloaded file's size on disk, and what the history system's last record
   // of it is. At worst, we'll end up re-downloading a small portion of the file
   // when resuming a download (assuming the server supports byte ranges).
   void Cancel(bool user_cancel);
 
   // Called by external code (SavePackage) using the DownloadItem interface
   // to display progress when the DownloadItem should be considered complete.
   void MarkAsComplete();
 
   // Called by the delegate after it delayed opening the download in
   // DownloadManagerDelegate::ShouldOpenDownload.
   void DelayedDownloadOpened();
 
   // Called when all data has been saved.
   void OnAllDataSaved(int64 size, const std::string& final_hash);
 
   // Called when the downloaded file is removed.
   void OnDownloadedFileRemoved();
 
   // Download operation had an error.
   // |size| is the amount of data received at interruption.
+  // |partial_hash| is the current hash value at interruption.
   // |reason| is the download interrupt reason code that the operation received.
-  void Interrupted(int64 size, InterruptReason reason);
+  void Interrupted(int64 size,
+                   const std::string partial_hash,
+                   InterruptReason reason);
 
   // Deletes the file from disk and removes the download from the views and
   // history.  |user| should be true if this is the result of the user clicking
   // the discard button, and false if it is being deleted for other reasons like
   // browser shutdown.
   void Delete(DeleteReason reason);
 
   // Removes the download from the views and history.
   void Remove();
 
@@ skipping 98 matching lines @@
   const FilePath& target_name() const { return state_info_.target_name; }
   bool prompt_user_for_save_location() const {
     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_; }
   void set_opened(bool opened) { opened_ = opened; }
   bool opened() const { return opened_; }
 
+  const std::string& last_modified_time() const { return last_modified_time_; }
+  void set_last_modified_time(const std::string& time) {
+    last_modified_time_ = time;
+  }
+  const std::string& etag() const { return etag_; }
+  void set_etag(const std::string& tag) { etag_ = tag; }

[Randy Smith (Not in Mondays), 2011/11/15 18:45:26]

Under what circumstances are the setters used?  Can we replace them with an
UpdateOnResumption(DownloadCreateInfo)?

[ahendrickson, 2011/11/16 15:41:08]

We need the getters (or an equivalent function) when we resume a download, and
possibly to save to the history DB.

The setters can be removed, as they only need to be set at construction time
(Done).

[Randy Smith (Not in Mondays), 2011/11/16 18:29:27]

So you're not planning to update these values when you do a resumption?  I'm
inclined to think you should--if you restart, they may change, and there's no
reason to disable continuation after restart if the restart happened because of
an etag/last_modified mismatch.  I'd just rather than that update get done in a
function that's targeted at that update, thus my suggestion of
UpdateOnResumption.

[ahendrickson, 2011/11/19 20:18:03]

You're right, and I'll put them back in when they are necessary.

+
   InterruptReason last_reason() const { return last_reason_; }
 
   DownloadPersistentStoreInfo GetPersistentStoreInfo() const;
   DownloadStateInfo state_info() const { return state_info_; }
 
   TabContents* GetTabContents() const;
 
   // Returns the final target file path for the download.
   FilePath GetTargetFilePath() const;
 
@@ skipping 24 matching lines @@
   void MockDownloadOpenForTesting() { open_enabled_ = false; }
 
  private:
   // Construction common to all constructors. |active| should be true for new
   // downloads and false for downloads from the history.
   void Init(bool active);
 
   // Internal helper for maintaining consistent received and total sizes.
   void UpdateSize(int64 size);
 
+  // Internal helper for keeping track of the hash as we receive data.
+  void UpdateHash(const std::string& partial_hash);

[Randy Smith (Not in Mondays), 2011/11/15 18:45:26]

Given that we worked out in a different comment thread that it's fairly
important for resumption that the hash and size need to be kept in sync, I'd be
more inclined to fold this argument into UpdateSize (maybe change the name to
UpdateSizeAndHash).

[ahendrickson, 2011/11/16 15:41:08]

Done.

+
   // Called when the entire download operation (including renaming etc)
   // is completed.
   void Completed();
 
   // Call to transition state; all state transitions should go through this.
   void TransitionTo(DownloadState new_state);
 
   // Called when safety_state_ should be recomputed from is_dangerous_file
   // and is_dangerous_url.
   void UpdateSafetyState();
@@ skipping 40 matching lines @@
 
   // The value of the content type header sent with the downloaded item.  It
   // may be different from |mime_type_|, which may be set based on heuristics
   // which may look at the file extension and first few bytes of the file.
   std::string original_mime_type_;
 
   // The charset of the referring page where the download request comes from.
   // It's used to construct a suggested filename.
   std::string referrer_charset_;
 
-  // Total bytes expected
+  // Total bytes expected.
   int64 total_bytes_;
 
-  // Current received bytes
+  // Current received bytes.
   int64 received_bytes_;
 
   // Sha256 hash of the content.  This might be empty either because
-  // the download isn't done yet or because the hash isn't needed
+  // the download hasn't started yet or because the hash isn't needed
   // (ChromeDownloadManagerDelegate::GenerateFileHash() returned false).
   std::string hash_;
 
+  // Server's time stamp for the file.
+  std::string last_modified_time_;
+
+  // Server's ETAG for the file.
+  std::string etag_;
+
   // Last reason.
   InterruptReason last_reason_;
 
-  // Start time for calculating remaining time
+  // Start time for calculating remaining time.
   base::TimeTicks start_tick_;
 
-  // The current state of this download
+  // The current state of this download.
   DownloadState state_;
 
-  // The views of this item in the download shelf and download tab
+  // The views of this item in the download shelf and download tab.
   ObserverList<Observer> observers_;
 
-  // Time the download was started
+  // Time the download was started.
   base::Time start_time_;
 
-  // Time the download completed
+  // Time the download completed.
   base::Time end_time_;
 
-  // Our persistent store handle
+  // Our persistent store handle.
   int64 db_handle_;
 
-  // Our owning object
+  // Our owning object.
   DownloadManager* download_manager_;
 
-  // In progress downloads may be paused by the user, we note it here
+  // 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_;
 
   // 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).
@@ skipping 23 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_