Clear the received slices in DownloadItemImpl when etag changed.

content/browser/download/download_item_impl_unittest.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_item_impl.h"
 
 #include <stdint.h>
 
 #include <deque>
 #include <iterator>
@@ skipping 283 matching lines @@
                                           DownloadTargetCallback* callback) {
     MockDownloadFile* mock_download_file = nullptr;
     std::unique_ptr<DownloadFile> download_file;
     EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(item, _))
         .WillOnce(SaveArg<1>(callback));
 
     // Only create a DownloadFile if the request was successful.
     if (create_info_->result == DOWNLOAD_INTERRUPT_REASON_NONE) {
       mock_download_file = new StrictMock<MockDownloadFile>;
       download_file.reset(mock_download_file);
-      EXPECT_CALL(*mock_download_file, Initialize(_))
+      EXPECT_CALL(*mock_download_file, Initialize(_, _))
           .WillOnce(ScheduleCallbackWithParam(DOWNLOAD_INTERRUPT_REASON_NONE));
       EXPECT_CALL(*mock_download_file, FullPath())
           .WillRepeatedly(ReturnRefOfCopy(base::FilePath()));
     }
 
     std::unique_ptr<MockRequestHandle> request_handle =
         base::MakeUnique<NiceMock<MockRequestHandle>>();
     item->Start(std::move(download_file), std::move(request_handle),
                 *create_info_);
     RunAllPendingInMessageLoops();
@@ skipping 271 matching lines @@
 }
 
 TEST_F(DownloadItemTest, NotificationAfterTogglePause) {
   DownloadItemImpl* item = CreateDownloadItem();
   TestDownloadItemObserver observer(item);
   MockDownloadFile* mock_download_file(new MockDownloadFile);
   std::unique_ptr<DownloadFile> download_file(mock_download_file);
   std::unique_ptr<DownloadRequestHandleInterface> request_handle(
       new NiceMock<MockRequestHandle>);
 
-  EXPECT_CALL(*mock_download_file, Initialize(_));
+  EXPECT_CALL(*mock_download_file, Initialize(_, _));
   EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(_, _));
   item->Start(std::move(download_file), std::move(request_handle),
               *create_info());
 
   item->Pause();
   ASSERT_TRUE(observer.CheckAndResetDownloadUpdated());
 
   ASSERT_TRUE(item->IsPaused());
 
   item->Resume();
@@ skipping 277 matching lines @@
   EXPECT_EQ(kFirstLastModified, item->GetLastModifiedTime());
   EXPECT_EQ(kFirstURL, item->GetURL().spec());
   EXPECT_EQ(kMimeType, item->GetMimeType());
   EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED, item->GetLastReason());
   EXPECT_EQ(kDummyIntermediatePath, item->GetFullPath().value());
   EXPECT_EQ(1, item->GetReceivedBytes());
 }
 
 // If the download resumption request succeeds, the origin state should be
-// updated
+// updated.
 TEST_F(DownloadItemTest, SucceededResumptionUpdatesOriginState) {
   const char kContentDisposition[] = "attachment; filename=foo";
   const char kFirstETag[] = "ABC";
   const char kFirstLastModified[] = "Yesterday";
   const char kFirstURL[] = "http://www.example.com/download";
   const char kMimeType[] = "text/css";
   create_info()->content_disposition = kContentDisposition;
   create_info()->etag = kFirstETag;
   create_info()->last_modified = kFirstLastModified;
   create_info()->url_chain.push_back(GURL(kFirstURL));
@@ skipping 29 matching lines @@
 
   EXPECT_EQ(kSecondContentDisposition, item->GetContentDisposition());
   EXPECT_EQ(kSecondETag, item->GetETag());
   EXPECT_EQ(kSecondLastModified, item->GetLastModifiedTime());
   EXPECT_EQ(kSecondURL, item->GetURL().spec());
   EXPECT_EQ(kSecondMimeType, item->GetMimeType());
 
   CleanupItem(item, download_file, DownloadItem::IN_PROGRESS);
 }
 
+// Ensure when strong validators changed on resumption, the received
+// slices should be cleared.
+TEST_F(DownloadItemTest, ClearReceivedSliceIfEtagChanged) {
+  const char kFirstETag[] = "ABC";
+  const char kSecondETag[] = "123";
+  const DownloadItem::ReceivedSlices kReceivedSlice = {
+      DownloadItem::ReceivedSlice(0, 10)};
+  create_info()->etag = kFirstETag;
+
+  DownloadItemImpl* item = CreateDownloadItem();
+  MockDownloadFile* download_file =
+      DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
+
+  EXPECT_CALL(*mock_delegate(), MockResumeInterruptedDownload(_, _));
+  EXPECT_CALL(*download_file, Detach());
+
+  item->DestinationObserverAsWeakPtr()->DestinationUpdate(10, 100,
+                                                          kReceivedSlice);
+  EXPECT_EQ(kReceivedSlice, item->GetReceivedSlices());
+  EXPECT_EQ(10, item->GetReceivedBytes());
+
+  item->DestinationObserverAsWeakPtr()->DestinationError(
+      DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR, 0,
+      std::unique_ptr<crypto::SecureHash>());
+  EXPECT_EQ(kReceivedSlice, item->GetReceivedSlices());
+
+  RunAllPendingInMessageLoops();
+
+  // Change the strong validator and resume the download, the received slices
+  // should be cleared.
+  create_info()->etag = kSecondETag;
+  DownloadTargetCallback target_callback;
+  download_file = CallDownloadItemStart(item, &target_callback);
+  EXPECT_TRUE(item->GetReceivedSlices().empty());
+  EXPECT_EQ(0, item->GetReceivedBytes());
+
+  CleanupItem(item, download_file, DownloadItem::IN_PROGRESS);
+}
+
 // Test that resumption uses the final URL in a URL chain when resuming.
 TEST_F(DownloadItemTest, ResumeUsesFinalURL) {
   create_info()->save_info->prompt_for_save_location = false;
   create_info()->url_chain.clear();
   create_info()->url_chain.push_back(GURL("http://example.com/a"));
   create_info()->url_chain.push_back(GURL("http://example.com/b"));
   create_info()->url_chain.push_back(GURL("http://example.com/c"));
 
   DownloadItemImpl* item = CreateDownloadItem();
   TestDownloadItemObserver observer(item);
@@ skipping 46 matching lines @@
   EXPECT_EQ(FILE_PATH_LITERAL("new.name"),
             item->GetFileNameToReportUser().value());
   CleanupItem(item, download_file, DownloadItem::IN_PROGRESS);
 }
 
 // Test to make sure that Start method calls DF initialize properly.
 TEST_F(DownloadItemTest, Start) {
   MockDownloadFile* mock_download_file(new MockDownloadFile);
   std::unique_ptr<DownloadFile> download_file(mock_download_file);
   DownloadItemImpl* item = CreateDownloadItem();
-  EXPECT_CALL(*mock_download_file, Initialize(_));
+  EXPECT_CALL(*mock_download_file, Initialize(_, _));
   std::unique_ptr<DownloadRequestHandleInterface> request_handle(
       new NiceMock<MockRequestHandle>);
   EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(item, _));
   item->Start(std::move(download_file), std::move(request_handle),
               *create_info());
   RunAllPendingInMessageLoops();
 
   CleanupItem(item, mock_download_file, DownloadItem::IN_PROGRESS);
 }
 
 // Download file and the request should be cancelled as a result of download
 // file initialization failing.
 TEST_F(DownloadItemTest, InitDownloadFileFails) {
   DownloadItemImpl* item = CreateDownloadItem();
   std::unique_ptr<MockDownloadFile> file = base::MakeUnique<MockDownloadFile>();
   std::unique_ptr<MockRequestHandle> request_handle =
       base::MakeUnique<MockRequestHandle>();
 
   EXPECT_CALL(*file, Cancel());
   EXPECT_CALL(*request_handle, CancelRequest());
-  EXPECT_CALL(*file, Initialize(_))
+  EXPECT_CALL(*file, Initialize(_, _))
       .WillOnce(ScheduleCallbackWithParam(
           DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED));
 
   base::RunLoop start_download_loop;
   DownloadTargetCallback download_target_callback;
   EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(item, _))
       .WillOnce(DoAll(SaveArg<1>(&download_target_callback),
                       ScheduleClosure(start_download_loop.QuitClosure())));
 
   item->Start(std::move(file), std::move(request_handle), *create_info());
@@ skipping 1001 matching lines @@
 // Run through the DII workflow but the embedder cancels the download at target
 // determination.
 TEST_P(DownloadItemDestinationUpdateRaceTest, DownloadCancelledByUser) {
   // Expect that the download file and the request will be cancelled as a
   // result.
   EXPECT_CALL(*file_, Cancel());
   EXPECT_CALL(*request_handle_, CancelRequest());
 
   base::RunLoop download_start_loop;
   DownloadFile::InitializeCallback initialize_callback;
-  EXPECT_CALL(*file_, Initialize(_))
+  EXPECT_CALL(*file_, Initialize(_, _))
       .WillOnce(DoAll(SaveArg<0>(&initialize_callback),
                       ScheduleClosure(download_start_loop.QuitClosure())));
   item_->Start(std::move(file_), std::move(request_handle_), *create_info());
   download_start_loop.Run();
 
   base::WeakPtr<DownloadDestinationObserver> destination_observer =
       item_->DestinationObserverAsWeakPtr();
 
   ScheduleObservations(PreInitializeFileObservations(), destination_observer);
   RunAllPendingInMessageLoops();
@@ skipping 32 matching lines @@
   // DownloadFile expectations since we are about to transfer its ownership to
   // the DownloadItem.
   base::RunLoop intermediate_rename_loop;
   DownloadFile::RenameCompletionCallback intermediate_rename_callback;
   EXPECT_CALL(*file_, RenameAndUniquify(_, _))
       .WillOnce(DoAll(SaveArg<1>(&intermediate_rename_callback),
                       ScheduleClosure(intermediate_rename_loop.QuitClosure())));
 
   base::RunLoop download_start_loop;
   DownloadFile::InitializeCallback initialize_callback;
-  EXPECT_CALL(*file_, Initialize(_))
+  EXPECT_CALL(*file_, Initialize(_, _))
       .WillOnce(DoAll(SaveArg<0>(&initialize_callback),
                       ScheduleClosure(download_start_loop.QuitClosure())));
 
   item_->Start(std::move(file_), std::move(request_handle_), *create_info());
   download_start_loop.Run();
   base::WeakPtr<DownloadDestinationObserver> destination_observer =
       item_->DestinationObserverAsWeakPtr();
 
   ScheduleObservations(PreInitializeFileObservations(), destination_observer);
   RunAllPendingInMessageLoops();
@@ skipping 49 matching lines @@
   // DownloadFile expectations since we are about to transfer its ownership to
   // the DownloadItem.
   base::RunLoop intermediate_rename_loop;
   DownloadFile::RenameCompletionCallback intermediate_rename_callback;
   EXPECT_CALL(*file_, RenameAndUniquify(_, _))
       .WillOnce(DoAll(SaveArg<1>(&intermediate_rename_callback),
                       ScheduleClosure(intermediate_rename_loop.QuitClosure())));
 
   base::RunLoop download_start_loop;
   DownloadFile::InitializeCallback initialize_callback;
-  EXPECT_CALL(*file_, Initialize(_))
+  EXPECT_CALL(*file_, Initialize(_, _))
       .WillOnce(DoAll(SaveArg<0>(&initialize_callback),
                       ScheduleClosure(download_start_loop.QuitClosure())));
 
   item_->Start(std::move(file_), std::move(request_handle_), *create_info());
   download_start_loop.Run();
   base::WeakPtr<DownloadDestinationObserver> destination_observer =
       item_->DestinationObserverAsWeakPtr();
 
   ScheduleObservations(PreInitializeFileObservations(), destination_observer);
   RunAllPendingInMessageLoops();
@@ skipping 45 matching lines @@
 
   item_->Cancel(true);
   RunAllPendingInMessageLoops();
 }
 
 TEST(MockDownloadItem, Compiles) {
   MockDownloadItem mock_item;
 }
 
 }  // namespace content