Update the received slices vector when stream is written to disk

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 91 matching lines @@
     ~SourceStream();
 
     void SetByteStream(std::unique_ptr<ByteStreamReader> stream_reader);
 
     // Called after successfully writing a buffer to disk.
     void OnWriteBytesToDisk(int64_t bytes_write);
 
     ByteStreamReader* stream_reader() const { return stream_reader_.get(); }
     int64_t offset() const { return offset_; }
     int64_t length() const { return length_; }
+    void set_length(int64_t length) { length_ = length; }
     int64_t bytes_written() const { return bytes_written_; }
     bool is_finished() const { return finished_; }
     void set_finished(bool finish) { finished_ = finish; }
+    size_t index() { return index_; }
+    void set_index(size_t index) { index_ = index; }
 
    private:
     // Starting position for the stream to write to disk.
     int64_t offset_;
 
     // The maximum length to write to the disk. If set to 0, keep writing until
     // the stream depletes.
     int64_t length_;
 
     // Number of bytes written to disk from the stream.
     // Next write position is (|offset_| + |bytes_written_|).
     int64_t bytes_written_;
 
     // If all the data read from the stream has been successfully written to
     // disk.
     bool finished_;
 
+    // The slice index in the |received_slices_| vector. A slice was created
+    // once the stream started writing data to the target file.
+    size_t index_;
+
     // The stream through which data comes.
     std::unique_ptr<ByteStreamReader> stream_reader_;
 
     DISALLOW_COPY_AND_ASSIGN(SourceStream);
   };
 
   typedef std::unordered_map<int64_t, std::unique_ptr<SourceStream>>
       SourceStreams;
 
   // Options for RenameWithRetryInternal.
@@ skipping 34 matching lines @@
   // Called before the data is written to disk.
   void WillWriteToDisk(size_t data_len);
 
   // 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);
 
+  // Adds a new slice to |received_slices_| and update the existing entries in
+  // |source_streams_| as their lengths will change.
+  // TODO(qinmin): add a test for this function.
+  void AddNewSlice(int64_t offset, int64_t length);
+
   // 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.
   int64_t TotalBytesReceived() const;
 
   net::NetLogWithSource net_log_;
 
   // The base file instance.
   BaseFile file_;
 
@@ skipping 32 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_