Update from https://crrev.com/306655

net/disk_cache/blockfile/backend_impl.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 "net/disk_cache/blockfile/backend_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
@@ skipping 466 matching lines @@
   }
 
   int current_size = data_->header.num_bytes / (1024 * 1024);
   int64 total_hours = stats_.GetCounter(Stats::TIMER) / 120;
   int64 no_use_hours = stats_.GetCounter(Stats::LAST_REPORT_TIMER) / 120;
   int64 use_hours = total_hours - no_use_hours;
 
   if (!cache_entry) {
     CACHE_UMA(AGE_MS, "OpenTime.Miss", 0, start);
     CACHE_UMA(COUNTS_10000, "AllOpenBySize.Miss", 0, current_size);
-    CACHE_UMA(HOURS, "AllOpenByTotalHours.Miss", 0, total_hours);
-    CACHE_UMA(HOURS, "AllOpenByUseHours.Miss", 0, use_hours);
+    CACHE_UMA(HOURS, "AllOpenByTotalHours.Miss", 0,
+              static_cast<base::HistogramBase::Sample>(total_hours));
+    CACHE_UMA(HOURS, "AllOpenByUseHours.Miss", 0,
+              static_cast<base::HistogramBase::Sample>(use_hours));
     stats_.OnEvent(Stats::OPEN_MISS);
     return NULL;
   }
 
   eviction_.OnOpenEntry(cache_entry);
   entry_count_++;
 
   Trace("Open hash 0x%x end: 0x%x", hash,
         cache_entry->entry()->address().value());
   CACHE_UMA(AGE_MS, "OpenTime", 0, start);
   CACHE_UMA(COUNTS_10000, "AllOpenBySize.Hit", 0, current_size);
-  CACHE_UMA(HOURS, "AllOpenByTotalHours.Hit", 0, total_hours);
-  CACHE_UMA(HOURS, "AllOpenByUseHours.Hit", 0, use_hours);
+  CACHE_UMA(HOURS, "AllOpenByTotalHours.Hit", 0,
+            static_cast<base::HistogramBase::Sample>(total_hours));
+  CACHE_UMA(HOURS, "AllOpenByUseHours.Hit", 0,
+            static_cast<base::HistogramBase::Sample>(use_hours));
   stats_.OnEvent(Stats::OPEN_HIT);
   web_fonts_histogram::RecordCacheHit(cache_entry);
   SIMPLE_STATS_COUNTER("disk_cache.hit");
   return cache_entry;
 }
 
 EntryImpl* BackendImpl::CreateEntryImpl(const std::string& key) {
   if (disabled_ || key.empty())
     return NULL;
 
@@ skipping 1367 matching lines @@
   }
 
   // This is an up to date client that will report FirstEviction() data. After
   // that event, start reporting this:
 
   CACHE_UMA(HOURS, "TotalTime", 0, static_cast<int>(total_hours));
   // For any bin in HitRatioByTotalTime, the hit ratio of caches of that total
   // time is the ratio of that bin's total count to the count in the same bin in
   // the TotalTime histogram.
   if (base::RandInt(0, 99) < hit_ratio_as_percentage)
-    CACHE_UMA(HOURS, "HitRatioByTotalTime", 0, implicit_cast<int>(total_hours));
+    CACHE_UMA(HOURS, "HitRatioByTotalTime", 0, static_cast<int>(total_hours));
 
   int64 use_hours = stats_.GetCounter(Stats::LAST_REPORT_TIMER) / 120;
   stats_.SetCounter(Stats::LAST_REPORT_TIMER, stats_.GetCounter(Stats::TIMER));
 
   // We may see users with no use_hours at this point if this is the first time
   // we are running this code.
   if (use_hours)
     use_hours = total_hours - use_hours;
 
   if (!use_hours || !GetEntryCount() || !data_->header.num_bytes)
     return;
 
   CACHE_UMA(HOURS, "UseTime", 0, static_cast<int>(use_hours));
   // For any bin in HitRatioByUseTime, the hit ratio of caches of that use time
   // is the ratio of that bin's total count to the count in the same bin in the
   // UseTime histogram.
   if (base::RandInt(0, 99) < hit_ratio_as_percentage)
-    CACHE_UMA(HOURS, "HitRatioByUseTime", 0, implicit_cast<int>(use_hours));
+    CACHE_UMA(HOURS, "HitRatioByUseTime", 0, static_cast<int>(use_hours));
   CACHE_UMA(PERCENTAGE, "HitRatio", 0, hit_ratio_as_percentage);
 
   int64 trim_rate = stats_.GetCounter(Stats::TRIM_ENTRY) / use_hours;
   CACHE_UMA(COUNTS, "TrimRate", 0, static_cast<int>(trim_rate));
 
   int avg_size = data_->header.num_bytes / GetEntryCount();
   CACHE_UMA(COUNTS, "EntrySize", 0, avg_size);
   CACHE_UMA(COUNTS, "EntriesFull", 0, data_->header.num_entries);
 
   CACHE_UMA(PERCENTAGE, "IndexLoad", 0,
@@ skipping 162 matching lines @@
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 }  // namespace disk_cache