Add new UMA stats for parallelizable download

content/browser/download/download_file_impl.cc

 // Copyright (c) 2012 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/download_file_impl.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 111 matching lines @@
       download_item_net_log.source().ToEventParametersCallback());
 }
 
 DownloadFileImpl::~DownloadFileImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_ACTIVE);
 }
 
 void DownloadFileImpl::Initialize(
     const InitializeCallback& callback,
-    const DownloadItem::ReceivedSlices& received_slices) {
+    const DownloadItem::ReceivedSlices& received_slices,
+    bool is_parallelizable) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   update_timer_.reset(new base::RepeatingTimer());
   int64_t bytes_so_far = 0;
   received_slices_ = received_slices;
   if (IsSparseFile()) {
     for (const auto& received_slice : received_slices_) {
       bytes_so_far += received_slice.received_bytes;
     }
   } else {
     bytes_so_far = save_info_->offset;
   }
   DownloadInterruptReason result = file_.Initialize(
       save_info_->file_path, default_download_directory_,
       std::move(save_info_->file), bytes_so_far,
       save_info_->hash_of_partial_file, std::move(save_info_->hash_state),
       IsSparseFile());
   if (result != DOWNLOAD_INTERRUPT_REASON_NONE) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, base::Bind(callback, result));
     return;
   }
 
   download_start_ = base::TimeTicks::Now();
   last_update_time_ = download_start_;
+  record_stream_bandwidth_ = is_parallelizable;

[xingliu, 2017/04/19 02:18:11]

Can we initialize this to false in the constructor? 

[qinmin, 2017/04/19 22:42:33]

Done.

 
   // Primarily to make reset to zero in restart visible to owner.
   SendUpdate();
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE, base::Bind(
           callback, DOWNLOAD_INTERRUPT_REASON_NONE));
 
   // Initial pull from the straw from all source streams.
   for (auto& source_stream : source_streams_)
@@ skipping 307 matching lines @@
     }
     num_active_streams_--;
 
     // Inform observers.
     SendUpdate();
 
     // All the stream reader are completed, shut down file IO processing.
     if (IsDownloadCompleted()) {
       RecordFileBandwidth(bytes_seen_, disk_writes_time_,
                           base::TimeTicks::Now() - download_start_);
-      if (IsSparseFile() && record_stream_bandwidth_) {
-        RecordParallelDownloadStats(bytes_seen_with_parallel_streams_,
-                                    download_time_with_parallel_streams_,
-                                    bytes_seen_without_parallel_streams_,
-                                    download_time_without_parallel_streams_);
+      if (record_stream_bandwidth_) {
+        RecordParallelizableDownloadStats(
+            bytes_seen_with_parallel_streams_,
+            download_time_with_parallel_streams_,
+            bytes_seen_without_parallel_streams_,
+            download_time_without_parallel_streams_, IsSparseFile());
       }
       weak_factory_.InvalidateWeakPtrs();
       std::unique_ptr<crypto::SecureHash> hash_state = file_.Finish();
       update_timer_.reset();
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           base::Bind(&DownloadDestinationObserver::DestinationCompleted,
                      observer_, TotalBytesReceived(),
                      base::Passed(&hash_state)));
     }
@@ skipping 198 matching lines @@
     const base::FilePath& new_path,
     const RenameCompletionCallback& completion_callback)
     : option(option),
       new_path(new_path),
       retries_left(kMaxRenameRetries),
       completion_callback(completion_callback) {}
 
 DownloadFileImpl::RenameParameters::~RenameParameters() {}
 
 }  // namespace content