Move the logic to determine how much data can be written to another function

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 133 matching lines @@
 }
 
 DownloadInterruptReason DownloadFileImpl::WriteDataToFile(int64_t offset,
                                                           const char* data,
                                                           size_t data_len) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   WillWriteToDisk(data_len);
   return file_.WriteDataToFile(offset, data, data_len);
 }
 
+bool DownloadFileImpl::CalculateBytesToWrite(
+    SourceStream* source_stream,
+    size_t bytes_read,
+    size_t *bytes_to_write) {
+  // If a new slice find that its target position has already been written,
+  // terminate the stream.
+  if (source_stream->bytes_written() == 0) {
+    for (const auto& received_slice : received_slices_) {
+      if (received_slice.offset <= source_stream->offset() &&
+          received_slice.offset + received_slice.received_bytes >
+              source_stream->offset()) {
+        *bytes_to_write = 0;
+        return true;
+      }
+    }
+  }
+
+  if (source_stream->length() != DownloadSaveInfo::kLengthFullContent &&

[xingliu, 2017/03/11 00:11:46]

nit%: Maybe add a comment for this block.
Write a partial buffer if the source stream exceeds length limit.

[qinmin, 2017/03/14 23:24:50]

Done.

+      source_stream->bytes_written() +
+              static_cast<int64_t>(bytes_read) >= source_stream->length()) {
+    *bytes_to_write = source_stream->length() - source_stream->bytes_written();
+    return true;
+  }
+
+  *bytes_to_write = bytes_read;
+  return false;
+}
+
 void DownloadFileImpl::RenameAndUniquify(
     const base::FilePath& full_path,
     const RenameCompletionCallback& callback) {
   std::unique_ptr<RenameParameters> parameters(
       new RenameParameters(UNIQUIFY, full_path, callback));
   RenameWithRetryInternal(std::move(parameters));
 }
 
 void DownloadFileImpl::RenameAndAnnotate(
     const base::FilePath& full_path,
@@ skipping 116 matching lines @@
 }
 
 void DownloadFileImpl::StreamActive(SourceStream* source_stream) {
   DCHECK(source_stream->stream_reader());
   base::TimeTicks start(base::TimeTicks::Now());
   base::TimeTicks now;
   scoped_refptr<net::IOBuffer> incoming_data;
   size_t incoming_data_size = 0;
   size_t total_incoming_data_size = 0;
   size_t num_buffers = 0;
+  size_t bytes_to_write = 0;
   bool should_terminate = false;
   ByteStreamReader::StreamState state(ByteStreamReader::STREAM_EMPTY);
   DownloadInterruptReason reason = DOWNLOAD_INTERRUPT_REASON_NONE;
   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:
         break;
       case ByteStreamReader::STREAM_HAS_DATA:
         {
           ++num_buffers;
           base::TimeTicks write_start(base::TimeTicks::Now());
-          // Stop the stream if it writes more bytes than expected.
-          if (source_stream->length() != DownloadSaveInfo::kLengthFullContent &&
-              source_stream->bytes_written() +
-                      static_cast<int64_t>(incoming_data_size) >=
-                  source_stream->length()) {
-            should_terminate = true;
-            incoming_data_size =
-                source_stream->length() - source_stream->bytes_written();
-          }
+          should_terminate = CalculateBytesToWrite(
+              source_stream, incoming_data_size, &bytes_to_write);
+
           reason = WriteDataToFile(
               source_stream->offset() + source_stream->bytes_written(),
-              incoming_data.get()->data(), incoming_data_size);
+              incoming_data.get()->data(), bytes_to_write);
           disk_writes_time_ += (base::TimeTicks::Now() - write_start);
-          bytes_seen_ += incoming_data_size;
-          total_incoming_data_size += incoming_data_size;
+          bytes_seen_ += bytes_to_write;
+          total_incoming_data_size += bytes_to_write;
           if (reason == DOWNLOAD_INTERRUPT_REASON_NONE)
-            source_stream->OnWriteBytesToDisk(incoming_data_size);
+            source_stream->OnWriteBytesToDisk(bytes_to_write);
         }
         break;
       case ByteStreamReader::STREAM_COMPLETE:
         {
           reason = static_cast<DownloadInterruptReason>(
             source_stream->stream_reader()->GetStatus());
           SendUpdate();
         }
         break;
       default:
@@ skipping 110 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