Added member data to classes to support download resumption.

content/browser/download/download_file_manager.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_file_manager.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/task.h"
@@ skipping 91 matching lines @@
 }
 
 void DownloadFileManager::UpdateInProgressDownloads() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   for (DownloadFileMap::iterator i = downloads_.begin();
        i != downloads_.end(); ++i) {
     DownloadId global_id = i->first;
     DownloadFile* download_file = i->second;
     DownloadManager* manager = download_file->GetDownloadManager();
     if (manager) {
+      std::string partial_hash;
+      if (!download_file->GetPartialSha256Hash(&partial_hash))
+        partial_hash = "";
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           NewRunnableMethod(manager, &DownloadManager::UpdateDownload,
-                            global_id.local(), download_file->bytes_so_far()));
+                            global_id.local(), download_file->bytes_so_far(),
+                            partial_hash));
     }
   }
 }
 
 void DownloadFileManager::StartDownload(
     DownloadCreateInfo* info, const DownloadRequestHandle& request_handle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(info);
 
   DownloadManager* manager = request_handle.GetDownloadManager();
@@ skipping 32 matching lines @@
     const int data_len = (*contents)[i].second;
     if (!had_error && download_file) {
       net::Error write_result =
           download_file->AppendDataToFile(data->data(), data_len);
       if (write_result != net::OK) {
         // Write failed: interrupt the download.
         DownloadManager* download_manager = download_file->GetDownloadManager();
         had_error = true;
 
         int64 bytes_downloaded = download_file->bytes_so_far();
+        std::string partial_hash;
+        if (!download_file->GetPartialSha256Hash(&partial_hash))
+          partial_hash.clear();
+
         // Calling this here in case we get more data, to avoid
         // processing data after an error.  That could lead to
         // files that are corrupted if the later processing succeeded.
         CancelDownload(global_id);
         download_file = NULL;  // Was deleted in |CancelDownload|.
 
         if (download_manager) {
           BrowserThread::PostTask(
               BrowserThread::UI,
               FROM_HERE,
               NewRunnableMethod(
                   download_manager,
                   &DownloadManager::OnDownloadInterrupted,
                   global_id.local(),
                   bytes_downloaded,
+                  partial_hash,
                   ConvertNetErrorToInterruptReason(
                       write_result,
                       DOWNLOAD_INTERRUPT_FROM_DISK)));
         }
       }
     }
     data->Release();
   }
 }
 
@@ skipping 10 matching lines @@
     return;
 
   download_file->Finish();
 
   DownloadManager* download_manager = download_file->GetDownloadManager();
   if (!download_manager) {
     CancelDownload(global_id);
     return;
   }
 
-  std::string hash;
-  if (!download_file->GetSha256Hash(&hash))
-    hash.clear();
+  if (reason == DOWNLOAD_INTERRUPT_REASON_NONE) {
+    std::string hash;
+    if (!download_file->GetSha256Hash(&hash))
+      hash.clear();
 
-  if (reason == DOWNLOAD_INTERRUPT_REASON_NONE) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         NewRunnableMethod(
             download_manager,
             &DownloadManager::OnResponseCompleted,
             global_id.local(),
             download_file->bytes_so_far(),
             hash));
   } else {
+    std::string partial_hash;
+    if (!download_file->GetPartialSha256Hash(&partial_hash))
+      partial_hash.clear();
+
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         NewRunnableMethod(
             download_manager,
             &DownloadManager::OnDownloadInterrupted,
             global_id.local(),
             download_file->bytes_so_far(),
+            partial_hash,
             reason));
   }
   // We need to keep the download around until the UI thread has finalized
   // the name.
 }
 
 // This method will be sent via a user action, or shutdown on the UI thread, and
 // run on the download thread. Since this message has been sent from the UI
 // thread, the download may have already completed and won't exist in our map.
 void DownloadFileManager::CancelDownload(DownloadId global_id) {
@@ skipping 155 matching lines @@
 
   DownloadManager* download_manager = download_file->GetDownloadManager();
   if (!download_manager) {
     // Without a download manager, we can't cancel the request normally, so we
     // need to do it here.  The normal path will also update the download
     // history before canceling the request.
     download_file->CancelDownloadRequest();
     return;
   }
 
+  std::string partial_hash;
+  if (!download_file->GetPartialSha256Hash(&partial_hash))
+    partial_hash.clear();
+
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(download_manager,
                         &DownloadManager::OnDownloadInterrupted,
                         global_id.local(),
                         download_file->bytes_so_far(),
+                        partial_hash,
                         ConvertNetErrorToInterruptReason(
                             rename_error,
                             DOWNLOAD_INTERRUPT_FROM_DISK)));
 }
 
 void DownloadFileManager::EraseDownload(DownloadId global_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   if (!ContainsKey(downloads_, global_id))
     return;
 
   DownloadFile* download_file = downloads_[global_id];
 
   VLOG(20) << " " << __FUNCTION__ << "()"
            << " id = " << global_id
            << " download_file = " << download_file->DebugString();
 
   downloads_.erase(global_id);
 
   delete download_file;
 
   if (downloads_.empty())
     StopUpdateTimer();
 }