Glue parallel download job and download file together.

content/browser/download/parallel_download_utils.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_utils.h"
 
 #include "base/metrics/field_trial_params.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "content/public/browser/download_save_info.h"
@@ skipping 24 matching lines @@
 
 // TODO(qinmin): replace this with a comparator operator in
 // DownloadItem::ReceivedSlice.
 bool compareReceivedSlices(const DownloadItem::ReceivedSlice& lhs,
                            const DownloadItem::ReceivedSlice& rhs) {
   return lhs.offset < rhs.offset;
 }
 
 }  // namespace
 
+bool ShouldUseParallelDownload(const DownloadCreateInfo& create_info) {
+  // 1. Accept-Ranges, Content-Length and strong validators response headers.
+  // 2. Feature |kParallelDownloading| enabled.
+  // 3. Content-Length is no less than the minimum slice size configuration.
+  // 3. TODO(xingliu) HTTP/1.1 protocol, not QUIC or HTTP/2.
+
+  // Etag and last modified are stored into DownloadCreateInfo in
+  // DownloadRequestCore only if the response header complies to the strong
+  // validator rule.
+  bool has_strong_validator =
+      !create_info.etag.empty() || !create_info.last_modified.empty();
+
+  return has_strong_validator && create_info.accept_range &&
+         create_info.total_bytes >= GetMinSliceSizeConfig() &&
+         base::FeatureList::IsEnabled(features::kParallelDownloading);
+}
+
+std::vector<DownloadItem::ReceivedSlice> FindSlicesForRemainingContent(
+    int64_t bytes_received,
+    int64_t content_length,
+    int request_count) {
+  std::vector<DownloadItem::ReceivedSlice> slices_to_download;
+  if (request_count <= 0)
+    return slices_to_download;
+
+  // TODO(xingliu): Consider to use minimum size of a slice.
+  int64_t slice_size = content_length / request_count;
+  slice_size = slice_size > 0 ? slice_size : 1;
+  int64_t current_offset = bytes_received;
+  for (int i = 0, num_requests = content_length / slice_size;
+       i < num_requests - 1; ++i) {
+    slices_to_download.emplace_back(current_offset, slice_size);
+    current_offset += slice_size;
+  }
+
+  // Last slice is a half open slice, which results in sending range request
+  // like "Range:50-" to fetch from 50 bytes to the end of the file.
+  slices_to_download.emplace_back(current_offset,
+                                  DownloadSaveInfo::kLengthFullContent);
+  return slices_to_download;
+}
+
 std::vector<DownloadItem::ReceivedSlice> FindSlicesToDownload(
     const std::vector<DownloadItem::ReceivedSlice>& received_slices) {
   std::vector<DownloadItem::ReceivedSlice> result;
   if (received_slices.empty()) {
     result.emplace_back(0, DownloadSaveInfo::kLengthFullContent);
     return result;
   }
 
   std::vector<DownloadItem::ReceivedSlice>::const_iterator iter =
       received_slices.begin();
@@ skipping 56 matching lines @@
 base::TimeDelta GetParallelRequestDelayConfig() {
   std::string finch_value = base::GetFieldTrialParamValueByFeature(
       features::kParallelDownloading, kParallelRequestDelayFinchKey);
   int64_t time_ms = 0;
   return base::StringToInt64(finch_value, &time_ms)
              ? base::TimeDelta::FromMilliseconds(time_ms)
              : base::TimeDelta::FromMilliseconds(0);
 }
 
 }  // namespace content