Shift "commit point" for when a download will no longer accept cancels.

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 <vector>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 47 matching lines @@
   virtual void Rename(const FilePath& full_path,
                       bool overwrite_existing_file,
                       const RenameCompletionCallback& callback) OVERRIDE;
 
  private:
   // Error generating helper.
   content::DownloadInterruptReason ShouldReturnError(
       content::TestFileErrorInjector::FileOperationCode code,
       content::DownloadInterruptReason original_error);
 
-  // Used in place of original rename callback to intercept with
-  // ShouldReturnError.
-  void RenameErrorCallback(
-    const RenameCompletionCallback& original_callback,
-    content::DownloadInterruptReason original_error,
-    const FilePath& path_result);
+  // Determine whether to overwrite an operation with the given code
+  // with a substitute error; if returns true, |*original_error| is
+  // written with the error to use for overwriting.
+  // NOTE: This routine changes state; specifically, it increases the
+  // operations counts for the specified code.  It should only be called
+  // once per operation.
+  bool OverwriteError(
+    content::TestFileErrorInjector::FileOperationCode code,
+    content::DownloadInterruptReason* output_error);
 
   // Source URL for the file being downloaded.
   GURL source_url_;
 
   // Our injected error.  Only one per file.
   content::TestFileErrorInjector::FileErrorInfo error_info_;
 
   // Count per operation.  0-based.
   std::map<content::TestFileErrorInjector::FileOperationCode, int>
       operation_counter_;
 
   // Callback for destruction.
   DestructionCallback destruction_callback_;
 };
 
+static void RenameErrorCallback(
+    const content::DownloadFile::RenameCompletionCallback original_callback,
+    content::DownloadInterruptReason overwrite_error,
+    content::DownloadInterruptReason original_error,
+    const FilePath& path_result) {
+  original_callback.Run(
+      overwrite_error,
+      overwrite_error == content::DOWNLOAD_INTERRUPT_REASON_NONE ?
+      path_result : FilePath());
+}
+
+
 DownloadFileWithErrors::DownloadFileWithErrors(
     const DownloadCreateInfo* info,
     scoped_ptr<content::ByteStreamReader> stream,
     DownloadRequestHandleInterface* request_handle,
     content::DownloadManager* download_manager,
     bool calculate_hash,
     const net::BoundNetLog& bound_net_log,
     const content::TestFileErrorInjector::FileErrorInfo& error_info,
     const ConstructionCallback& ctor_callback,
     const DestructionCallback& dtor_callback)
         : DownloadFileImpl(info,
                            stream.Pass(),
                            request_handle,
                            download_manager,
                            calculate_hash,
                            scoped_ptr<content::PowerSaveBlocker>(NULL).Pass(),
                            bound_net_log),
           source_url_(info->url()),
           error_info_(error_info),
           destruction_callback_(dtor_callback) {
   ctor_callback.Run(source_url_, info->download_id);
 }
 
 DownloadFileWithErrors::~DownloadFileWithErrors() {
   destruction_callback_.Run(source_url_);
 }
 
 content::DownloadInterruptReason DownloadFileWithErrors::Initialize() {
   return ShouldReturnError(
-          content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
-          DownloadFileImpl::Initialize());
+      content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
+      DownloadFileImpl::Initialize());
 }
 
 content::DownloadInterruptReason DownloadFileWithErrors::AppendDataToFile(
     const char* data, size_t data_len) {
   return ShouldReturnError(
       content::TestFileErrorInjector::FILE_OPERATION_WRITE,
       DownloadFileImpl::AppendDataToFile(data, data_len));
 }
 
 void DownloadFileWithErrors::Rename(
     const FilePath& full_path,
     bool overwrite_existing_file,
     const RenameCompletionCallback& callback) {
-  DownloadFileImpl::Rename(
-      full_path, overwrite_existing_file,
-      base::Bind(&DownloadFileWithErrors::RenameErrorCallback,
-                 // Unretained since this'll only be called from
-                 // the DownloadFileImpl slice of the same object.
-                 base::Unretained(this), callback));
+  content::DownloadInterruptReason error_to_return =
+      content::DOWNLOAD_INTERRUPT_REASON_NONE;
+  RenameCompletionCallback callback_to_use = callback;
+
+  // Replace callback if the error needs to be overwritten.
+  if (OverwriteError(
+          content::TestFileErrorInjector::FILE_OPERATION_RENAME,
+          &error_to_return)) {
+    callback_to_use = base::Bind(&RenameErrorCallback, callback,
+                                 error_to_return);
+  }
+
+  DownloadFileImpl::Rename(full_path, overwrite_existing_file, callback_to_use);
+}
+
+bool DownloadFileWithErrors::OverwriteError(
+    content::TestFileErrorInjector::FileOperationCode code,
+    content::DownloadInterruptReason* output_error) {
+  int counter = operation_counter_[code]++;
+
+  if (code != error_info_.code)
+    return false;
+
+  if (counter != error_info_.operation_instance)
+    return false;
+
+  *output_error = error_info_.error;
+  return true;
 }
 
 content::DownloadInterruptReason DownloadFileWithErrors::ShouldReturnError(
     content::TestFileErrorInjector::FileOperationCode code,
     content::DownloadInterruptReason original_error) {
-  int counter = operation_counter_[code];
-  ++operation_counter_[code];
-
-  if (code != error_info_.code)
-    return original_error;
-
-  if (counter != error_info_.operation_instance)
-    return original_error;
-
-  VLOG(1) << " " << __FUNCTION__ << "()"
-          << " url = '" << source_url_.spec() << "'"
-          << " code = " << content::TestFileErrorInjector::DebugString(code)
-          << " (" << code << ")"
-          << " counter = " << counter
-          << " original_error = "
-          << content::InterruptReasonDebugString(original_error)
-          << " (" << original_error << ")"
-          << " new error = "
-          << content::InterruptReasonDebugString(error_info_.error)
-          << " (" << error_info_.error << ")";
-
-  return error_info_.error;
-}
-
-void DownloadFileWithErrors::RenameErrorCallback(
-    const RenameCompletionCallback& original_callback,
-    content::DownloadInterruptReason original_error,
-    const FilePath& path_result) {
-  original_callback.Run(ShouldReturnError(
-      content::TestFileErrorInjector::FILE_OPERATION_RENAME,
-      original_error), path_result);
+  content::DownloadInterruptReason output_error = original_error;
+  OverwriteError(code, &output_error);
+  return output_error;
 }
 
 }  // namespace
 
 namespace content {
 
 // A factory for constructing DownloadFiles that inject errors.
-class DownloadFileWithErrorsFactory
-    : public DownloadFileManager::DownloadFileFactory {
+class DownloadFileWithErrorsFactory : public content::DownloadFileFactory {
  public:
 
   DownloadFileWithErrorsFactory(
       const DownloadFileWithErrors::ConstructionCallback& ctor_callback,
       const DownloadFileWithErrors::DestructionCallback& dtor_callback);
   virtual ~DownloadFileWithErrorsFactory();
 
   // DownloadFileFactory interface.
   virtual DownloadFile* CreateFile(
       DownloadCreateInfo* info,
@@ skipping 97 matching lines @@
 }
 
 void TestFileErrorInjector::AddFactory(
     scoped_ptr<DownloadFileWithErrorsFactory> factory) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
 
   DownloadFileManager* download_file_manager = GetDownloadFileManager();
   DCHECK(download_file_manager);
 
   // Convert to base class pointer, for GCC.
-  scoped_ptr<DownloadFileManager::DownloadFileFactory> plain_factory(
+  scoped_ptr<content::DownloadFileFactory> plain_factory(
       factory.release());
 
   download_file_manager->SetFileFactoryForTesting(plain_factory.Pass());
 }
 
 bool TestFileErrorInjector::AddError(const FileErrorInfo& error_info) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK_LE(0, error_info.operation_instance);
   DCHECK(injected_errors_.find(error_info.url) == injected_errors_.end());
 
@@ skipping 25 matching lines @@
 }
 
 void TestFileErrorInjector::InjectErrorsOnFileThread(
     ErrorMap map, DownloadFileWithErrorsFactory* factory) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
 
   // Validate that our factory is in use.
   DownloadFileManager* download_file_manager = GetDownloadFileManager();
   DCHECK(download_file_manager);
 
-  DownloadFileManager::DownloadFileFactory* file_factory =
+  content::DownloadFileFactory* file_factory =
       download_file_manager->GetFileFactoryForTesting();
 
   // Validate that we still have the same factory.
-  DCHECK_EQ(static_cast<DownloadFileManager::DownloadFileFactory*>(factory),
+  DCHECK_EQ(static_cast<content::DownloadFileFactory*>(factory),
             file_factory);
 
   // We want to replace all existing injection errors.
   factory->ClearErrors();
 
   for (ErrorMap::const_iterator it = map.begin(); it != map.end(); ++it)
     factory->AddError(it->second);
 }
 
 size_t TestFileErrorInjector::CurrentFileCount() const {
@@ skipping 86 matching lines @@
     case FILE_OPERATION_RENAME:
       return "RENAME";
     default:
       break;
   }
 
   return "Unknown";
 }
 
 }  // namespace content