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

content/browser/download/download_file_impl.h

 // 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.
 
 #ifndef CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_FILE_IMPL_H_
 #define CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_FILE_IMPL_H_
 
 #include "content/browser/download/download_file.h"
 
 #include <stddef.h>
@@ skipping 158 matching lines @@
 
   // Rename file_ based on |parameters|.
   void RenameWithRetryInternal(std::unique_ptr<RenameParameters> parameters);
 
   // Send an update on our progress.
   void SendUpdate();
 
   // Called before the data is written to disk.
   void WillWriteToDisk(size_t data_len);
 
+  // For a given SourceStream object and the bytes it has read, determine the
+  // actual number of bytes it can write to the disk. For parallel downloading,
+  // if the target location is already written by another worker, the current

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

nit%: We actually check this only before the first disk IO of the stream. Maybe
explicitly address this here.

This sgtm since we can avoid iterate the received slice vector on every buffer
read.

A half open request will stop when it hit a received slice when another CL
checked in to set the length of previous source streams, right?

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

Done.
Yes, a half open request will stop when a later source stream starts writing the
first chunk. 
There are 2 scenarios we need to handle. Suppose there are stream A, B, and C,
all of them are half open, and are ordered by the offset.
When B starts writing, it will set the length limit on A, thus causing it to
stop early. that's addressed in another CL.
Now B continues to write and it surpasses the offset of C. If C starts writing
at this moment, it should immediately stop. That's addressed in this CL.

+  // stream should stop writing, Returns true if the stream can write no more
+  // data and should be finished, returns false otherwise.
+  bool CalculateBytesToWrite(SourceStream* source_stream,
+                             size_t bytes_read,
+                             size_t* bytes_to_write);
+
   // Called when there's some activity on the byte stream that needs to be
   // handled.
   void StreamActive(SourceStream* source_stream);
 
   // Register callback and start to read data from the stream.
   void RegisterAndActivateStream(SourceStream* source_stream);
 
   // Return the total valid bytes received in the target file.
   // If the file is a sparse file, return the total number of valid bytes.
   // Otherwise, return the current file size.
@@ skipping 39 matching lines @@
 
   base::WeakPtr<DownloadDestinationObserver> observer_;
   base::WeakPtrFactory<DownloadFileImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadFileImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_FILE_IMPL_H_