Clear callback when a parallel request can no longer write any data

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 389 matching lines @@
   base::TimeDelta delta(
       base::TimeDelta::FromMilliseconds(kMaxTimeBlockingFileThreadMs));
 
   // Take care of any file local activity required.
   do {
     state = source_stream->stream_reader()->Read(&incoming_data,
                                                  &incoming_data_size);
 
     switch (state) {
       case ByteStreamReader::STREAM_EMPTY:
+        should_terminate = (source_stream->length() == kNoBytesToWrite);
         break;
       case ByteStreamReader::STREAM_HAS_DATA:
         {
           ++num_buffers;
           base::TimeTicks write_start(base::TimeTicks::Now());
           should_terminate = CalculateBytesToWrite(
               source_stream, incoming_data_size, &bytes_to_write);
           DCHECK_GE(incoming_data_size, bytes_to_write);
           reason = WriteDataToFile(
               source_stream->offset() + source_stream->bytes_written(),
@@ skipping 99 matching lines @@
   ByteStreamReader* stream_reader = source_stream->stream_reader();
   if (stream_reader) {
     stream_reader->RegisterCallback(base::Bind(&DownloadFileImpl::StreamActive,
                                                weak_factory_.GetWeakPtr(),
                                                source_stream));
     // Truncate |source_stream|'s length if necessary.
     for (const auto& received_slice : received_slices_) {
       source_stream->TruncateLengthWithWrittenDataBlock(
           received_slice.offset, received_slice.received_bytes);
     }
+    num_active_streams_++;
     StreamActive(source_stream);
-    num_active_streams_++;
   }
 }
 
 int64_t DownloadFileImpl::TotalBytesReceived() const {
   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_.
@@ skipping 62 matching lines @@
   return TotalBytesReceived() == potential_file_length_;
 }
 
 void DownloadFileImpl::HandleStreamError(SourceStream* source_stream,
                                          DownloadInterruptReason reason) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   source_stream->stream_reader()->RegisterCallback(base::Closure());
   source_stream->set_finished(true);
   num_active_streams_--;
 
-  bool can_recover_from_error = false;
+  bool can_recover_from_error = (source_stream->length() == kNoBytesToWrite);
 
-  if (IsSparseFile() && source_stream->length() != kNoBytesToWrite) {
+  if (IsSparseFile() && !can_recover_from_error) {
     // If a neighboring stream request is available, check if it can help
     // download all the data left by |source stream| or has already done so. We
     // want to avoid the situation that a server always fail additional requests
     // from the client thus causing the initial request and the download going
     // nowhere.
     // TODO(qinmin): make all streams half open so that they can recover
     // failures from their neighbors.
     SourceStream* preceding_neighbor = FindPrecedingNeighbor(source_stream);
     while (preceding_neighbor) {
       int64_t upper_range = source_stream->offset() + source_stream->length();
@@ skipping 89 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