[Downloads] Rework how hashes are calculated for download files.

content/browser/download/download_manager_impl.cc

 // 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.
 
 #include "content/browser/download/download_manager_impl.h"
 
 #include <iterator>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 102 matching lines @@
       const std::vector<GURL>& url_chain,
       const GURL& referrer_url,
       const std::string& mime_type,
       const std::string& original_mime_type,
       const base::Time& start_time,
       const base::Time& end_time,
       const std::string& etag,
       const std::string& last_modified,
       int64_t received_bytes,
       int64_t total_bytes,
+      const std::string& hash,
       DownloadItem::DownloadState state,
       DownloadDangerType danger_type,
       DownloadInterruptReason interrupt_reason,
       bool opened,
       const net::BoundNetLog& bound_net_log) override {
     return new DownloadItemImpl(delegate,
                                 guid,
                                 download_id,
                                 current_path,
                                 target_path,
                                 url_chain,
                                 referrer_url,
                                 mime_type,
                                 original_mime_type,
                                 start_time,
                                 end_time,
                                 etag,
                                 last_modified,
                                 received_bytes,
                                 total_bytes,
+                                hash,
                                 state,
                                 danger_type,
                                 interrupt_reason,
                                 opened,
                                 bound_net_log);
   }
 
   DownloadItemImpl* CreateActiveItem(
       DownloadItemImplDelegate* delegate,
       uint32_t download_id,
@@ skipping 204 matching lines @@
     base::FilePath website_save_directory;  // Unused
     bool skip_dir_check = false;            // Unused
     delegate_->GetSaveDir(GetBrowserContext(), &website_save_directory,
                           &default_download_directory, &skip_dir_check);
   }
 
   scoped_ptr<DownloadFile> download_file;
 
   if (info->result == DOWNLOAD_INTERRUPT_REASON_NONE) {
     DCHECK(stream.get());
-    download_file.reset(file_factory_->CreateFile(
-        *info->save_info, default_download_directory, info->url(),
-        info->referrer_url, delegate_ && delegate_->GenerateFileHash(),
-        std::move(info->save_info->file), std::move(stream),
-        download->GetBoundNetLog(), download->DestinationObserverAsWeakPtr()));
-
-    if (download_file.get() && delegate_) {
-      download_file->SetClientGuid(
-          delegate_->ApplicationClientIdForFileScanning());
-    }
+    download_file.reset(
+        file_factory_->CreateFile(std::move(info->save_info),
+                                  default_download_directory,
+                                  std::move(stream),
+                                  download->GetBoundNetLog(),
+                                  download->DestinationObserverAsWeakPtr()));
   }
+  // It is important to leave info->save_info intact in the case of an interrupt
+  // so that the DownloadItem can salvage what it can out of a failed resumption
+  // attempt.
 
   download->Start(std::move(download_file), std::move(info->request_handle),
                   *info);
 
   // For interrupted downloads, Start() will transition the state to
   // IN_PROGRESS and consumers will be notified via OnDownloadUpdated().
   // For new downloads, we notify here, rather than earlier, so that
   // the download_file is bound to download and all the usual
   // setters (e.g. Cancel) work.
   if (new_download)
@@ skipping 222 matching lines @@
     const std::vector<GURL>& url_chain,
     const GURL& referrer_url,
     const std::string& mime_type,
     const std::string& original_mime_type,
     const base::Time& start_time,
     const base::Time& end_time,
     const std::string& etag,
     const std::string& last_modified,
     int64_t received_bytes,
     int64_t total_bytes,
+    const std::string& hash,
     DownloadItem::DownloadState state,
     DownloadDangerType danger_type,
     DownloadInterruptReason interrupt_reason,
     bool opened) {
   if (ContainsKey(downloads_, id)) {
     NOTREACHED();
     return NULL;
   }
   DCHECK(!ContainsKey(downloads_by_guid_, guid));
   DownloadItemImpl* item = item_factory_->CreatePersistedItem(
       this,
       guid,
       id,
       current_path,
       target_path,
       url_chain,
       referrer_url,
       mime_type,
       original_mime_type,
       start_time,
       end_time,
       etag,
       last_modified,
       received_bytes,
       total_bytes,
+      hash,
       state,
       danger_type,
       interrupt_reason,
       opened,
       net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD));
   downloads_[id] = item;
   downloads_by_guid_[guid] = item;
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadCreated(this, item));
   DVLOG(20) << __FUNCTION__ << "() download = " << item->DebugString(true);
   return item;
@@ skipping 53 matching lines @@
   if (delegate_)
     delegate_->OpenDownload(download);
 }
 
 void DownloadManagerImpl::ShowDownloadInShell(DownloadItemImpl* download) {
   if (delegate_)
     delegate_->ShowDownloadInShell(download);
 }
 
 }  // namespace content