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 is_parallelizable,
                                bool uses_parallel_requests) {
   RecordDownloadCount(INTERRUPTED_COUNT);
-  if (uses_parallel_requests)
-    RecordParallelDownloadCount(INTERRUPTED_COUNT);
+  if (is_parallelizable) {
+    RecordParallelizableDownloadCount(INTERRUPTED_COUNT,
+                                      uses_parallel_requests);
+  }
 
   std::vector<base::HistogramBase::Sample> samples =
       base::CustomHistogram::ArrayToCustomRanges(
           kAllInterruptReasonCodes, arraysize(kAllInterruptReasonCodes));
   UMA_HISTOGRAM_CUSTOM_ENUMERATION("Download.InterruptedReason", reason,
                                    samples);
   if (uses_parallel_requests) {
     UMA_HISTOGRAM_CUSTOM_ENUMERATION(
         "Download.InterruptedReason.ParallelDownload", reason, samples);
   }
@@ skipping 26 matching lines @@
     if (uses_parallel_requests) {
       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,
+                                          uses_parallel_requests);
         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);
@@ skipping 306 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,
+void RecordParallelizableDownloadCount(DownloadCountTypes type,
+                                       bool uses_parallel_requests) {
+  std::string histogram_name = uses_parallel_requests
+                                   ? "Download.Counts.ParallelDownload"
+                                   : "Download.Counts.ParallelizableDownload";
+  UMA_HISTOGRAM_ENUMERATION(histogram_name, type,

[Ilya Sherman, 2017/04/19 00:29:41]

UMA_HISTOGRAM macros require a runtime-constant name.   Please use the function
UmaHistogramEnumeration instead.

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

Done.

                             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