Add a delay to send the parallel requests.

content/browser/download/parallel_download_job.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 "base/memory/ptr_util.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/parallel_download_utils.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/storage_partition.h"
 
 namespace content {
 
 ParallelDownloadJob::ParallelDownloadJob(
     DownloadItemImpl* download_item,
     std::unique_ptr<DownloadRequestHandleInterface> request_handle,
     const DownloadCreateInfo& create_info)
     : DownloadJobImpl(download_item, std::move(request_handle)),
       initial_request_offset_(create_info.save_info->offset),
       initial_request_length_(create_info.save_info->length) {}
 
 ParallelDownloadJob::~ParallelDownloadJob() = default;
 
 void ParallelDownloadJob::Start() {
   DownloadJobImpl::Start();
 
-  BuildParallelRequests();
+  timer_.Start(FROM_HERE, GetParallelRequestDelayConfig(), this,
+               &ParallelDownloadJob::BuildParallelRequests);
 }
 
 void ParallelDownloadJob::Cancel(bool user_cancel) {
   DownloadJobImpl::Cancel(user_cancel);

[qinmin, 2017/03/15 18:32:38]

you need to stop the timer_ here

[xingliu, 2017/03/15 19:37:11]

Discussed below.

[David Trainor- moved to gerrit, 2017/03/15 22:39:54]

Nice catch Min!

[xingliu, 2017/03/15 23:43:57]

Done.

   for (auto& worker : workers_)
     worker->Cancel();
 }
 
 void ParallelDownloadJob::Pause() {
   DownloadJobImpl::Pause();

[qinmin, 2017/03/15 18:32:38]

need some book keeping here. If the timer is active, record its state, and stop
the timer

[xingliu, 2017/03/15 19:37:11]

Yeah, we need state control in this class. Can we do it in next CL? Also
probably directly control the request handle.

[qinmin, 2017/03/15 21:50:57]

This is different from the request handle. You don't even need to create the
request handles in this case.

[xingliu, 2017/03/15 23:43:57]

Makes sense, done. This is better.

   for (auto& worker : workers_)
     worker->Pause();
 }
 
 void ParallelDownloadJob::Resume(bool resume_request) {
   DownloadJobImpl::Resume(resume_request);

[qinmin, 2017/03/15 18:32:38]

Need to start the timer again if it is paused previously.

[xingliu, 2017/03/15 19:37:11]

Shall we use requests handle to control the state, wdyt?

Like we send the requests and get response, if they are paused, we pause the
request handle instead of the timer.

Since pause the timer will introduce another state control.

[qinmin, 2017/03/15 21:50:57]

The timer is a one-time thing before the requests are created. So if user has
already paused a download, why should we create those request handle?

[xingliu, 2017/03/15 23:43:57]

Done.

   if (!resume_request)
     return;
 
   for (auto& worker : workers_)
     worker->Resume();
 }
 
 void ParallelDownloadJob::ForkRequestsForNewDownload(int64_t bytes_received,
                                                      int64_t total_bytes,
                                                      int request_count) {
@@ skipping 14 matching lines @@
                          ? slice_size + (bytes_left % slice_size)
                          : slice_size;
     CreateRequest(current_offset, length);
     current_offset += slice_size;
   }
 }
 
 void ParallelDownloadJob::BuildParallelRequests() {
   // Calculate the slices to download and fork parallel requests.
   std::vector<DownloadItem::ReceivedSlice> slices_to_download =
       FindSlicesToDownload(download_item_->GetReceivedSlices());

[qinmin, 2017/03/15 19:09:00]

There is also an issue here. The initial request might have write some data
before the delayed task is executed. And the updated ReceivedSlices information
is not yet reported to DownloadItem as the write/report happens on different
thread. 

[xingliu, 2017/03/15 19:37:11]

This is probably OK, if DownloadFile is smart enough to discard later streams or
continue writing.

   // The initial request has already been sent, it should cover the first slice.
   DCHECK_GE(slices_to_download[0].offset, initial_request_offset_);
   DCHECK(initial_request_length_ == DownloadSaveInfo::kLengthFullContent ||
          initial_request_offset_ + initial_request_length_ >=
              slices_to_download[0].offset +
              slices_to_download[0].received_bytes);
   if (slices_to_download.size() >=
       static_cast<size_t>(GetParallelRequestCountConfig())) {
     // The size of |slices_to_download| should be no larger than
     // |kParallelRequestCount| unless |kParallelRequestCount| is changed after
@@ skipping 32 matching lines @@
   // Subsequent range requests have the same referrer URL as the original
   // download request.
   download_params->set_referrer(Referrer(download_item_->GetReferrerUrl(),
                                          blink::WebReferrerPolicyAlways));
   // Send the request.
   worker->SendRequest(std::move(download_params));
   workers_.push_back(std::move(worker));
 }
 
 }  // namespace content