Parallel Download finch config parameters on Chrome client.

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"
 
 namespace content {
 
+namespace {
+
+// Finch parameter key value for minimum file size in bytes to use parallel
+// download.
+const char kMinFileSizeFinchKey[] = "min_file_size";

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

shouldn't be file size, it could be part of a slice.

For example, a file is 1G bytes large, and we use 2 workers to download it. If
the first worker downloaded 100 MB and chrome crashes right before the 2nd
worker is able to download any data, then we should still fork the 2nd worker
when resuming the download 

I would use MinSliceSize instead

[xingliu, 2017/03/06 23:37:05]

Done. Also polished some comments.

One question of the expected behavior: If we have 2 holes and they are both
larger than MinSliceSize, and we can have at most 2 requests.

Then the 2 worker will download the first hole, then if one of them is finished,
we chunk the second hole, and start one new request on it?

[xingliu, 2017/03/07 18:44:08]

Got it.

+
+// Default value for |kMinFileSizeFinchKey|, when no parameter is specified.
+const int64_t kMinFileSizeParallelDownload = 2097152;
+
+// 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
+
 DownloadItem::ReceivedSlice FindNextSliceToDownload(
     const std::vector<DownloadItem::ReceivedSlice>& received_slices) {
   if (received_slices.empty())
     return DownloadItem::ReceivedSlice(0, DownloadSaveInfo::kLengthFullContent);
 
   std::vector<DownloadItem::ReceivedSlice>::const_iterator iter =
       received_slices.begin();
   DCHECK_GE(iter->offset, 0);
   if (iter->offset != 0)
     return DownloadItem::ReceivedSlice(0, iter->offset);
@@ skipping 10 matching lines @@
     DCHECK_GE(next->offset, offset);
     if (next->offset > offset) {
       remaining_bytes = next->offset - offset;
       break;
     }
     iter = next;
   }
   return DownloadItem::ReceivedSlice(offset, remaining_bytes);
 }
 
+int64_t GetMinFileSizeConfig() {
+  std::string finch_value = base::GetFieldTrialParamValueByFeature(
+      features::kParallelDownloading, kMinFileSizeFinchKey);
+  int64_t result;
+  return !finch_value.empty() && base::StringToInt64(finch_value, &result)
+             ? result
+             : kMinFileSizeParallelDownload;
+}
+
+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