Add UMA for estimating disk bandwidth and the time saved with parallel download

content/browser/download/download_stats.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_stats.h"
 
 #include "base/macros.h"
+#include "base/metrics/histogram_functions.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_util.h"
 #include "content/browser/download/download_resource_handler.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "net/http/http_content_disposition.h"
 
 namespace content {
 
 namespace {
@@ skipping 321 matching lines @@
 
 // Maps extensions to their matching UMA histogram int value.
 int GetDangerousFileType(const base::FilePath& file_path) {
   for (size_t i = 0; i < arraysize(kDangerousFileTypes); ++i) {
     if (file_path.MatchesExtension(kDangerousFileTypes[i]))
       return i + 1;
   }
   return 0;  // Unknown extension.
 }
 
+// Helper method to calculate the bandwidth given the data length and time.
+int CalculateBandwidthBytesPerSecond(size_t length,
+                                     base::TimeDelta elapsed_time) {
+  size_t elapsed_time_ms = elapsed_time.InMilliseconds();
+  if (0u == elapsed_time_ms)
+    elapsed_time_ms = 1;
+
+  return 1000 * length / elapsed_time_ms;
+}
+
+// Helper method to record the bandwidth for a given metric.
+void RecordBandwidthMetric(const std::string& metric, int bandwidth) {
+  base::UmaHistogramCustomCounts(metric, bandwidth, 1, 50 * 1000 * 1000, 50);
+}
+
 } // namespace
 
 void RecordDownloadCount(DownloadCountTypes type) {
   UMA_HISTOGRAM_ENUMERATION(
       "Download.Counts", type, DOWNLOAD_COUNT_TYPES_LAST_ENTRY);
 }
 
 void RecordDownloadSource(DownloadSource source) {
   UMA_HISTOGRAM_ENUMERATION(
       "Download.Sources", source, DOWNLOAD_SOURCE_LAST_ENTRY);
@@ skipping 337 matching lines @@
         resource_handler_blocked_time * 100 / resource_handler_lifetime;
   }
 
   UMA_HISTOGRAM_COUNTS_100("Download.ResourceHandlerBlockedPercentage",
                            percentage);
 }
 
 void RecordFileBandwidth(size_t length,
                          base::TimeDelta disk_write_time,
                          base::TimeDelta elapsed_time) {
-  size_t elapsed_time_ms = elapsed_time.InMilliseconds();
-  if (0u == elapsed_time_ms)
-    elapsed_time_ms = 1;
-  size_t disk_write_time_ms = disk_write_time.InMilliseconds();
-  if (0u == disk_write_time_ms)
-    disk_write_time_ms = 1;
+  RecordBandwidthMetric("Download.BandwidthOverallBytesPerSecond",
+                        CalculateBandwidthBytesPerSecond(length, elapsed_time));
+  RecordBandwidthMetric(
+      "Download.BandwidthDiskBytesPerSecond",
+      CalculateBandwidthBytesPerSecond(length, disk_write_time));
+}
 
-  UMA_HISTOGRAM_CUSTOM_COUNTS(
-      "Download.BandwidthOverallBytesPerSecond",
-      (1000 * length / elapsed_time_ms), 1, 50000000, 50);
-  UMA_HISTOGRAM_CUSTOM_COUNTS(
-      "Download.BandwidthDiskBytesPerSecond",
-      (1000 * length / disk_write_time_ms), 1, 50000000, 50);
+void RecordParallelDownloadStats(
+    size_t bytes_downloaded_with_parallel_streams,
+    base::TimeDelta time_with_parallel_streams,
+    size_t bytes_downloaded_without_parallel_streams,
+    base::TimeDelta time_without_parallel_streams) {
+  int bandwidth_without_parallel_streams = CalculateBandwidthBytesPerSecond(
+      bytes_downloaded_without_parallel_streams, time_without_parallel_streams);
+  RecordBandwidthMetric(
+      "Download.BandwidthWithoutParallelStreamsBytesPerSecond",
+      bandwidth_without_parallel_streams);
+  RecordBandwidthMetric(
+      "Download.BandwidthWithParallelStreamsBytesPerSecond",
+      CalculateBandwidthBytesPerSecond(bytes_downloaded_with_parallel_streams,
+                                       time_with_parallel_streams));
+
+  base::TimeDelta time_saved;
+  if (bandwidth_without_parallel_streams > 0) {
+    time_saved = base::TimeDelta::FromMilliseconds(
+                     1000.0 * bytes_downloaded_with_parallel_streams /
+                     bandwidth_without_parallel_streams) -
+                 time_with_parallel_streams;
+  }
+  int kMillisecondsPerHour =
+      base::checked_cast<int>(base::Time::kMillisecondsPerSecond * 60 * 60);
+  if (time_saved >= base::TimeDelta()) {
+    UMA_HISTOGRAM_CUSTOM_COUNTS(
+        "Download.EstimatedTimeSavedWithParallelDownload",
+        time_saved.InMilliseconds(), 0, kMillisecondsPerHour, 50);
+  } else {
+    UMA_HISTOGRAM_CUSTOM_COUNTS(
+        "Download.EstimatedTimeWastedWithParallelDownload",
+        -time_saved.InMilliseconds(), 0, kMillisecondsPerHour, 50);
+  }
 }
 
 void RecordDownloadFileRenameResultAfterRetry(
     base::TimeDelta time_since_first_failure,
     DownloadInterruptReason interrupt_reason) {
   if (interrupt_reason == DOWNLOAD_INTERRUPT_REASON_NONE) {
     UMA_HISTOGRAM_TIMES("Download.TimeToRenameSuccessAfterInitialFailure",
                         time_since_first_failure);
   } else {
     UMA_HISTOGRAM_TIMES("Download.TimeToRenameFailureAfterInitialFailure",
@@ skipping 66 matching lines @@
   if (!page_transition)
     return;
 
   UMA_HISTOGRAM_ENUMERATION(
       "Download.PageTransition",
       ui::PageTransitionStripQualifier(page_transition.value()),
       ui::PAGE_TRANSITION_LAST_CORE + 1);
 }
 
 }  // namespace content