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

chrome/browser/safe_browsing/safe_browsing_store_unittest.cc

 // Copyright (c) 2011 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 <stdint.h>
+#include <string.h>
+
 #include "chrome/browser/safe_browsing/safe_browsing_store.h"
 #include "components/safe_browsing_db/util.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace safe_browsing {
 
 namespace {
 
 const SBFullHash kHash1 = SBFullHashForString("one");
@@ skipping 19 matching lines @@
 
 SBFullHash ModifyHashAfterPrefix(SBFullHash hash, unsigned char mask) {
   hash.full_hash[sizeof(hash.full_hash) - 1] ^= mask;
   return hash;
 }
 
 void ProcessHelper(SBAddPrefixes* add_prefixes,
                    SBSubPrefixes* sub_prefixes,
                    std::vector<SBAddFullHash>* add_full_hashes,
                    std::vector<SBSubFullHash>* sub_full_hashes,
-                   const base::hash_set<int32>& add_chunks_deleted,
-                   const base::hash_set<int32>& sub_chunks_deleted) {
+                   const base::hash_set<int32_t>& add_chunks_deleted,
+                   const base::hash_set<int32_t>& sub_chunks_deleted) {
   std::sort(add_prefixes->begin(), add_prefixes->end(),
             SBAddPrefixLess<SBAddPrefix,SBAddPrefix>);
   std::sort(sub_prefixes->begin(), sub_prefixes->end(),
             SBAddPrefixLess<SBSubPrefix,SBSubPrefix>);
   std::sort(add_full_hashes->begin(), add_full_hashes->end(),
             SBAddPrefixHashLess<SBAddFullHash,SBAddFullHash>);
   std::sort(sub_full_hashes->begin(), sub_full_hashes->end(),
             SBAddPrefixHashLess<SBSubFullHash,SBSubFullHash>);
 
   SBProcessSubs(add_prefixes, sub_prefixes, add_full_hashes, sub_full_hashes,
@@ skipping 103 matching lines @@
 }
 
 // SBProcessSubs does a lot of iteration, run through empty just to
 // make sure degenerate cases work.
 TEST(SafeBrowsingStoreTest, SBProcessSubsEmpty) {
   SBAddPrefixes add_prefixes;
   std::vector<SBAddFullHash> add_hashes;
   SBSubPrefixes sub_prefixes;
   std::vector<SBSubFullHash> sub_hashes;
 
-  const base::hash_set<int32> no_deletions;
+  const base::hash_set<int32_t> no_deletions;
   SBProcessSubs(&add_prefixes, &sub_prefixes, &add_hashes, &sub_hashes,
                 no_deletions, no_deletions);
   EXPECT_TRUE(add_prefixes.empty());
   EXPECT_TRUE(sub_prefixes.empty());
   EXPECT_TRUE(add_hashes.empty());
   EXPECT_TRUE(sub_hashes.empty());
 }
 
 // Test that subs knock out adds.
 TEST(SafeBrowsingStoreTest, SBProcessSubsKnockout) {
@@ skipping 25 matching lines @@
   // Subs with no corresponding add.  Both items should be retained.
   sub_hashes.push_back(SBSubFullHash(kSubChunk3, kAddChunk3, kHash7));
   sub_prefixes.push_back(SBSubPrefix(kSubChunk4, kAddChunk4, kHash3.prefix));
 
   // Add hashes with the same prefix, with a sub that will knock one of them
   // out.
   add_hashes.push_back(SBAddFullHash(kAddChunk5, kHash4));
   add_hashes.push_back(SBAddFullHash(kAddChunk5, kHash4mod));
   sub_hashes.push_back(SBSubFullHash(kSubChunk5, kAddChunk5, kHash4mod));
 
-  const base::hash_set<int32> no_deletions;
+  const base::hash_set<int32_t> no_deletions;
   ProcessHelper(&add_prefixes, &sub_prefixes, &add_hashes, &sub_hashes,
                 no_deletions, no_deletions);
 
   ASSERT_EQ(1U, add_prefixes.size());
   EXPECT_EQ(kAddChunk7, add_prefixes[0].chunk_id);
   EXPECT_EQ(kHash2.prefix, add_prefixes[0].prefix);
 
   ASSERT_EQ(2U, add_hashes.size());
   EXPECT_EQ(kAddChunk5, add_hashes[0].chunk_id);
   EXPECT_TRUE(SBFullHashEqual(kHash4, add_hashes[0].full_hash));
@@ skipping 34 matching lines @@
 
   // Adds with no corresponding sub.  Both items should be retained.
   add_hashes.push_back(SBAddFullHash(kAddChunk1, kHash6));
   add_prefixes.push_back(SBAddPrefix(kAddChunk1, kHash2.prefix));
 
   // Subs with no corresponding add.  Both items should be retained.
   sub_hashes.push_back(SBSubFullHash(kSubChunk1, kAddChunk1, kHash7));
   sub_prefixes.push_back(SBSubPrefix(kSubChunk1, kAddChunk1, kHash3.prefix));
 
   // Subs apply before being deleted.
-  const base::hash_set<int32> no_deletions;
-  base::hash_set<int32> sub_deletions;
+  const base::hash_set<int32_t> no_deletions;
+  base::hash_set<int32_t> sub_deletions;
   sub_deletions.insert(kSubChunk1);
   ProcessHelper(&add_prefixes, &sub_prefixes, &add_hashes, &sub_hashes,
                 no_deletions, sub_deletions);
 
   ASSERT_EQ(1U, add_prefixes.size());
   EXPECT_EQ(kAddChunk1, add_prefixes[0].chunk_id);
   EXPECT_EQ(kHash2.prefix, add_prefixes[0].prefix);
 
   ASSERT_EQ(1U, add_hashes.size());
   EXPECT_EQ(kAddChunk1, add_hashes[0].chunk_id);
   EXPECT_TRUE(SBFullHashEqual(kHash6, add_hashes[0].full_hash));
 
   EXPECT_TRUE(sub_prefixes.empty());
   EXPECT_TRUE(sub_hashes.empty());
 
   // Delete the adds, also.
-  base::hash_set<int32> add_deletions;
+  base::hash_set<int32_t> add_deletions;
   add_deletions.insert(kAddChunk1);
   ProcessHelper(&add_prefixes, &sub_prefixes, &add_hashes, &sub_hashes,
                 add_deletions, no_deletions);
 
   EXPECT_TRUE(add_prefixes.empty());
   EXPECT_TRUE(add_hashes.empty());
   EXPECT_TRUE(sub_prefixes.empty());
   EXPECT_TRUE(sub_hashes.empty());
 }
 
 TEST(SafeBrowsingStoreTest, Y2K38) {
   const base::Time now = base::Time::Now();
   const base::Time future = now + base::TimeDelta::FromDays(3*365);
 
   // TODO: Fix file format before 2035.
-  EXPECT_GT(static_cast<int32>(future.ToTimeT()), 0)
-    << " (int32)time_t is running out.";
+  EXPECT_GT(static_cast<int32_t>(future.ToTimeT()), 0)
+      << " (int32_t)time_t is running out.";
 }
 
 }  // namespace safe_browsing