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

content/browser/download/download_file_impl.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_file_impl.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 110 matching lines @@
       net::NetLogEventType::DOWNLOAD_FILE_ACTIVE,
       download_item_net_log.source().ToEventParametersCallback());
 }
 
 DownloadFileImpl::~DownloadFileImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_ACTIVE);
 }
 
 void DownloadFileImpl::Initialize(
-    const InitializeCallback& callback,
+    const InitializeCallback& initialize_callback,
+    const CancelRequestCallback& cancel_request_callback,
     const DownloadItem::ReceivedSlices& received_slices) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   update_timer_.reset(new base::RepeatingTimer());
   int64_t bytes_so_far = 0;
+  cancel_request_callback_ = cancel_request_callback;
   received_slices_ = received_slices;
   if (IsSparseFile()) {
     for (const auto& received_slice : received_slices_) {
       bytes_so_far += received_slice.received_bytes;
     }
   } else {
     bytes_so_far = save_info_->offset;
   }
   DownloadInterruptReason result = file_.Initialize(
       save_info_->file_path, default_download_directory_,
       std::move(save_info_->file), bytes_so_far,
       save_info_->hash_of_partial_file, std::move(save_info_->hash_state),
       IsSparseFile());
   if (result != DOWNLOAD_INTERRUPT_REASON_NONE) {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE, base::Bind(callback, result));
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(initialize_callback, result));
     return;
   }
 
   download_start_ = base::TimeTicks::Now();
   last_update_time_ = download_start_;
 
   // Primarily to make reset to zero in restart visible to owner.
   SendUpdate();
 
   BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE, base::Bind(
-          callback, DOWNLOAD_INTERRUPT_REASON_NONE));
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(initialize_callback, DOWNLOAD_INTERRUPT_REASON_NONE));
 
   // Initial pull from the straw from all source streams.
   for (auto& source_stream : source_streams_)
     RegisterAndActivateStream(source_stream.second.get());
 }
 
 void DownloadFileImpl::AddByteStream(
     std::unique_ptr<ByteStreamReader> stream_reader,
     int64_t offset,
     int64_t length) {
@@ skipping 146 matching lines @@
                                                  parameters->source_url,
                                                  parameters->referrer_url);
   }
 
   if (reason != DOWNLOAD_INTERRUPT_REASON_NONE) {
     // Make sure our information is updated, since we're about to
     // error out.
     SendUpdate();
 
     // Null out callback so that we don't do any more stream processing.
+    // The request that writes to the pipe should be canceled after
+    // the download being interrupted.
     for (auto& stream : source_streams_) {
       ByteStreamReader* stream_reader = stream.second->stream_reader();
       if (stream_reader)
         stream_reader->RegisterCallback(base::Closure());
     }
 
     new_path.clear();
   }
 
   BrowserThread::PostTask(
@@ skipping 121 matching lines @@
 
   RecordContiguousWriteTime(now - start);
 
   // Take care of communication with our observer.
   if (reason != DOWNLOAD_INTERRUPT_REASON_NONE) {
     HandleStreamError(source_stream, reason);
   } else if (state == ByteStreamReader::STREAM_COMPLETE || should_terminate) {
     // Signal successful completion or termination of the current stream.
     source_stream->stream_reader()->RegisterCallback(base::Closure());
     source_stream->set_finished(true);
+    if (should_terminate)
+      CancelRequestOnUIThread(source_stream->offset());
     if (source_stream->length() == DownloadSaveInfo::kLengthFullContent) {
       SetPotentialFileLength(source_stream->offset() +
                              source_stream->bytes_written());
     }
     num_active_streams_--;
 
     // Inform observers.
     SendUpdate();
 
     // All the stream reader are completed, shut down file IO processing.
@@ skipping 152 matching lines @@
     if (can_recover_from_error) {
       // Since the neighbor stream will download all data downloading from its
       // offset to source_stream->offset(). Close all other streams in the
       // middle.
       for (auto& stream : source_streams_) {
         if (stream.second->offset() < source_stream->offset() &&
             stream.second->offset() > preceding_neighbor->offset()) {
           DCHECK_EQ(stream.second->bytes_written(), 0);
           stream.second->stream_reader()->RegisterCallback(base::Closure());
           stream.second->set_finished(true);
+          CancelRequestOnUIThread(stream.second->offset());
           num_active_streams_--;
         }
       }
     }
   }
 
   SendUpdate();  // Make info up to date before error.
 
   if (!can_recover_from_error) {
     // Error case for both upstream source and file write.
@@ skipping 19 matching lines @@
   for (auto& stream : source_streams_) {
     int64_t offset = stream.second->offset();
     if (offset < source_stream->offset() && offset >= max_preceding_offset) {
       ret = stream.second.get();
       max_preceding_offset = offset;
     }
   }
   return ret;
 }
 
+void DownloadFileImpl::CancelRequestOnUIThread(int64_t offset) {
+  if (!cancel_request_callback_.is_null()) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(cancel_request_callback_, offset));
+  }
+}
+
 void DownloadFileImpl::DebugStates() const {
   DVLOG(1) << "### Debugging DownloadFile states:";
   DVLOG(1) << "Total source stream count = " << source_streams_.size();
   for (const auto& stream : source_streams_) {
     DVLOG(1) << "Source stream, offset = " << stream.second->offset()
              << " , bytes_written = " << stream.second->bytes_written()
              << " , is_finished = " << stream.second->is_finished()
              << " , length = " << stream.second->length();
   }
 
   DebugSlicesInfo(received_slices_);
 }
 
 DownloadFileImpl::RenameParameters::RenameParameters(
     RenameOption option,
     const base::FilePath& new_path,
     const RenameCompletionCallback& completion_callback)
     : option(option),
       new_path(new_path),
       retries_left(kMaxRenameRetries),
       completion_callback(completion_callback) {}
 
 DownloadFileImpl::RenameParameters::~RenameParameters() {}
 
 }  // namespace content