Add new UMA stats for parallelizable 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"
@@ skipping 371 matching lines @@
   UMA_HISTOGRAM_CUSTOM_COUNTS("Download.DownloadSize",
                               download_len,
                               1,
                               max,
                               256);
 }
 
 void RecordDownloadInterrupted(DownloadInterruptReason reason,
                                int64_t received,
                                int64_t total,
-                               bool uses_parallel_requests) {
+                               bool is_parallelizable,
+                               bool is_parallel_download_enabled) {
   RecordDownloadCount(INTERRUPTED_COUNT);
-  if (uses_parallel_requests)
-    RecordParallelDownloadCount(INTERRUPTED_COUNT);
+  if (is_parallelizable) {
+    RecordParallelizableDownloadCount(INTERRUPTED_COUNT,
+                                      is_parallel_download_enabled);
+  }
 
   std::vector<base::HistogramBase::Sample> samples =
       base::CustomHistogram::ArrayToCustomRanges(
           kAllInterruptReasonCodes, arraysize(kAllInterruptReasonCodes));
   UMA_HISTOGRAM_CUSTOM_ENUMERATION("Download.InterruptedReason", reason,
                                    samples);
-  if (uses_parallel_requests) {
+  if (is_parallel_download_enabled) {
     UMA_HISTOGRAM_CUSTOM_ENUMERATION(
         "Download.InterruptedReason.ParallelDownload", reason, samples);
   }
 
   // The maximum should be 2^kBuckets, to have the logarithmic bucket
   // boundaries fall on powers of 2.
   static const int kBuckets = 30;
   static const int64_t kMaxKb = 1 << kBuckets;  // One Terabyte, in Kilobytes.
   int64_t delta_bytes = total - received;
   bool unknown_size = total <= 0;
   int64_t received_kb = received / 1024;
   int64_t total_kb = total / 1024;
   UMA_HISTOGRAM_CUSTOM_COUNTS("Download.InterruptedReceivedSizeK",
                               received_kb,
                               1,
                               kMaxKb,
                               kBuckets);
-  if (uses_parallel_requests) {
+  if (is_parallel_download_enabled) {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Download.InterruptedReceivedSizeK.ParallelDownload", received_kb, 1,
         kMaxKb, kBuckets);
   }
 
   if (!unknown_size) {
     UMA_HISTOGRAM_CUSTOM_COUNTS("Download.InterruptedTotalSizeK",
                                 total_kb,
                                 1,
                                 kMaxKb,
                                 kBuckets);
-    if (uses_parallel_requests) {
+    if (is_parallel_download_enabled) {
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Download.InterruptedTotalSizeK.ParallelDownload", total_kb, 1,
           kMaxKb, kBuckets);
     }
     if (delta_bytes == 0) {
       RecordDownloadCount(INTERRUPTED_AT_END_COUNT);
       UMA_HISTOGRAM_CUSTOM_ENUMERATION("Download.InterruptedAtEndReason",
                                        reason, samples);
 
-      if (uses_parallel_requests) {
-        RecordParallelDownloadCount(INTERRUPTED_AT_END_COUNT);
+      if (is_parallelizable) {
+        RecordParallelizableDownloadCount(INTERRUPTED_AT_END_COUNT,
+                                          is_parallel_download_enabled);
         UMA_HISTOGRAM_CUSTOM_ENUMERATION(
             "Download.InterruptedAtEndReason.ParallelDownload", reason,
             samples);
       }
     } else if (delta_bytes > 0) {
       UMA_HISTOGRAM_CUSTOM_COUNTS("Download.InterruptedOverrunBytes",
                                   delta_bytes,
                                   1,
                                   kMaxKb,
                                   kBuckets);
-      if (uses_parallel_requests) {
+      if (is_parallel_download_enabled) {
         UMA_HISTOGRAM_CUSTOM_COUNTS(
             "Download.InterruptedOverrunBytes.ParallelDownload", delta_bytes, 1,
             kMaxKb, kBuckets);
       }
     } else {
       UMA_HISTOGRAM_CUSTOM_COUNTS("Download.InterruptedUnderrunBytes",
                                   -delta_bytes,
                                   1,
                                   kMaxKb,
                                   kBuckets);
-      if (uses_parallel_requests) {
+      if (is_parallel_download_enabled) {
         UMA_HISTOGRAM_CUSTOM_COUNTS(
             "Download.InterruptedUnderrunBytes.ParallelDownload", -delta_bytes,
             1, kMaxKb, kBuckets);
       }
     }
   }
 
   UMA_HISTOGRAM_BOOLEAN("Download.InterruptedUnknownSize", unknown_size);
 }
 
@@ skipping 284 matching lines @@
 void RecordFileBandwidth(size_t length,
                          base::TimeDelta disk_write_time,
                          base::TimeDelta elapsed_time) {
   RecordBandwidthMetric("Download.BandwidthOverallBytesPerSecond",
                         CalculateBandwidthBytesPerSecond(length, elapsed_time));
   RecordBandwidthMetric(
       "Download.BandwidthDiskBytesPerSecond",
       CalculateBandwidthBytesPerSecond(length, disk_write_time));
 }
 
-void RecordParallelDownloadCount(DownloadCountTypes type) {
-  UMA_HISTOGRAM_ENUMERATION("Download.Counts.ParallelDownload", type,
-                            DOWNLOAD_COUNT_TYPES_LAST_ENTRY);
+void RecordParallelizableDownloadCount(DownloadCountTypes type,
+                                       bool is_parallel_download_enabled) {
+  std::string histogram_name = is_parallel_download_enabled
+                                   ? "Download.Counts.ParallelDownload"
+                                   : "Download.Counts.ParallelizableDownload";
+  base::UmaHistogramEnumeration(histogram_name, type,
+                                DOWNLOAD_COUNT_TYPES_LAST_ENTRY);
 }
 
 void RecordParallelDownloadRequestCount(int request_count) {
   UMA_HISTOGRAM_CUSTOM_COUNTS("Download.ParallelDownloadRequestCount",
                               request_count, 1, 10, 11);
 }
 
 void RecordParallelDownloadAddStreamSuccess(bool success) {
   UMA_HISTOGRAM_BOOLEAN("Download.ParallelDownloadAddStreamSuccess", success);
 }
 
-void RecordParallelDownloadStats(
+void RecordParallelizableDownloadStats(
     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) {
-  int64_t 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_without_parallel_streams,
+    bool uses_parallel_requests) {
+  int64_t bandwidth_without_parallel_streams = 0;
+  if (bytes_downloaded_without_parallel_streams > 0) {
+    bandwidth_without_parallel_streams = CalculateBandwidthBytesPerSecond(
+        bytes_downloaded_without_parallel_streams,
+        time_without_parallel_streams);
+    if (uses_parallel_requests) {
+      RecordBandwidthMetric(
+          "Download.ParallelizableDownloadBandwidth."
+          "WithParallelRequestsSingleStream",
+          bandwidth_without_parallel_streams);
+    } else {
+      RecordBandwidthMetric(
+          "Download.ParallelizableDownloadBandwidth."
+          "WithoutParallelRequests",
+          bandwidth_without_parallel_streams);
+    }
+  }
+
+  if (!uses_parallel_requests)
+    return;
+
+  if (bytes_downloaded_with_parallel_streams > 0) {
+    RecordBandwidthMetric(
+        "Download.ParallelizableDownloadBandwidth."
+        "WithParallelRequestsMultipleStreams",
+        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);
@@ skipping 90 matching lines @@
   if (!page_transition)
     return;
 
   UMA_HISTOGRAM_ENUMERATION(
       "Download.PageTransition",
       ui::PageTransitionStripQualifier(page_transition.value()),
       ui::PAGE_TRANSITION_LAST_CORE + 1);
 }
 
 }  // namespace content