Switch to standard integer types in chrome/browser/, part 3 of 4.

chrome/browser/safe_browsing/safe_browsing_database.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 "chrome/browser/safe_browsing/safe_browsing_database.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process_handle.h"
 #include "base/process/process_metrics.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
+#include "build/build_config.h"
 #include "chrome/browser/safe_browsing/safe_browsing_store_file.h"
 #include "components/safe_browsing_db/prefix_set.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/sha2.h"
 #include "net/base/ip_address_number.h"
 #include "url/gurl.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #endif
@@ skipping 177 matching lines @@
 
 void UpdateChunkRangesForList(
     SafeBrowsingStore* store,
     const std::string& listname,
     std::vector<SBListChunkRanges>* lists) {
   UpdateChunkRanges(store, std::vector<std::string>(1, listname), lists);
 }
 
 // This code always checks for non-zero file size.  This helper makes
 // that less verbose.
-int64 GetFileSizeOrZero(const base::FilePath& file_path) {
-  int64 size_64;
+int64_t GetFileSizeOrZero(const base::FilePath& file_path) {
+  int64_t size_64;
   if (!base::GetFileSize(file_path, &size_64))
     return 0;
   return size_64;
 }
 
 // Helper for PrefixSetContainsUrlHashes().  Returns true if an un-expired match
 // for |full_hash| is found in |cache|, with any matches appended to |results|
 // (true can be returned with zero matches).  |expire_base| is used to check the
 // cache lifetime of matches, expired matches will be discarded from |cache|.
 bool GetCachedFullHash(std::map<SBPrefix, SBCachedFullHashResult>* cache,
@@ skipping 1425 matching lines @@
 void SafeBrowsingDatabaseNew::LoadIpBlacklist(
     const std::vector<SBAddFullHash>& full_hashes) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
   IPBlacklist new_blacklist;
   for (std::vector<SBAddFullHash>::const_iterator it = full_hashes.begin();
        it != full_hashes.end(); ++it) {
     const char* full_hash = it->full_hash.full_hash;
     DCHECK_EQ(crypto::kSHA256Length, arraysize(it->full_hash.full_hash));
     // The format of the IP blacklist is:
-    // SHA-1(IPv6 prefix) + uint8(prefix size) + 11 unused bytes.
+    // SHA-1(IPv6 prefix) + uint8_t(prefix size) + 11 unused bytes.
     std::string hashed_ip_prefix(full_hash, base::kSHA1Length);
-    size_t prefix_size = static_cast<uint8>(full_hash[base::kSHA1Length]);
+    size_t prefix_size = static_cast<uint8_t>(full_hash[base::kSHA1Length]);
     if (prefix_size > kMaxIpPrefixSize || prefix_size < kMinIpPrefixSize) {
       RecordFailure(FAILURE_IP_BLACKLIST_UPDATE_INVALID);
       new_blacklist.clear();  // Load empty blacklist.
       break;
     }
 
     // We precompute the mask for the given subnet size to speed up lookups.
     // Basically we need to create a 16B long string which has the highest
     // |size| bits sets to one.
     std::string mask(net::kIPv6AddressSize, '\0');
@@ skipping 26 matching lines @@
       ->second;
 }
 
 SafeBrowsingDatabaseNew::PrefixGetHashCache*
 SafeBrowsingDatabaseNew::GetUnsynchronizedPrefixGetHashCacheForTesting() {
   return state_manager_.BeginReadTransaction()->prefix_gethash_cache();
 }
 
 void SafeBrowsingDatabaseNew::RecordFileSizeHistogram(
     const base::FilePath& file_path) {
-  const int64 file_size = GetFileSizeOrZero(file_path);
+  const int64_t file_size = GetFileSizeOrZero(file_path);
   const int file_size_kilobytes = static_cast<int>(file_size / 1024);
 
   base::FilePath::StringType filename = file_path.BaseName().value();
 
   // Default to logging DB sizes unless |file_path| points at PrefixSet storage.
   std::string histogram_name("SB2.DatabaseSizeKilobytes");
   if (base::EndsWith(filename, kPrefixSetFileSuffix,
                      base::CompareCase::SENSITIVE)) {
     histogram_name = "SB2.PrefixSetSizeKilobytes";
     // Clear the PrefixSet suffix to have the histogram suffix selector below
@@ skipping 35 matching lines @@
 
   // Histogram properties as in UMA_HISTOGRAM_COUNTS macro.
   base::HistogramBase* histogram_pointer = base::Histogram::FactoryGet(
       histogram_name, 1, 1000000, 50,
       base::HistogramBase::kUmaTargetedHistogramFlag);
 
   histogram_pointer->Add(file_size_kilobytes);
 }
 
 }  // namespace safe_browsing