Clear the received slices in DownloadItemImpl when etag changed.

content/public/test/test_file_error_injector.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/public/test/test_file_error_injector.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 16 matching lines @@
 
 namespace {
 
 // A class that performs file operations and injects errors.
 class DownloadFileWithError: public DownloadFileImpl {
  public:
   DownloadFileWithError(
       std::unique_ptr<DownloadSaveInfo> save_info,
       const base::FilePath& default_download_directory,
       std::unique_ptr<ByteStreamReader> byte_stream,
-      const std::vector<DownloadItem::ReceivedSlice>& received_slices,
       const net::NetLogWithSource& net_log,
       base::WeakPtr<DownloadDestinationObserver> observer,
       const TestFileErrorInjector::FileErrorInfo& error_info,
       const base::Closure& ctor_callback,
       const base::Closure& dtor_callback);
 
   ~DownloadFileWithError() override;
 
-  void Initialize(const InitializeCallback& callback) override;
+  void Initialize(const InitializeCallback& callback,
+                  const DownloadItem::ReceivedSlices& received_slices) override;
 
   // DownloadFile interface.
   DownloadInterruptReason WriteDataToFile(int64_t offset,
                                           const char* data,
                                           size_t data_len) override;
 
   void RenameAndUniquify(const base::FilePath& full_path,
                          const RenameCompletionCallback& callback) override;
   void RenameAndAnnotate(const base::FilePath& full_path,
                          const std::string& client_guid,
@@ skipping 42 matching lines @@
   original_callback.Run(
       overwrite_error,
       overwrite_error == DOWNLOAD_INTERRUPT_REASON_NONE ?
       path_result : base::FilePath());
 }
 
 DownloadFileWithError::DownloadFileWithError(
     std::unique_ptr<DownloadSaveInfo> save_info,
     const base::FilePath& default_download_directory,
     std::unique_ptr<ByteStreamReader> byte_stream,
-    const std::vector<DownloadItem::ReceivedSlice>& received_slices,
     const net::NetLogWithSource& net_log,
     base::WeakPtr<DownloadDestinationObserver> observer,
     const TestFileErrorInjector::FileErrorInfo& error_info,
     const base::Closure& ctor_callback,
     const base::Closure& dtor_callback)
     : DownloadFileImpl(std::move(save_info),
                        default_download_directory,
                        std::move(byte_stream),
-                       received_slices,
                        net_log,
                        observer),
       error_info_(error_info),
       destruction_callback_(dtor_callback) {
   // DownloadFiles are created on the UI thread and are destroyed on the FILE
   // thread. Schedule the ConstructionCallback on the FILE thread so that if a
   // DownloadItem schedules a DownloadFile to be destroyed and creates another
   // one (as happens during download resumption), then the DestructionCallback
   // for the old DownloadFile is run before the ConstructionCallback for the
   // next DownloadFile.
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, ctor_callback);
 }
 
 DownloadFileWithError::~DownloadFileWithError() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   destruction_callback_.Run();
 }
 
 void DownloadFileWithError::Initialize(
-    const InitializeCallback& callback) {
+    const InitializeCallback& callback,
+    const DownloadItem::ReceivedSlices& received_slices) {
   DownloadInterruptReason error_to_return = DOWNLOAD_INTERRUPT_REASON_NONE;
   InitializeCallback callback_to_use = callback;
 
   // Replace callback if the error needs to be overwritten.
   if (OverwriteError(
           TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
           &error_to_return)) {
     if (DOWNLOAD_INTERRUPT_REASON_NONE != error_to_return) {
       // Don't execute a, probably successful, Initialize; just
       // return the error.
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE, base::Bind(
               callback, error_to_return));
       return;
     }
 
     // Otherwise, just wrap the return.
     callback_to_use = base::Bind(&InitializeErrorCallback, callback,
                                  error_to_return);
   }
 
-  DownloadFileImpl::Initialize(callback_to_use);
+  DownloadFileImpl::Initialize(callback_to_use, received_slices);
 }
 
 DownloadInterruptReason DownloadFileWithError::WriteDataToFile(
     int64_t offset,
     const char* data,
     size_t data_len) {
   return ShouldReturnError(
       TestFileErrorInjector::FILE_OPERATION_WRITE,
       DownloadFileImpl::WriteDataToFile(offset, data, data_len));
 }
@@ skipping 86 matching lines @@
  public:
   DownloadFileWithErrorFactory(const base::Closure& ctor_callback,
                                 const base::Closure& dtor_callback);
   ~DownloadFileWithErrorFactory() override;
 
   // DownloadFileFactory interface.
   DownloadFile* CreateFile(
       std::unique_ptr<DownloadSaveInfo> save_info,
       const base::FilePath& default_download_directory,
       std::unique_ptr<ByteStreamReader> byte_stream,
-      const std::vector<DownloadItem::ReceivedSlice>& received_slices,
       const net::NetLogWithSource& net_log,
       base::WeakPtr<DownloadDestinationObserver> observer) override;
 
   bool SetError(TestFileErrorInjector::FileErrorInfo error);
 
  private:
   // Our injected error.
   TestFileErrorInjector::FileErrorInfo injected_error_;
 
   // Callback for creation and destruction.
@@ skipping 10 matching lines @@
   injected_error_.error = DOWNLOAD_INTERRUPT_REASON_NONE;
   injected_error_.operation_instance = -1;
 }
 
 DownloadFileWithErrorFactory::~DownloadFileWithErrorFactory() {}
 
 DownloadFile* DownloadFileWithErrorFactory::CreateFile(
     std::unique_ptr<DownloadSaveInfo> save_info,
     const base::FilePath& default_download_directory,
     std::unique_ptr<ByteStreamReader> byte_stream,
-    const std::vector<DownloadItem::ReceivedSlice>& received_slices,
     const net::NetLogWithSource& net_log,
     base::WeakPtr<DownloadDestinationObserver> observer) {
   return new DownloadFileWithError(std::move(save_info),
                                    default_download_directory,
                                    std::move(byte_stream),
-                                   received_slices,
                                    net_log,
                                    observer,
                                    injected_error_,
                                    construction_callback_,
                                    destruction_callback_);
 }
 
 bool DownloadFileWithErrorFactory::SetError(
     TestFileErrorInjector::FileErrorInfo error) {
   injected_error_ = std::move(error);
@@ skipping 99 matching lines @@
     case FILE_OPERATION_RENAME_ANNOTATE:
       return "RENAME_ANNOTATE";
     default:
       break;
   }
 
   return "Unknown";
 }
 
 }  // namespace content