Switch to standard integer types in components/, part 4 of 4.

components/visitedlink/test/visitedlink_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 <stddef.h>
+#include <stdint.h>
+
 #include <cstdio>
 #include <string>
 #include <vector>
 
 #include "base/files/file_util.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "base/process/process_handle.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/visitedlink/browser/visitedlink_delegate.h"
 #include "components/visitedlink/browser/visitedlink_event_listener.h"
 #include "components/visitedlink/browser/visitedlink_master.h"
@@ skipping 232 matching lines @@
 
   for (int i = 0; i < g_test_count; i++)
     master_->AddURL(TestURL(i));
 
   // Test that the database was written properly
   Reload();
 }
 
 // Checks that we can delete things properly when there are collisions.
 TEST_F(VisitedLinkTest, Delete) {
-  static const int32 kInitialSize = 17;
+  static const int32_t kInitialSize = 17;
   ASSERT_TRUE(InitVisited(kInitialSize, true, true));
 
   // Add a cluster from 14-17 wrapping around to 0. These will all hash to the
   // same value.
   const VisitedLinkCommon::Fingerprint kFingerprint0 = kInitialSize * 0 + 14;
   const VisitedLinkCommon::Fingerprint kFingerprint1 = kInitialSize * 1 + 14;
   const VisitedLinkCommon::Fingerprint kFingerprint2 = kInitialSize * 2 + 14;
   const VisitedLinkCommon::Fingerprint kFingerprint3 = kInitialSize * 3 + 14;
   const VisitedLinkCommon::Fingerprint kFingerprint4 = kInitialSize * 4 + 14;
   master_->AddFingerprint(kFingerprint0, false);  // @14
@@ skipping 22 matching lines @@
         "Hash table has values in it.";
 }
 
 // When we delete more than kBigDeleteThreshold we trigger different behavior
 // where the entire file is rewritten.
 TEST_F(VisitedLinkTest, BigDelete) {
   ASSERT_TRUE(InitVisited(16381, true, true));
 
   // Add the base set of URLs that won't be deleted.
   // Reload() will test for these.
-  for (int32 i = 0; i < g_test_count; i++)
+  for (int32_t i = 0; i < g_test_count; i++)
     master_->AddURL(TestURL(i));
 
   // Add more URLs than necessary to trigger this case.
   const int kTestDeleteCount = VisitedLinkMaster::kBigDeleteThreshold + 2;
   URLs urls_to_delete;
-  for (int32 i = g_test_count; i < g_test_count + kTestDeleteCount; i++) {
+  for (int32_t i = g_test_count; i < g_test_count + kTestDeleteCount; i++) {
     GURL url(TestURL(i));
     master_->AddURL(url);
     urls_to_delete.push_back(url);
   }
 
   TestURLIterator iterator(urls_to_delete);
   master_->DeleteURLs(&iterator);
   master_->DebugValidate();
 
   Reload();
@@ skipping 39 matching lines @@
   master_->DebugValidate();
   EXPECT_EQ(0, master_->GetUsedCount());
   for (int i = 0; i < g_test_count; i++)
     EXPECT_FALSE(master_->IsVisited(TestURL(i)));
 }
 
 // This tests that the master correctly resizes its tables when it gets too
 // full, notifies its slaves of the change, and updates the disk.
 TEST_F(VisitedLinkTest, Resizing) {
   // Create a very small database.
-  const int32 initial_size = 17;
+  const int32_t initial_size = 17;
   ASSERT_TRUE(InitVisited(initial_size, true, true));
 
   // ...and a slave
   VisitedLinkSlave slave;
   base::SharedMemoryHandle new_handle = base::SharedMemory::NULLHandle();
   master_->shared_memory()->ShareToProcess(
       base::GetCurrentProcessHandle(), &new_handle);
   slave.OnUpdateVisitedLinks(new_handle);
   g_slaves.push_back(&slave);
 
-  int32 used_count = master_->GetUsedCount();
+  int32_t used_count = master_->GetUsedCount();
   ASSERT_EQ(used_count, 0);
 
   for (int i = 0; i < g_test_count; i++) {
     master_->AddURL(TestURL(i));
     used_count = master_->GetUsedCount();
     ASSERT_EQ(i + 1, used_count);
   }
 
   // Verify that the table got resized sufficiently.
-  int32 table_size;
+  int32_t table_size;
   VisitedLinkCommon::Fingerprint* table;
   master_->GetUsageStatistics(&table_size, &table);
   used_count = master_->GetUsedCount();
   ASSERT_GT(table_size, used_count);
   ASSERT_EQ(used_count, g_test_count) <<
                 "table count doesn't match the # of things we added";
 
   // Verify that the slave got the resize message and has the same
   // table information.
-  int32 child_table_size;
+  int32_t child_table_size;
   VisitedLinkCommon::Fingerprint* child_table;
   slave.GetUsageStatistics(&child_table_size, &child_table);
   ASSERT_EQ(table_size, child_table_size);
-  for (int32 i = 0; i < table_size; i++) {
+  for (int32_t i = 0; i < table_size; i++) {
     ASSERT_EQ(table[i], child_table[i]);
   }
 
   master_->DebugValidate();
   g_slaves.clear();
 
   // This tests that the file is written correctly by reading it in using
   // a new database.
   Reload();
 }
@@ skipping 168 matching lines @@
   void WidgetHidden() override { widgets_--; }
   int VisibleWidgetCount() const override { return widgets_; }
 
   bool Send(IPC::Message* msg) override {
     VisitCountingContext* counting_context =
         static_cast<VisitCountingContext*>(
             GetBrowserContext());
 
     if (msg->type() == ChromeViewMsg_VisitedLink_Add::ID) {
       base::PickleIterator iter(*msg);
-      std::vector<uint64> fingerprints;
+      std::vector<uint64_t> fingerprints;
       CHECK(IPC::ReadParam(msg, &iter, &fingerprints));
       counting_context->CountAddEvent(fingerprints.size());
     } else if (msg->type() == ChromeViewMsg_VisitedLink_Reset::ID) {
       base::PickleIterator iter(*msg);
       bool invalidate_hashes;
       CHECK(IPC::ReadParam(msg, &iter, &invalidate_hashes));
       if (invalidate_hashes)
         counting_context->CountCompletelyResetEvent();
       else
         counting_context->CountResetEvent();
@@ skipping 270 matching lines @@
   // Waiting complete loading the table.
   content::RunAllBlockingPoolTasksUntilIdle();
 
   WaitForCoalescence();
 
   // After load table expect completely reset event.
   EXPECT_EQ(1, context()->completely_reset_event_count());
 }
 
 }  // namespace visitedlink