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 61 matching lines @@
 
 void DownloadFileImpl::SourceStream::TruncateLengthWithWrittenDataBlock(
     int64_t offset,
     int64_t bytes_written) {
   DCHECK_GT(bytes_written, 0);
   if (length_ == kNoBytesToWrite)
     return;
 
   if (offset <= offset_) {
     if (offset + bytes_written > offset_) {
       length_ = kNoBytesToWrite;

[qinmin, 2017/04/14 20:04:43]

the stream_to_close can be added here rather than waiting for the StreamActive
call

[xingliu, 2017/04/15 00:26:29]

We also truncate the length in next block, line 90. In this case, we also need
to cancel the request, but after that much data being written to disk.

So we only cancel the request when |should_terminate| is true in StreamActive.
When the stream is complete by itself, the writer side should close the url
request.

But I agree on the idea to let SourceStream to do a bit more things, and it
needs some clean up and refactoring. Like SourceStream::Close as a temporary
solution to "ByteStreamReader::Close".

       finished_ = true;
     }
     return;
   }
 
   if (length_ == DownloadSaveInfo::kLengthFullContent ||
       length_ > offset - offset_) {
     length_ = offset - offset_;
   }
 }
@@ skipping 228 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
+    // download 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);
+    streams_to_close_.emplace(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 44 matching lines @@
   return file_.bytes_so_far();
 }
 
 void DownloadFileImpl::SendUpdate() {
   // TODO(qinmin): For each active stream, add the slice it has written so
   // far along with received_slices_.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DownloadDestinationObserver::DestinationUpdate, observer_,
                  TotalBytesReceived(), rate_estimator_.GetCountPerSecond(),
-                 received_slices_));
+                 received_slices_, streams_to_close_));
+  streams_to_close_.clear();
 }
 
 void DownloadFileImpl::WillWriteToDisk(size_t data_len) {
   if (!update_timer_->IsRunning()) {
     update_timer_->Start(FROM_HERE,
                          base::TimeDelta::FromMilliseconds(kUpdatePeriodMs),
                          this, &DownloadFileImpl::SendUpdate);
   }
   rate_estimator_.Increment(data_len);
   base::TimeTicks now = base::TimeTicks::Now();
@@ skipping 87 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);
+          streams_to_close_.emplace(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 44 matching lines @@
     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