[Downloads] Avoid resetting SecureHash state across an interruption.

content/browser/download/download_browsertest.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.
 
 // This file contains download browser tests that are known to be runnable
 // in a pure content context.  Over time tests should be migrated here.
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
@@ skipping 365 matching lines @@
   bool ShouldOpenDownload(
       DownloadItem* item,
       const DownloadOpenDelayedCallback& callback) override {
     if (delay_download_open_) {
       delayed_callbacks_.push_back(callback);
       return false;
     }
     return true;
   }
 
+  bool GenerateFileHash() override { return true; }
+
   void SetDelayedOpen(bool delay) {
     delay_download_open_ = delay;
   }
 
   void GetDelayedCallbacks(
       std::vector<DownloadOpenDelayedCallback>* callbacks) {
     callbacks->swap(delayed_callbacks_);
   }
  private:
   bool delay_download_open_;
@@ skipping 996 matching lines @@
   // Clear the old errors list.
   injector->ClearErrors();
   injector->InjectErrors();
 
   PrepareToResume();
   download->Resume();
   WaitForCompletion(download);
   EXPECT_EQ(download->GetState(), DownloadItem::COMPLETE);
 }
 
+IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest, Resume_Hash) {
+  using InjectedError = TestDownloadRequestHandler::InjectedError;
+  const char kExpectedHash[] =
+      "\xa7\x44\x49\x86\x24\xc6\x84\x6c\x89\xdf\xd8\xec\xa0\xe0\x61\x12\xdc\x80"
+      "\x13\xf2\x83\x49\xa9\x14\x52\x32\xf0\x95\x20\xca\x5b\x30";
+  std::string expected_hash(kExpectedHash);
+  TestDownloadRequestHandler request_handler;
+  TestDownloadRequestHandler::Parameters parameters;
+
+  // As a control, let's try GetHash() on an uninterrupted download.
+  request_handler.StartServing(parameters);
+  DownloadItem* uninterrupted_download(StartDownloadAndReturnItem(
+      initiator_shell_for_resumption(), request_handler.url()));
+  WaitForCompletion(uninterrupted_download);
+  EXPECT_EQ(expected_hash, uninterrupted_download->GetHash());
+
+  // Now with interruptions.
+  parameters.injected_errors.push(
+      InjectedError(100, net::ERR_CONNECTION_RESET));
+  parameters.injected_errors.push(
+      InjectedError(211, net::ERR_CONNECTION_RESET));
+  parameters.injected_errors.push(
+      InjectedError(337, net::ERR_CONNECTION_RESET));
+  parameters.injected_errors.push(
+      InjectedError(400, net::ERR_CONNECTION_RESET));
+  parameters.injected_errors.push(
+      InjectedError(512, net::ERR_CONNECTION_RESET));
+  request_handler.StartServing(parameters);
+
+  // Start and watch for interrupt.
+  DownloadItem* download(StartDownloadAndReturnItem(
+      initiator_shell_for_resumption(), request_handler.url()));
+  WaitForInterrupt(download);
+
+  PrepareToResume();
+  download->Resume();
+  WaitForInterrupt(download);
+
+  download->Resume();
+  WaitForInterrupt(download);
+
+  download->Resume();
+  WaitForInterrupt(download);
+
+  download->Resume();
+  WaitForInterrupt(download);
+
+  download->Resume();
+  WaitForCompletion(download);
+
+  EXPECT_EQ(expected_hash, download->GetHash());
+}
+
 // An interrupted download should remove the intermediate file when it is
 // cancelled.
 IN_PROC_BROWSER_TEST_P(DownloadResumptionContentTest,
                        CancelInterruptedDownload) {
   TestDownloadRequestHandler request_handler;
   request_handler.StartServing(
       TestDownloadRequestHandler::Parameters::WithSingleInterruption());
 
   DownloadItem* download = StartDownloadAndReturnItem(
       initiator_shell_for_resumption(), request_handler.url());
@@ skipping 398 matching lines @@
 
   std::vector<DownloadItem*> downloads;
   DownloadManagerForShell(shell())->GetAllDownloads(&downloads);
   ASSERT_EQ(1u, downloads.size());
 
   EXPECT_EQ(FILE_PATH_LITERAL("Jumboshrimp.txt"),
             downloads[0]->GetTargetFilePath().BaseName().value());
 }
 
 }  // namespace content