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

chrome/browser/safe_browsing/safe_browsing_store_file_unittest.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_store_file.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/md5.h"
 #include "base/path_service.h"
 #include "base/test/test_simple_task_runner.h"
+#include "build/build_config.h"
 #include "chrome/common/chrome_paths.h"
 #include "components/safe_browsing_db/prefix_set.h"
 #include "components/safe_browsing_db/util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace safe_browsing {
 
 namespace {
 
@@ skipping 78 matching lines @@
     EXPECT_FALSE(store_->CheckSubChunk(kAddChunk1));
     EXPECT_FALSE(store_->CheckSubChunk(kAddChunk2));
 
     PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
 
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
   }
 
   // Manually read the shard stride info from the file.
-  uint32 ReadStride() {
+  uint32_t ReadStride() {
     base::ScopedFILE file(base::OpenFile(filename_, "rb"));
-    const long kOffset = 4 * sizeof(uint32);
+    const long kOffset = 4 * sizeof(uint32_t);
     EXPECT_EQ(fseek(file.get(), kOffset, SEEK_SET), 0);
-    uint32 shard_stride = 0;
+    uint32_t shard_stride = 0;
     EXPECT_EQ(fread(&shard_stride, sizeof(shard_stride), 1, file.get()), 1U);
     return shard_stride;
   }
 
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ScopedTempDir temp_dir_;
   base::FilePath filename_;
   scoped_ptr<SafeBrowsingStoreFile> store_;
   bool corruption_detected_;
 };
@@ skipping 372 matching lines @@
     builder.GetPrefixSetNoHashes()->GetPrefixes(&orig_prefixes);
     EXPECT_GT(orig_prefixes.size(), 0U);
     EXPECT_GT(orig_hashes.size(), 0U);
     EXPECT_FALSE(corruption_detected_);
   }
 
   // Corrupt the store.
   base::ScopedFILE file(base::OpenFile(filename_, "rb+"));
   const long kOffset = 60;
   EXPECT_EQ(fseek(file.get(), kOffset, SEEK_SET), 0);
-  const uint32 kZero = 0;
-  uint32 previous = kZero;
+  const uint32_t kZero = 0;
+  uint32_t previous = kZero;
   EXPECT_EQ(fread(&previous, sizeof(previous), 1, file.get()), 1U);
   EXPECT_NE(previous, kZero);
   EXPECT_EQ(fseek(file.get(), kOffset, SEEK_SET), 0);
   EXPECT_EQ(fwrite(&kZero, sizeof(kZero), 1, file.get()), 1U);
   file.reset();
 
   // Update fails and corruption callback is called.
   std::vector<SBAddFullHash> add_hashes;
   corruption_detected_ = false;
   {
     PrefixSetBuilder builder;
     ASSERT_TRUE(store_->BeginUpdate());
     EXPECT_FALSE(store_->FinishUpdate(&builder, &add_hashes));
     EXPECT_TRUE(corruption_detected_);
   }
 
   // Make it look like there is a lot of add-chunks-seen data.
-  const long kAddChunkCountOffset = 2 * sizeof(int32);
-  const int32 kLargeCount = 1000 * 1000 * 1000;
+  const long kAddChunkCountOffset = 2 * sizeof(int32_t);
+  const int32_t kLargeCount = 1000 * 1000 * 1000;
   file.reset(base::OpenFile(filename_, "rb+"));
   EXPECT_EQ(fseek(file.get(), kAddChunkCountOffset, SEEK_SET), 0);
   EXPECT_EQ(fwrite(&kLargeCount, sizeof(kLargeCount), 1, file.get()), 1U);
   file.reset();
 
   // Detects corruption and fails to even begin the update.
   corruption_detected_ = false;
   EXPECT_FALSE(store_->BeginUpdate());
   EXPECT_TRUE(corruption_detected_);
 }
@@ skipping 131 matching lines @@
   EXPECT_TRUE(store_->GetAddFullHashes(&add_hashes));
   ASSERT_EQ(1U, add_hashes.size());
   EXPECT_EQ(kAddChunk2, add_hashes[0].chunk_id);
   EXPECT_TRUE(SBFullHashEqual(kHash4, add_hashes[0].full_hash));
 }
 
 // Test that the database handles resharding correctly, both when growing and
 // which shrinking.
 TEST_F(SafeBrowsingStoreFileTest, Resharding) {
   // Loop through multiple stride boundaries (1<<32, 1<<31, 1<<30, 1<<29).
-  const uint32 kTargetStride = 1 << 29;
+  const uint32_t kTargetStride = 1 << 29;
 
   // Each chunk will require 8 bytes per prefix, plus 4 bytes for chunk
   // information.  It should be less than |kTargetFootprint| in the
   // implementation, but high enough to keep the number of rewrites modest (to
   // keep the test fast).
   const size_t kPrefixesPerChunk = 10000;
 
-  uint32 shard_stride = 0;
+  uint32_t shard_stride = 0;
   int chunk_id = 1;
 
   // Add a series of chunks, tracking that the stride size changes in a
   // direction appropriate to increasing file size.
   do {
     ASSERT_TRUE(store_->BeginUpdate());
 
     EXPECT_TRUE(store_->BeginChunk());
     store_->SetAddChunk(chunk_id);
     EXPECT_TRUE(store_->CheckAddChunk(chunk_id));
     for (size_t i = 0; i < kPrefixesPerChunk; ++i) {
       EXPECT_TRUE(store_->WriteAddPrefix(chunk_id, static_cast<SBPrefix>(i)));
     }
     EXPECT_TRUE(store_->FinishChunk());
 
     PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     SBAddPrefixes add_prefixes;
     EXPECT_TRUE(store_->GetAddPrefixes(&add_prefixes));
     ASSERT_EQ(chunk_id * kPrefixesPerChunk, add_prefixes.size());
 
     // New stride should be the same, or shifted one right.
-    const uint32 new_shard_stride = ReadStride();
+    const uint32_t new_shard_stride = ReadStride();
     EXPECT_TRUE((new_shard_stride == shard_stride) ||
                 ((new_shard_stride << 1) == shard_stride));
     shard_stride = new_shard_stride;
     ++chunk_id;
   } while (!shard_stride || shard_stride > kTargetStride);
 
   // Guard against writing too many chunks.  If this gets too big, adjust
   // |kPrefixesPerChunk|.
   EXPECT_LT(chunk_id, 20);
 
   // Remove each chunk and check that the stride goes back to 0.
   while (--chunk_id) {
     ASSERT_TRUE(store_->BeginUpdate());
     EXPECT_TRUE(store_->CheckAddChunk(chunk_id));
     EXPECT_FALSE(store_->CheckAddChunk(chunk_id + 1));
     store_->DeleteAddChunk(chunk_id);
 
     PrefixSetBuilder builder;
     std::vector<SBAddFullHash> add_full_hashes_result;
     EXPECT_TRUE(store_->FinishUpdate(&builder, &add_full_hashes_result));
 
     // New stride should be the same, or shifted one left.
-    const uint32 new_shard_stride = ReadStride();
+    const uint32_t new_shard_stride = ReadStride();
     EXPECT_TRUE((new_shard_stride == shard_stride) ||
                 (new_shard_stride == (shard_stride << 1)));
     shard_stride = new_shard_stride;
   }
   EXPECT_EQ(0u, shard_stride);
 }
 
 // Test that a golden v7 file can no longer be read.  All platforms generating
 // v7 files were little-endian, so there is no point to testing this transition
 // if/when a big-endian port is added.
@@ skipping 101 matching lines @@
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSetNoHashes()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(1U, prefixes_result.size());
     EXPECT_EQ(kHash1.prefix, prefixes_result[0]);
     EXPECT_TRUE(add_full_hashes_result.empty());
   }
 }
 #endif
 
 }  // namespace safe_browsing