Fix an issue that we didn't clean url request properly.

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 24 matching lines @@
       const base::FilePath& default_download_directory,
       std::unique_ptr<ByteStreamReader> byte_stream,
       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,
+  void Initialize(const InitializeCallback& initialize_callback,
+                  const CancelRequestCallback& cancel_request_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,
@@ skipping 70 matching lines @@
   // 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& initialize_callback,
+    const CancelRequestCallback& cancel_request_callback,
     const DownloadItem::ReceivedSlices& received_slices) {
   DownloadInterruptReason error_to_return = DOWNLOAD_INTERRUPT_REASON_NONE;
-  InitializeCallback callback_to_use = callback;
+  InitializeCallback callback_to_use = initialize_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));
+      BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                              base::Bind(initialize_callback, error_to_return));
       return;
     }
 
     // Otherwise, just wrap the return.
-    callback_to_use = base::Bind(&InitializeErrorCallback, callback,
+    callback_to_use = base::Bind(&InitializeErrorCallback, initialize_callback,
                                  error_to_return);
   }
 
-  DownloadFileImpl::Initialize(callback_to_use, received_slices);
+  DownloadFileImpl::Initialize(callback_to_use, cancel_request_callback,
+                               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 240 matching lines @@
     case FILE_OPERATION_RENAME_ANNOTATE:
       return "RENAME_ANNOTATE";
     default:
       break;
   }
 
   return "Unknown";
 }
 
 }  // namespace content