Don't create parallel request until download file is initialized

content/browser/download/parallel_download_job_unittest.cc

 // Copyright 2017 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/parallel_download_job.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
+#include "base/run_loop.h"
+#include "content/browser/download/download_destination_observer.h"
+#include "content/browser/download/download_file_impl.h"
 #include "content/browser/download/download_item_impl_delegate.h"
 #include "content/browser/download/mock_download_item_impl.h"
 #include "content/browser/download/parallel_download_utils.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using ::testing::_;
 using ::testing::NiceMock;
+using ::testing::StrictMock;
 
 namespace content {
 
 namespace {
 
 class MockDownloadRequestHandle : public DownloadRequestHandleInterface {
  public:
   MOCK_CONST_METHOD0(GetWebContents, WebContents*());
   MOCK_CONST_METHOD0(GetDownloadManager, DownloadManager*());
   MOCK_CONST_METHOD0(PauseRequest, void());
   MOCK_CONST_METHOD0(ResumeRequest, void());
   MOCK_CONST_METHOD0(CancelRequest, void());
   MOCK_CONST_METHOD0(DebugString, std::string());
 };
 
+class MockDownloadDestinationObserver : public DownloadDestinationObserver {
+ public:
+  MOCK_METHOD3(DestinationUpdate,
+               void(int64_t,
+                    int64_t,
+                    const std::vector<DownloadItem::ReceivedSlice>&));
+  void DestinationError(
+      DownloadInterruptReason reason,
+      int64_t bytes_so_far,
+      std::unique_ptr<crypto::SecureHash> hash_state) override {}
+  void DestinationCompleted(
+      int64_t total_bytes,
+      std::unique_ptr<crypto::SecureHash> hash_state) override {}
+  MOCK_METHOD2(CurrentUpdateStatus, void(int64_t, int64_t));
+};
+
+class MockByteStreamReader : public ByteStreamReader {
+ public:
+  MOCK_METHOD2(Read,
+               ByteStreamReader::StreamState(scoped_refptr<net::IOBuffer>*,
+                                             size_t*));
+  MOCK_CONST_METHOD0(GetStatus, int());
+  MOCK_METHOD1(RegisterCallback, void(const base::Closure&));
+};
+
 }  // namespace
 
 class ParallelDownloadJobForTest : public ParallelDownloadJob {
  public:
   ParallelDownloadJobForTest(
       DownloadItemImpl* download_item,
       std::unique_ptr<DownloadRequestHandleInterface> request_handle,
       const DownloadCreateInfo& create_info,
       int request_count,
       int64_t min_slice_size,
@@ skipping 55 matching lines @@
 
     DownloadCreateInfo info;
     info.offset = initial_request_offset;
     info.total_bytes = content_length;
     std::unique_ptr<MockDownloadRequestHandle> request_handle =
         base::MakeUnique<MockDownloadRequestHandle>();
     mock_request_handle_ = request_handle.get();
     job_ = base::MakeUnique<ParallelDownloadJobForTest>(
         download_item_.get(), std::move(request_handle), info, request_count,
         min_slice_size, min_remaining_time);
+    file_initialized_ = false;
   }
 
   void DestroyParallelJob() {
     job_.reset();
     download_item_.reset();
     item_delegate_.reset();
     mock_request_handle_ = nullptr;
   }
 
   void BuildParallelRequests() { job_->BuildParallelRequests(); }
@@ skipping 12 matching lines @@
         std::move(create_info), std::unique_ptr<ByteStreamReader>(),
         DownloadUrlParameters::OnStartedCallback());
   }
 
   void VerifyWorker(int64_t offset, int64_t length) const {
     EXPECT_TRUE(job_->workers_.find(offset) != job_->workers_.end());
     EXPECT_EQ(offset, job_->workers_[offset]->offset());
     EXPECT_EQ(length, job_->workers_[offset]->length());
   }
 
+  void OnFileInitialized(DownloadInterruptReason result) {
+    file_initialized_ = true;
+  }
+
   content::TestBrowserThreadBundle browser_threads_;
   std::unique_ptr<DownloadItemImplDelegate> item_delegate_;
   std::unique_ptr<MockDownloadItemImpl> download_item_;
   std::unique_ptr<ParallelDownloadJobForTest> job_;
+  bool file_initialized_;
   // Request handle for the original request.
   MockDownloadRequestHandle* mock_request_handle_;
 };
 
 // Test if parallel requests can be built correctly for a new download without
 // existing slices.
 TEST_F(ParallelDownloadJobTest, CreateNewDownloadRequestsWithoutSlices) {
   // Totally 2 requests for 100 bytes.
   // Original request:  Range:0-49, for 50 bytes.
   // Task 1:  Range:50-, for 50 bytes.
@@ skipping 158 matching lines @@
 // finish downloading soon.
 TEST_F(ParallelDownloadJobTest, RemainingContentWillFinishSoon) {
   DownloadItem::ReceivedSlices slices = {DownloadItem::ReceivedSlice(0, 99)};
   CreateParallelJob(99, 1, slices, 3, 1, 10);
   BuildParallelRequests();
   EXPECT_EQ(0, static_cast<int>(job_->workers().size()));
 
   DestroyParallelJob();
 }
 
+// Test that parallel request is not created until download file is initialized.
+TEST_F(ParallelDownloadJobTest, ParallelRequestNotCreatedUntilFileInitialized) {
+  auto save_info = base::MakeUnique<DownloadSaveInfo>();
+  StrictMock<MockByteStreamReader>* input_stream =
+      new StrictMock<MockByteStreamReader>();
+  auto observer =
+      base::MakeUnique<StrictMock<MockDownloadDestinationObserver>>();
+  base::WeakPtrFactory<DownloadDestinationObserver> observer_factory(
+      observer.get());
+  auto download_file = base::MakeUnique<DownloadFileImpl>(
+      std::move(save_info), base::FilePath(),
+      std::unique_ptr<ByteStreamReader>(input_stream), net::NetLogWithSource(),
+      observer_factory.GetWeakPtr());
+  CreateParallelJob(0, 100, DownloadItem::ReceivedSlices(), 2, 0, 0);
+  job_->Start(download_file.get(),
+              base::Bind(&ParallelDownloadJobTest::OnFileInitialized,
+                         base::Unretained(this)),
+              DownloadItem::ReceivedSlices());
+  EXPECT_FALSE(file_initialized_);
+  EXPECT_EQ(0u, job_->workers().size());
+  EXPECT_CALL(*input_stream, RegisterCallback(_));
+  EXPECT_CALL(*input_stream, Read(_, _));
+  EXPECT_CALL(*(observer.get()), DestinationUpdate(_, _, _));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(file_initialized_);
+  EXPECT_EQ(1u, job_->workers().size());
+  DestroyParallelJob();
+}
+
 }  // namespace content