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 "content/public/browser/download_save_info.h"
 #include "content/public/common/content_features.h"
@@ skipping 12 matching lines @@
 // Finch parameter key value for number of parallel requests in a parallel
 // download, including the original request.
 const char kParallelRequestCountFinchKey[] = "request_count";
 
 // Default value for |kParallelRequestCountFinchKey|, when no parameter is
 // specified.
 const int kParallelRequestCount = 2;
 
 }  // 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. (Undetermined) Http/1.1 protocol.
+  // 4. (Undetermined) Not under http proxy, e.g. data saver.
+
+  // 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> FindSlicesForNewDownload(
+    int64_t bytes_received,
+    int64_t total_bytes,
+    int request_count) {
+  std::vector<DownloadItem::ReceivedSlice> slices_to_download;
+  if (bytes_received >= total_bytes || request_count <= 0)
+    return slices_to_download;
+
+  // TODO(xingliu): Consider to use minimum size of a slice.
+  int64_t bytes_left = total_bytes - bytes_received;
+  int64_t slice_size = bytes_left / request_count;
+  slice_size = slice_size > 0 ? slice_size : 1;
+  int64_t current_offset = bytes_received;
+  for (int i = 0, num_requests = bytes_left / slice_size; i < num_requests - 1;

[qinmin, 2017/03/11 06:08:22]

shouldn't this just use request_count? why using a new num_requests?

[xingliu, 2017/03/13 17:53:17]

This logic considers an edge case, like 3 bytes left with 4 request count, then
slice_size will be 1, and num_requests is 3 instead of 4.

+       ++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, 0);

[qinmin, 2017/03/11 06:08:22]

s/0/DownloadSaveInfo::kLengthFullContent/

[xingliu, 2017/03/13 17:53:17]

Done.

+  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 30 matching lines @@
 int GetParallelRequestCountConfig() {
   std::string finch_value = base::GetFieldTrialParamValueByFeature(
       features::kParallelDownloading, kParallelRequestCountFinchKey);
   int result;
   return !finch_value.empty() && base::StringToInt(finch_value, &result)
              ? result
              : kParallelRequestCount;
 }
 
 }  // namespace content