Update the received slices vector when stream is written to disk

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 10 matching lines @@
 const int64_t kMinSliceSizeParallelDownload = 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;
 
+bool compareReceivedSlices(const DownloadItem::ReceivedSlice& lhs,
+                           const DownloadItem::ReceivedSlice& rhs) {
+  return lhs.offset < rhs.offset;
+}
+
 }  // namespace
 
 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;
   }
 
@@ skipping 13 matching lines @@
     }
 
     DCHECK_GE(next->offset, offset);
     if (next->offset > offset)
       result.emplace_back(offset, next->offset - offset);
     iter = next;
   }
   return result;
 }
 
+size_t AddOrMergeReceivedSliceIntoSortedArray(
+    const DownloadItem::ReceivedSlice& new_slice,
+    std::vector<DownloadItem::ReceivedSlice>& received_slices) {
+  std::vector<DownloadItem::ReceivedSlice>::iterator it =
+      std::upper_bound(received_slices.begin(), received_slices.end(),
+                       new_slice, compareReceivedSlices);
+  if (it != received_slices.begin()) {
+    std::vector<DownloadItem::ReceivedSlice>::iterator prev = std::prev(it);
+    if (prev->offset + prev->received_bytes == new_slice.offset) {

[xingliu, 2017/03/09 01:33:53]

Do we merge when (prev->offset + prev->received_bytes > new_slice.offset)?

If we have 3 slices, the first two are finished, and then they merged, and we
have 2 slices eventually, does it means the db now will have 2 records? 
We currently use REPLACE so we probably need to delete a single record?

[qinmin, 2017/03/09 05:43:53]

No. That shouldn't happen. If that happens, there is a logic error somewhere in
our code when calculating how much data we can write.

2 finished slices won't get merged, because that will impact the number of db
entries. 
Here we only merge a new(unfinished) slice with an existing finished slice, so
we won't increase the number of db entries if possible.
For example, if (0, 500) and (1000, 1500) are 2 finished slice, when a new slice
(500, 600) is introduced, it will be merged with (0, 500). When that new slice
finally goes to 1000, we have (0, 1000) and (1000, 1500), those 2 finished
slices will not be merged. 

[xingliu, 2017/03/09 05:46:07]

sgtm.

+      prev->received_bytes += new_slice.received_bytes;
+      return static_cast<size_t>(std::distance(received_slices.begin(), prev));
+    }
+  }
+
+  it = received_slices.emplace(it, new_slice);
+  return static_cast<size_t>(std::distance(received_slices.begin(), it));
+}
+
 int64_t GetMinSliceSizeConfig() {
   std::string finch_value = base::GetFieldTrialParamValueByFeature(
       features::kParallelDownloading, kMinSliceSizeFinchKey);
   int64_t result;
   return !finch_value.empty() && base::StringToInt64(finch_value, &result)
              ? result
              : kMinSliceSizeParallelDownload;
 }
 
 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