Update the received slices vector when stream is written to disk

content/browser/download/download_file_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 #include <vector>
 
@@ skipping 377 matching lines @@
         base::Bind(&DownloadFileTest::SetRenameResult,
                    base::Unretained(this),
                    loop_runner.QuitClosure(),
                    &result_reason,
                    result_path_p);
     InvokeRenameMethod(method, full_path, completion_callback);
     loop_runner.Run();
     return result_reason;
   }
 
-  // Prepare two byte streams to write to the same file sink.
-  void PrepareMultipleStreams(int64_t second_stream_length) {
+  // Prepare two byte streams to write to the same file sink. If
+  // |first_stream_completes_early| is true, the first stream will complete
+  // before the second stream starts.
+  void PrepareMultipleStreams(bool first_stream_completes_early,
+                              int64_t second_stream_length) {
     // Create a sparse file.
     ASSERT_TRUE(CreateDownloadFile(0, true, true));
     base::FilePath initial_path(download_file_->FullPath());
     EXPECT_TRUE(base::PathExists(initial_path));
     DCHECK(download_file_);
 
     const char* stream_0_data[] = {kTestData1, kTestData2};
     const char* stream_1_data[] = {kTestData4, kTestData5};
     size_t stream_1_offset = strlen(kTestData1) + strlen(kTestData2);
 
     // Register second SourceStream entry for the second stream.
     // The first stream should be registered in ctor of DownloadFile.
     DownloadFileImpl::SourceStreams& source_streams =
         download_file_->source_streams_;
     EXPECT_EQ(static_cast<size_t>(1), source_streams.size());
     source_streams[stream_1_offset] =
         base::MakeUnique<DownloadFileImpl::SourceStream>(stream_1_offset,
                                                          second_stream_length);
 
     // Create the second byte stream. Will be moved to DownloadFile.
     input_stream_1_ = new MockByteStreamReader();
 
     ::testing::Sequence s0;
     ::testing::Sequence s1;
     SetupDataAppend(stream_1_data, 2, input_stream_1_, s1, stream_1_offset);
     SetupDataAppend(stream_0_data, 2, input_stream_, s0, 0);
-    SetupFinishStream(DOWNLOAD_INTERRUPT_REASON_NONE, input_stream_, s0);
+    // If the first stream doesn't finish before the second stream starts
+    // writing, its length will be cut short by the second stream. So
+    // STREAM_COMPLETE will never get called.
+    if (first_stream_completes_early)
+      SetupFinishStream(DOWNLOAD_INTERRUPT_REASON_NONE, input_stream_, s0);
+    else
+      EXPECT_CALL(*input_stream_, RegisterCallback(_)).RetiresOnSaturation();
 
     // Expectation on MockByteStreamReader for MultipleStreams tests:
     // 1. RegisterCallback: Must called twice. One to set the callback, the
     // other to release the stream.
     // 2. Read: If filled with N buffer, called (N+1) times, where the last Read
-    // call doesn't read any data but returns STRAM_COMPLETE.
+    // call doesn't read any data but returns STREAM_COMPLETE.
     // The stream may terminate in the middle and less Read calls are expected.
     // 3. GetStatus: Only called if the stream is completed and last Read call
     // returns STREAM_COMPLETE.
     if (second_stream_length == 0)
       SetupFinishStream(DOWNLOAD_INTERRUPT_REASON_NONE, input_stream_1_, s1);
     else
       EXPECT_CALL(*input_stream_1_, RegisterCallback(_)).RetiresOnSaturation();
 
     EXPECT_CALL(*input_stream_1_, RegisterCallback(_)).RetiresOnSaturation();
   }
@@ skipping 453 matching lines @@
   sink_callback_.Run();
   base::RunLoop().RunUntilIdle();
   VerifyStreamAndSize();
   DestroyDownloadFile(0);
 }
 
 // Tests for concurrent streams handling, used for parallel download.
 //
 // Activate both streams at the same time.
 TEST_F(DownloadFileTest, MutipleStreamsWrite) {
-  PrepareMultipleStreams(0);
+  PrepareMultipleStreams(false, 0);
   EXPECT_CALL(*(observer_.get()), MockDestinationCompleted(_, _));
 
   int64_t stream_0_length =
       static_cast<int64_t>(strlen(kTestData1) + strlen(kTestData2));
   int64_t stream_1_length =
       static_cast<int64_t>(strlen(kTestData4) + strlen(kTestData5));
 
   download_file_->AddByteStream(
       std::unique_ptr<MockByteStreamReader>(input_stream_1_), stream_0_length);
   sink_callback_.Run();
   base::RunLoop().RunUntilIdle();
 
   SourceStreamTestData stream_data_0(0, stream_0_length, true);
   SourceStreamTestData stream_data_1(stream_0_length, stream_1_length, true);
   VerifySourceStreamsStates(stream_data_0);
   VerifySourceStreamsStates(stream_data_1);
   EXPECT_EQ(stream_0_length + stream_1_length, TotalBytesReceived());
 
   DestroyDownloadFile(0);
 }
 
 // Activate and deplete one stream, later add the second stream.
 TEST_F(DownloadFileTest, MutipleStreamsOneStreamFirst) {
-  PrepareMultipleStreams(0);
+  PrepareMultipleStreams(true, 0);
 
   int64_t stream_0_length =
       static_cast<int64_t>(strlen(kTestData1) + strlen(kTestData2));
   int64_t stream_1_length =
       static_cast<int64_t>(strlen(kTestData4) + strlen(kTestData5));
 
   // Deplete the first stream.
   sink_callback_.Run();
   base::RunLoop().RunUntilIdle();
 
@@ skipping 22 matching lines @@
 
 // Two streams write to one sink, the second stream has a limited length.
 TEST_F(DownloadFileTest, MutipleStreamsLimitedLength) {
   // The second stream has two buffers, kTestData4 and kTestData5.
   // The length limit is set to less than the length of kTestData4.
   // kTestData4 should be partially written to disk, where kTestData5 should be
   // ignored.
   int64_t stream_0_length =
       static_cast<int64_t>(strlen(kTestData1) + strlen(kTestData2));
   int64_t stream_1_length = static_cast<int64_t>(strlen(kTestData4)) - 1;
-  PrepareMultipleStreams(stream_1_length);
+  PrepareMultipleStreams(false, stream_1_length);
 
   EXPECT_CALL(*(observer_.get()), MockDestinationCompleted(_, _));
 
   download_file_->AddByteStream(
       std::unique_ptr<MockByteStreamReader>(input_stream_1_), stream_0_length);
   sink_callback_.Run();
   base::RunLoop().RunUntilIdle();
 
   SourceStreamTestData stream_data_0(0, stream_0_length, true);
   SourceStreamTestData stream_data_1(stream_0_length, stream_1_length, true);
@@ skipping 10 matching lines @@
   // Finish the second stream.
   // TODO(xingliu): Refactor test code to deal with unfinished streams.
   scoped_refptr<net::IOBuffer> data = new net::IOBuffer(strlen(kTestData5));
   size_t size;
   input_stream_1_->Read(&data, &size);
 
   DestroyDownloadFile(0, false);
 }
 
 }  // namespace content