Added member data to classes to support download resumption.

content/browser/download/download_item_impl.cc

 // 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.
 
 #include "content/browser/download/download_item_impl.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 114 matching lines @@
 
 // Constructor for reading from the history service.
 DownloadItemImpl::DownloadItemImpl(DownloadManager* download_manager,
                                    const DownloadPersistentStoreInfo& info)
     : download_id_(download_manager->GetNextId()),
       full_path_(info.path),
       url_chain_(1, info.url),
       referrer_url_(info.referrer_url),
       total_bytes_(info.total_bytes),
       received_bytes_(info.received_bytes),
+      last_reason_(DOWNLOAD_INTERRUPT_REASON_NONE),
       start_tick_(base::TimeTicks()),
       state_(static_cast<DownloadState>(info.state)),
       start_time_(info.start_time),
       end_time_(info.end_time),
       db_handle_(info.db_handle),
       download_manager_(download_manager),
       is_paused_(false),
       open_when_complete_(false),
       file_externally_removed_(false),
       safety_state_(SAFE),
@@ skipping 172 matching lines @@
   UMA_HISTOGRAM_ENUMERATION("Download.DangerousDownloadValidated",
                             GetDangerType(),
                             DownloadStateInfo::DANGEROUS_TYPE_MAX);
 
   safety_state_ = DANGEROUS_BUT_VALIDATED;
   UpdateObservers();
 
   download_manager_->MaybeCompleteDownload(this);
 }
 
-void DownloadItemImpl::UpdateSize(int64 bytes_so_far) {
+void DownloadItemImpl::ProgressComplete(int64 bytes_so_far,
+                                        const std::string& final_hash) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  hash_ = final_hash;
+  hash_state_ = "";
+
   received_bytes_ = bytes_so_far;
 
   // If we've received more data than we were expecting (bad server info?),
   // revert to 'unknown size mode'.
   if (received_bytes_ > total_bytes_)
     total_bytes_ = 0;
 }
 
+void DownloadItemImpl::UpdateProgress(int64 bytes_so_far,
+                                      const std::string& hash_state) {
+  hash_state_ = hash_state;
+
+  received_bytes_ = bytes_so_far;
+
+  // If we've received more data than we were expecting (bad server info?),
+  // revert to 'unknown size mode'.
+  if (received_bytes_ > total_bytes_)
+    total_bytes_ = 0;
+}
+
 // Updates from the download thread may have been posted while this download
 // was being cancelled in the UI thread, so we'll accept them unless we're
 // complete.
-void DownloadItemImpl::Update(int64 bytes_so_far) {
+void DownloadItemImpl::Update(int64 bytes_so_far,
+                              const std::string& hash_state) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!IsInProgress()) {
     NOTREACHED();
     return;
   }
-  UpdateSize(bytes_so_far);
+  UpdateProgress(bytes_so_far, hash_state);
   UpdateObservers();
 }
 
 // Triggered by a user action.
 void DownloadItemImpl::Cancel(bool user_cancel) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   last_reason_ = user_cancel ?
       DOWNLOAD_INTERRUPT_REASON_USER_CANCELED :
@@ skipping 27 matching lines @@
   Completed();
 }
 
 void DownloadItemImpl::OnAllDataSaved(
     int64 size, const std::string& final_hash) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DCHECK(!all_data_saved_);
   all_data_saved_ = true;
-  UpdateSize(size);
-  hash_ = final_hash;
+  ProgressComplete(size, final_hash);
 }
 
 void DownloadItemImpl::OnDownloadedFileRemoved() {
   file_externally_removed_ = true;
   UpdateObservers();
 }
 
 void DownloadItemImpl::Completed() {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 40 matching lines @@
 }
 
 void DownloadItemImpl::UpdateTarget() {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (state_info_.target_name.value().empty())
     state_info_.target_name = full_path_.BaseName();
 }
 
-void DownloadItemImpl::Interrupted(int64 size, InterruptReason reason) {
+void DownloadItemImpl::Interrupted(int64 size,
+                                   const std::string& hash_state,
+                                   InterruptReason reason) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!IsInProgress())
     return;
 
   last_reason_ = reason;
-  UpdateSize(size);
+  UpdateProgress(size, hash_state);
   download_stats::RecordDownloadInterrupted(reason,
                                             received_bytes_,
                                             total_bytes_);
   TransitionTo(INTERRUPTED);
 }
 
 void DownloadItemImpl::Delete(DeleteReason reason) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 249 matching lines @@
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           base::Bind(&DownloadFileManager::CancelDownload,
                                      file_manager, GetGlobalId()));
 }
 
 void DownloadItemImpl::Init(bool active) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   UpdateTarget();
-  if (active) {
+  if (active)
     download_stats::RecordDownloadCount(download_stats::START_COUNT);
-  }
   VLOG(20) << __FUNCTION__ << "() " << DebugString(true);
 }
 
 // TODO(ahendrickson) -- Move |INTERRUPTED| from |IsCancelled()| to
 // |IsPartialDownload()|, when resuming interrupted downloads is implemented.
 bool DownloadItemImpl::IsPartialDownload() const {
   return (state_ == IN_PROGRESS);
 }
 
 bool DownloadItemImpl::IsInProgress() const {
@@ skipping 40 matching lines @@
   }
 
   if (verbose) {
     description += base::StringPrintf(
         " db_handle = %" PRId64
         " total_bytes = %" PRId64
         " received_bytes = %" PRId64
         " is_paused = %c"
         " is_otr = %c"
         " safety_state = %s"
+        " last_modified = '%s'"
+        " etag = '%s'"
         " url_chain = \n\t\"%s\"\n\t"
         " target_name = \"%" PRFilePath "\""
         " full_path = \"%" PRFilePath "\"",
         GetDbHandle(),
         GetTotalBytes(),
         GetReceivedBytes(),
         IsPaused() ? 'T' : 'F',
         IsOtr() ? 'T' : 'F',
         DebugSafetyStateString(GetSafetyState()),
+        GetLastModifiedTime().c_str(),
+        GetETag().c_str(),
         url_list.c_str(),
         state_info_.target_name.value().c_str(),
         GetFullPath().value().c_str());
   } else {
     description += base::StringPrintf(" url = \"%s\"", url_list.c_str());
   }
 
   description += " }";
 
   return description;
@@ skipping 26 matching lines @@
 }
 std::string DownloadItemImpl::GetReferrerCharset() const {
   return referrer_charset_;
 }
 int64 DownloadItemImpl::GetTotalBytes() const { return total_bytes_; }
 void DownloadItemImpl::SetTotalBytes(int64 total_bytes) {
   total_bytes_ = total_bytes;
 }
 const std::string& DownloadItemImpl::GetHash() const { return hash_; }
 int64 DownloadItemImpl::GetReceivedBytes() const { return received_bytes_; }
+const std::string& DownloadItemImpl::GetHashState() const {

[Randy Smith (Not in Mondays), 2011/11/23 19:40:24]

Just noticed that we use HashState here and Sha256HashState on *File.  Is there
a reason for the difference?  (This comment should probably be bundled with my
"Should we be using Sha256?" comment.)

[ahendrickson, 2011/12/20 00:04:14]

Changed to using just "Hash" instead of "Sha256Hash".

+  return hash_state_;
+}
 int32 DownloadItemImpl::GetId() const { return download_id_.local(); }
 DownloadId DownloadItemImpl::GetGlobalId() const { return download_id_; }
 base::Time DownloadItemImpl::GetStartTime() const { return start_time_; }
 base::Time DownloadItemImpl::GetEndTime() const { return end_time_; }
 void DownloadItemImpl::SetDbHandle(int64 handle) { db_handle_ = handle; }
 int64 DownloadItemImpl::GetDbHandle() const { return db_handle_; }
 DownloadManager* DownloadItemImpl::GetDownloadManager() {
   return download_manager_;
 }
 bool DownloadItemImpl::IsPaused() const { return is_paused_; }
@@ skipping 16 matching lines @@
 }
 bool DownloadItemImpl::PromptUserForSaveLocation() const {
   return state_info_.prompt_user_for_save_location;
 }
 const FilePath& DownloadItemImpl::GetSuggestedPath() const {
   return state_info_.suggested_path;
 }
 bool DownloadItemImpl::IsTemporary() const { return is_temporary_; }
 void DownloadItemImpl::SetOpened(bool opened) { opened_ = opened; }
 bool DownloadItemImpl::GetOpened() const { return opened_; }
+const std::string& DownloadItemImpl::GetLastModifiedTime() const {
+  return last_modified_time_;
+}
+const std::string& DownloadItemImpl::GetETag() const { return etag_; }
 InterruptReason DownloadItemImpl::GetLastReason() const {
   return last_reason_;
 }
 DownloadStateInfo DownloadItemImpl::GetStateInfo() const { return state_info_; }
 bool DownloadItemImpl::NeedsRename() const {
   return state_info_.target_name != full_path_.BaseName();
 }
 void DownloadItemImpl::MockDownloadOpenForTesting() { open_enabled_ = false; }