Add more UMA to record whether parallel download is completed/interrupted/cancelled

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 @@
   download_len /= 1024;  // In Kilobytes
   UMA_HISTOGRAM_CUSTOM_COUNTS("Download.DownloadSize",
                               download_len,
                               1,
                               max,
                               256);
 }
 
 void RecordDownloadInterrupted(DownloadInterruptReason reason,
                                int64_t received,
-                               int64_t total) {
+                               int64_t total,
+                               bool uses_parallel_requests) {
   RecordDownloadCount(INTERRUPTED_COUNT);
-  UMA_HISTOGRAM_CUSTOM_ENUMERATION(
-      "Download.InterruptedReason",
-      reason,
+  if (uses_parallel_requests)
+    RecordParallelDownloadCount(PARALLEL_DOWNLOAD_INTERRUPTED_COUNT);
+
+  std::vector<base::HistogramBase::Sample> samples =
       base::CustomHistogram::ArrayToCustomRanges(
-          kAllInterruptReasonCodes, arraysize(kAllInterruptReasonCodes)));
+          kAllInterruptReasonCodes, arraysize(kAllInterruptReasonCodes));
+  UMA_HISTOGRAM_CUSTOM_ENUMERATION("Download.InterruptedReason", reason,
+                                   samples);
+  if (uses_parallel_requests) {
+    UMA_HISTOGRAM_CUSTOM_ENUMERATION(
+        "Download.ParallelDownloadInterruptedReason", 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) {
+    UMA_HISTOGRAM_CUSTOM_COUNTS(
+        "Download.ParallelDownloadInterruptedReceivedSizeK", received_kb, 1,

[Ilya Sherman, 2017/03/24 00:52:59]

Optional: You might want to move "ParallelDownload" to be a suffix, so that
related histograms are grouped near each other.  (Well, related in terms of the
thing being measured; currently, all ParallelDownload histograms would be
alphabetized together, which is maybe more important for you?)

[Ilya Sherman, 2017/03/24 00:52:59]

nit: I'd use an extra dot to separate "ParallelDownload" from the rest of the
name.

[qinmin, 2017/03/24 19:54:39]

uses .ParallelDownload suffix now

[qinmin, 2017/03/24 19:54:40]

Done.

+        kMaxKb, kBuckets);
+  }
+
   if (!unknown_size) {
     UMA_HISTOGRAM_CUSTOM_COUNTS("Download.InterruptedTotalSizeK",
                                 total_kb,
                                 1,
                                 kMaxKb,
                                 kBuckets);
+    if (uses_parallel_requests) {
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Download.ParallelDownloadInterruptedTotalSizeK", total_kb, 1, kMaxKb,
+          kBuckets);
+    }
     if (delta_bytes == 0) {
       RecordDownloadCount(INTERRUPTED_AT_END_COUNT);
       UMA_HISTOGRAM_CUSTOM_ENUMERATION(
-          "Download.InterruptedAtEndReason",
-          reason,
-          base::CustomHistogram::ArrayToCustomRanges(
-              kAllInterruptReasonCodes,
-              arraysize(kAllInterruptReasonCodes)));
+          "Download.InterruptedAtEndReason", reason, samples);
+
+      if (uses_parallel_requests) {
+        RecordParallelDownloadCount(PARALLEL_DOWNLOAD_INTERRUPTED_AT_END_COUNT);
+        UMA_HISTOGRAM_CUSTOM_ENUMERATION(
+            "Download.ParallelDownloadInterruptedAtEndReason", reason, samples);
+      }
     } else if (delta_bytes > 0) {
       UMA_HISTOGRAM_CUSTOM_COUNTS("Download.InterruptedOverrunBytes",
                                   delta_bytes,
                                   1,
                                   kMaxKb,
                                   kBuckets);
+      if (uses_parallel_requests) {
+        UMA_HISTOGRAM_CUSTOM_COUNTS(
+            "Download.ParallelDownloadInterruptedOverrunBytes", delta_bytes, 1,
+            kMaxKb, kBuckets);
+      }
     } else {
       UMA_HISTOGRAM_CUSTOM_COUNTS("Download.InterruptedUnderrunBytes",
                                   -delta_bytes,
                                   1,
                                   kMaxKb,
                                   kBuckets);
+      if (uses_parallel_requests) {
+        UMA_HISTOGRAM_CUSTOM_COUNTS(
+            "Download.ParallelDownloadInterruptedUnderrunBytes", -delta_bytes,
+            1, kMaxKb, kBuckets);
+      }
     }
   }
 
   UMA_HISTOGRAM_BOOLEAN("Download.InterruptedUnknownSize", unknown_size);
 }
 
 void RecordMaliciousDownloadClassified(DownloadDangerType danger_type) {
   UMA_HISTOGRAM_ENUMERATION("Download.MaliciousDownloadClassified",
                             danger_type,
                             DOWNLOAD_DANGER_TYPE_MAX);
@@ skipping 270 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(ParallelDownloadCountTypes type) {
+  UMA_HISTOGRAM_ENUMERATION("Download.ParallelDownloadCounts", type,
+                            PARALLEL_DOWNLOAD_COUNT_TYPES_LAST_ENTRY);
+}
+
 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);
@@ skipping 99 matching lines @@
   if (!page_transition)
     return;
 
   UMA_HISTOGRAM_ENUMERATION(
       "Download.PageTransition",
       ui::PageTransitionStripQualifier(page_transition.value()),
       ui::PAGE_TRANSITION_LAST_CORE + 1);
 }
 
 }  // namespace content