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

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"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "content/browser/download/download_file_factory.h"
 #include "content/browser/download/download_file_impl.h"
 #include "content/browser/download/download_interrupt_reasons_impl.h"
 #include "content/browser/download/download_manager_impl.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "url/gurl.h"
 
 namespace content {
 class ByteStreamReader;
 
 namespace {
 
 // A class that performs file operations and injects errors.
 class DownloadFileWithError: public DownloadFileImpl {
  public:
-  DownloadFileWithError(const DownloadSaveInfo& save_info,
-                         const base::FilePath& default_download_directory,
-                         const GURL& url,
-                         const GURL& referrer_url,
-                         bool calculate_hash,
-                         base::File file,
-                         scoped_ptr<ByteStreamReader> byte_stream,
-                         const net::BoundNetLog& bound_net_log,
-                         base::WeakPtr<DownloadDestinationObserver> observer,
-                         const TestFileErrorInjector::FileErrorInfo& error_info,
-                         const base::Closure& ctor_callback,
-                         const base::Closure& dtor_callback);
+  DownloadFileWithError(scoped_ptr<DownloadSaveInfo> save_info,
+                        const base::FilePath& default_download_directory,
+                        scoped_ptr<ByteStreamReader> byte_stream,
+                        const net::BoundNetLog& bound_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;
 
   // DownloadFile interface.
   DownloadInterruptReason AppendDataToFile(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,
+                         const GURL& source_url,
+                         const GURL& referrer_url,
                          const RenameCompletionCallback& callback) override;
 
  private:
   // Error generating helper.
   DownloadInterruptReason ShouldReturnError(
       TestFileErrorInjector::FileOperationCode code,
       DownloadInterruptReason original_error);
 
   // Determine whether to overwrite an operation with the given code
   // with a substitute error; if returns true, |*original_error| is
@@ skipping 27 matching lines @@
     DownloadInterruptReason overwrite_error,
     DownloadInterruptReason original_error,
     const base::FilePath& path_result) {
   original_callback.Run(
       overwrite_error,
       overwrite_error == DOWNLOAD_INTERRUPT_REASON_NONE ?
       path_result : base::FilePath());
 }
 
 DownloadFileWithError::DownloadFileWithError(
-    const DownloadSaveInfo& save_info,
+    scoped_ptr<DownloadSaveInfo> save_info,
     const base::FilePath& default_download_directory,
-    const GURL& url,
-    const GURL& referrer_url,
-    bool calculate_hash,
-    base::File file,
     scoped_ptr<ByteStreamReader> byte_stream,
     const net::BoundNetLog& bound_net_log,
     base::WeakPtr<DownloadDestinationObserver> observer,
     const TestFileErrorInjector::FileErrorInfo& error_info,
     const base::Closure& ctor_callback,
     const base::Closure& dtor_callback)
-    : DownloadFileImpl(save_info,
+    : DownloadFileImpl(std::move(save_info),
                        default_download_directory,
-                       url,
-                       referrer_url,
-                       calculate_hash,
-                       std::move(file),
                        std::move(byte_stream),
                        bound_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
@@ skipping 61 matching lines @@
     // Otherwise, just wrap the return.
     callback_to_use = base::Bind(&RenameErrorCallback, callback,
                                  error_to_return);
   }
 
   DownloadFileImpl::RenameAndUniquify(full_path, callback_to_use);
 }
 
 void DownloadFileWithError::RenameAndAnnotate(
     const base::FilePath& full_path,
+    const std::string& client_guid,
+    const GURL& source_url,
+    const GURL& referrer_url,
     const RenameCompletionCallback& callback) {
   DownloadInterruptReason error_to_return = DOWNLOAD_INTERRUPT_REASON_NONE;
   RenameCompletionCallback callback_to_use = callback;
 
   // Replace callback if the error needs to be overwritten.
   if (OverwriteError(
           TestFileErrorInjector::FILE_OPERATION_RENAME_ANNOTATE,
           &error_to_return)) {
     if (DOWNLOAD_INTERRUPT_REASON_NONE != error_to_return) {
       // Don't execute a, probably successful, RenameAndAnnotate; just
       // return the error.
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE, base::Bind(
               callback, error_to_return, base::FilePath()));
       return;
     }
 
     // Otherwise, just wrap the return.
     callback_to_use = base::Bind(&RenameErrorCallback, callback,
                                  error_to_return);
   }
 
-  DownloadFileImpl::RenameAndAnnotate(full_path, callback_to_use);
+  DownloadFileImpl::RenameAndAnnotate(
+      full_path, client_guid, source_url, referrer_url, callback_to_use);
 }
 
 bool DownloadFileWithError::OverwriteError(
     TestFileErrorInjector::FileOperationCode code,
     DownloadInterruptReason* output_error) {
   int counter = operation_counter_[code]++;
 
   if (code != error_info_.code)
     return false;
 
@@ skipping 16 matching lines @@
 
 // A factory for constructing DownloadFiles that inject errors.
 class DownloadFileWithErrorFactory : public DownloadFileFactory {
  public:
   DownloadFileWithErrorFactory(const base::Closure& ctor_callback,
                                 const base::Closure& dtor_callback);
   ~DownloadFileWithErrorFactory() override;
 
   // DownloadFileFactory interface.
   DownloadFile* CreateFile(
-      const DownloadSaveInfo& save_info,
+      scoped_ptr<DownloadSaveInfo> save_info,
       const base::FilePath& default_download_directory,
-      const GURL& url,
-      const GURL& referrer_url,
-      bool calculate_hash,
-      base::File file,
       scoped_ptr<ByteStreamReader> byte_stream,
       const net::BoundNetLog& bound_net_log,
       base::WeakPtr<DownloadDestinationObserver> observer) override;
 
-  void ClearError();
   bool SetError(TestFileErrorInjector::FileErrorInfo error);
 
  private:
   // Our injected error.
   TestFileErrorInjector::FileErrorInfo injected_error_;
 
   // Callback for creation and destruction.
   base::Closure construction_callback_;
   base::Closure destruction_callback_;
 };
 
 DownloadFileWithErrorFactory::DownloadFileWithErrorFactory(
     const base::Closure& ctor_callback,
     const base::Closure& dtor_callback)
     : construction_callback_(ctor_callback),
       destruction_callback_(dtor_callback) {
   injected_error_.code = TestFileErrorInjector::FILE_OPERATION_INITIALIZE;
   injected_error_.error = DOWNLOAD_INTERRUPT_REASON_NONE;
   injected_error_.operation_instance = -1;
 }
 
 DownloadFileWithErrorFactory::~DownloadFileWithErrorFactory() {}
 
 DownloadFile* DownloadFileWithErrorFactory::CreateFile(
-    const DownloadSaveInfo& save_info,
+    scoped_ptr<DownloadSaveInfo> save_info,
     const base::FilePath& default_download_directory,
-    const GURL& url,
-    const GURL& referrer_url,
-    bool calculate_hash,
-    base::File file,
     scoped_ptr<ByteStreamReader> byte_stream,
     const net::BoundNetLog& bound_net_log,
     base::WeakPtr<DownloadDestinationObserver> observer) {
-  return new DownloadFileWithError(
-      save_info, default_download_directory, url, referrer_url, calculate_hash,
-      std::move(file), std::move(byte_stream), bound_net_log, observer,
-      injected_error_, construction_callback_, destruction_callback_);
+  return new DownloadFileWithError(std::move(save_info),
+                                   default_download_directory,
+                                   std::move(byte_stream),
+                                   bound_net_log,
+                                   observer,
+                                   injected_error_,
+                                   construction_callback_,
+                                   destruction_callback_);
 }
 
 bool DownloadFileWithErrorFactory::SetError(
     TestFileErrorInjector::FileErrorInfo error) {
   injected_error_ = std::move(error);
   return true;
 }
 
 TestFileErrorInjector::TestFileErrorInjector(DownloadManager* download_manager)
     :  // This code is only used for browser_tests, so a
       // DownloadManager is always a DownloadManagerImpl.
       download_manager_(static_cast<DownloadManagerImpl*>(download_manager)) {
   // Record the value of the pointer, for later validation.
-  created_factory_ =
-      new DownloadFileWithErrorFactory(
-          base::Bind(&TestFileErrorInjector::RecordDownloadFileConstruction,
-                     this),
-          base::Bind(&TestFileErrorInjector::RecordDownloadFileDestruction,
-                     this));
+  created_factory_ = new DownloadFileWithErrorFactory(
+      base::Bind(&TestFileErrorInjector::RecordDownloadFileConstruction, this),
+      base::Bind(&TestFileErrorInjector::RecordDownloadFileDestruction, this));
 
   // We will transfer ownership of the factory to the download manager.
   scoped_ptr<DownloadFileFactory> download_file_factory(
       created_factory_);
 
   download_manager_->SetDownloadFileFactoryForTesting(
       std::move(download_file_factory));
 }
 
 TestFileErrorInjector::~TestFileErrorInjector() {
@@ skipping 79 matching lines @@
     case FILE_OPERATION_RENAME_ANNOTATE:
       return "RENAME_ANNOTATE";
     default:
       break;
   }
 
   return "Unknown";
 }
 
 }  // namespace content