Type conversion fixes, components/ edition.

components/precache/core/precache_database.cc

 // Copyright 2013 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 "components/precache/core/precache_database.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 82 matching lines @@
     // Since the precache came from the cache, and there's no entry in the URL
     // table for the URL, this means that the resource was already in the cache
     // because of user browsing. Thus, this precache had no effect, so ignore
     // it.
     return;
   }
 
   if (!was_cached) {
     // The precache only counts as overhead if it was downloaded over the
     // network.
-    UMA_HISTOGRAM_COUNTS("Precache.DownloadedPrecacheMotivated", size);
+    UMA_HISTOGRAM_COUNTS("Precache.DownloadedPrecacheMotivated",
+                         static_cast<base::HistogramBase::Sample>(size));
   }
 
   // Use the URL table to keep track of URLs that are in the cache thanks to
   // precaching. If a row for the URL already exists, than update the timestamp
   // to |fetch_time|.
   buffered_writes_.push_back(
       base::Bind(&PrecacheURLTable::AddURL,
                  base::Unretained(&precache_url_table_), url, fetch_time));
   buffered_urls_.insert(url.spec());
   MaybePostFlush();
@@ skipping 12 matching lines @@
     // If the URL for this fetch is in the write buffer, then flush the write
     // buffer.
     Flush();
   }
 
   if (was_cached && !precache_url_table_.HasURL(url)) {
     // Ignore cache hits that precache can't take credit for.
     return;
   }
 
+  base::HistogramBase::Sample size_sample =
+      static_cast<base::HistogramBase::Sample>(size);
   if (!was_cached) {
     // The fetch was served over the network during user browsing, so count it
     // as downloaded non-precache bytes.
-    UMA_HISTOGRAM_COUNTS("Precache.DownloadedNonPrecache", size);
+    UMA_HISTOGRAM_COUNTS("Precache.DownloadedNonPrecache", size_sample);
     if (is_connection_cellular) {
-      UMA_HISTOGRAM_COUNTS("Precache.DownloadedNonPrecache.Cellular", size);
+      UMA_HISTOGRAM_COUNTS("Precache.DownloadedNonPrecache.Cellular",
+                           size_sample);
     }
   } else {
     // The fetch was served from the cache, and since there's an entry for this
     // URL in the URL table, this means that the resource was served from the
     // cache only because precaching put it there. Thus, precaching was helpful,
     // so count the fetch as saved bytes.
-    UMA_HISTOGRAM_COUNTS("Precache.Saved", size);
+    UMA_HISTOGRAM_COUNTS("Precache.Saved", size_sample);
     if (is_connection_cellular) {
-      UMA_HISTOGRAM_COUNTS("Precache.Saved.Cellular", size);
+      UMA_HISTOGRAM_COUNTS("Precache.Saved.Cellular", size_sample);
     }
   }
 
   // Since the resource has been fetched during user browsing, remove any record
   // of that URL having been precached from the URL table, if any exists.
   // The current fetch would have put this resource in the cache regardless of
   // whether or not it was previously precached, so delete any record of that
   // URL having been precached from the URL table.
   buffered_writes_.push_back(
       base::Bind(&PrecacheURLTable::DeleteURL,
@@ skipping 57 matching lines @@
   // database writes can be buffered up and flushed together in the same
   // transaction.
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, base::Bind(&PrecacheDatabase::PostedFlush,
                             scoped_refptr<PrecacheDatabase>(this)),
       base::TimeDelta::FromSeconds(1));
   is_flush_posted_ = true;
 }
 
 }  // namespace precache