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.

[asanka, 2017/03/17 17:10:09]

Probably needs to be plumbed up from DownloadRequestCore.

This is available via url_request()->response_info()->connection_info.

[xingliu, 2017/03/17 19:08:26]

Thanks, will do it in a separate CL.

+  // 4. (Undetermined) Not under http proxy, e.g. data saver.

[asanka, 2017/03/17 17:10:09]

I'd suggest being a bit conservative about avoiding proxies since those are
common.

Excluding H2 / QUIC will automatically eliminate proxies we are accessing via
multiplexed connections. That might be enough to avoid parallel requests via the
data reduction proxy.

[xingliu, 2017/03/17 19:08:26]

Make sense, removed the http proxy line.

+
+  // 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 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;
+       ++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 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