Fix the UMA stats calculation because of overflow

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 330 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)
+int64_t CalculateBandwidthBytesPerSecond(size_t length,
+                                         base::TimeDelta elapsed_time) {
+  int64_t elapsed_time_ms = elapsed_time.InMilliseconds();
+  if (0 == elapsed_time_ms)
     elapsed_time_ms = 1;
-
-  return 1000 * length / elapsed_time_ms;
+  return 1000 * static_cast<int64_t>(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) {
@@ skipping 399 matching lines @@
       "Download.BandwidthDiskBytesPerSecond",
       CalculateBandwidthBytesPerSecond(length, disk_write_time));
 }
 
 void RecordParallelDownloadCount(DownloadCountTypes type) {
   UMA_HISTOGRAM_ENUMERATION("Download.Counts.ParallelDownload", type,
                             DOWNLOAD_COUNT_TYPES_LAST_ENTRY);
 }
 
 void RecordParallelDownloadStats(
     size_t bytes_downloaded_with_parallel_streams,

[xingliu, 2017/04/05 00:29:10]

nit%: Not in this patch, but does it make sense to make bytes_downloaded_* and
bytes_seen_ to be int64_t. 

[qinmin, 2017/04/05 05:33:55]

normally anything non-negative and has file system constraints are size_t. 
For example. file size and memory size should both use size_t.When the
underlying CPU architecture changes from 32bit to 64bit or to 128bit, we don't
need to change the code.
Bytes_downloaded and bytes_seen_ are related to file size, so I would keep them
as size_t unless we really need to worry about the case of downloading a big
filewhose size is not supported by the filesystem.

[xingliu, 2017/04/05 17:56:38]

sgtm, but does cpu architecture limit the size of sdcard on Android? It's a bit
weird.

     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(
+  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_saved;
@@ skipping 93 matching lines @@
   if (!page_transition)
     return;
 
   UMA_HISTOGRAM_ENUMERATION(
       "Download.PageTransition",
       ui::PageTransitionStripQualifier(page_transition.value()),
       ui::PAGE_TRANSITION_LAST_CORE + 1);
 }
 
 }  // namespace content