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

components/history/core/browser/history_service_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.
 
 // History unit tests come in two flavors:
 //
 // 1. The more complicated style is that the unit test creates a full history
 //    service. This spawns a background thread for the history backend, and
 //    all communication is asynchronous. This is useful for testing more
 //    complicated things or end-to-end behavior.
 //
 // 2. The simpler style is to create a history backend on this thread and
 //    access it directly without a HistoryService object. This is much simpler
 //    because communication is synchronous. Generally, sets should go through
 //    the history backend (since there is a lot of logic) but gets can come
 //    directly from the HistoryDatabase. This is because the backend generally
 //    has no logic in the getter except threading stuff, which we don't want
 //    to run.
 
 #include "components/history/core/browser/history_service.h"
 
+#include <stdint.h>
+
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/history/core/browser/history_database_params.h"
 #include "components/history/core/browser/history_db_task.h"
 #include "components/history/core/test/database_test_utils.h"
 #include "components/history/core/test/test_history_database.h"
 #include "sync/api/attachments/attachment_id.h"
 #include "sync/api/fake_sync_change_processor.h"
@@ skipping 178 matching lines @@
   history_service_->AddPage(
       first_redirects.back(), base::Time::Now(),
       reinterpret_cast<ContextID>(1), 0, GURL(), first_redirects,
       ui::PAGE_TRANSITION_LINK, history::SOURCE_BROWSED, true);
 
   // The first page should be added once with a link visit type (because we set
   // LINK when we added the original URL, and a referrer of nowhere (0).
   EXPECT_TRUE(QueryURL(history_service_.get(), first_redirects[0]));
   EXPECT_EQ(1, query_url_row_.visit_count());
   ASSERT_EQ(1U, query_url_visits_.size());
-  int64 first_visit = query_url_visits_[0].visit_id;
+  int64_t first_visit = query_url_visits_[0].visit_id;
   EXPECT_EQ(ui::PAGE_TRANSITION_LINK | ui::PAGE_TRANSITION_CHAIN_START,
             query_url_visits_[0].transition);
   EXPECT_EQ(0, query_url_visits_[0].referring_visit);  // No referrer.
 
   // The second page should be a server redirect type with a referrer of the
   // first page.
   EXPECT_TRUE(QueryURL(history_service_.get(), first_redirects[1]));
   EXPECT_EQ(1, query_url_row_.visit_count());
   ASSERT_EQ(1U, query_url_visits_.size());
-  int64 second_visit = query_url_visits_[0].visit_id;
+  int64_t second_visit = query_url_visits_[0].visit_id;
   EXPECT_EQ(ui::PAGE_TRANSITION_SERVER_REDIRECT | ui::PAGE_TRANSITION_CHAIN_END,
             query_url_visits_[0].transition);
   EXPECT_EQ(first_visit, query_url_visits_[0].referring_visit);
 
   // Check that the redirect finding function successfully reports it.
   saved_redirects_.clear();
   QueryRedirectsFrom(history_service_.get(), first_redirects[0]);
   ASSERT_EQ(1U, saved_redirects_.size());
   EXPECT_EQ(first_redirects[1], saved_redirects_[0]);
 
@@ skipping 378 matching lines @@
 }
 
 // Create a local delete directive and process it while sync is
 // online, and then when offline. The delete directive should be sent to sync,
 // no error should be returned for the first time, and an error should be
 // returned for the second time.
 TEST_F(HistoryServiceTest, ProcessLocalDeleteDirectiveSyncOnline) {
   ASSERT_TRUE(history_service_.get());
 
   const GURL test_url("http://www.google.com/");
-  for (int64 i = 1; i <= 10; ++i) {
+  for (int64_t i = 1; i <= 10; ++i) {
     base::Time t =
         base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(i);
     history_service_->AddPage(test_url, t, NULL, 0, GURL(),
                               history::RedirectList(),
                               ui::PAGE_TRANSITION_LINK,
                               history::SOURCE_BROWSED, false);
   }
 
   sync_pb::HistoryDeleteDirectiveSpecifics delete_directive;
   sync_pb::GlobalIdDirective* global_id_directive =
@@ skipping 25 matching lines @@
   EXPECT_TRUE(err.IsSet());
   EXPECT_EQ(1u, change_processor.changes().size());
 }
 
 // Closure function that runs periodically to check result of delete directive
 // processing. Stop when timeout or processing ends indicated by the creation
 // of sync changes.
 void CheckDirectiveProcessingResult(
     base::Time timeout,
     const syncer::FakeSyncChangeProcessor* change_processor,
-    uint32 num_changes) {
+    uint32_t num_changes) {
   if (base::Time::Now() > timeout ||
       change_processor->changes().size() >= num_changes) {
     return;
   }
 
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&CheckDirectiveProcessingResult, timeout,
                             change_processor, num_changes));
 }
 
 // Create a delete directive for a few specific history entries,
 // including ones that don't exist. The expected entries should be
 // deleted.
 TEST_F(HistoryServiceTest, ProcessGlobalIdDeleteDirective) {
   ASSERT_TRUE(history_service_.get());
   const GURL test_url("http://www.google.com/");
-  for (int64 i = 1; i <= 20; i++) {
+  for (int64_t i = 1; i <= 20; i++) {
     base::Time t =
         base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(i);
     history_service_->AddPage(test_url, t, NULL, 0, GURL(),
                               history::RedirectList(),
                               ui::PAGE_TRANSITION_LINK,
                               history::SOURCE_BROWSED, false);
   }
 
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url));
   EXPECT_EQ(20, query_url_row_.visit_count());
@@ skipping 70 matching lines @@
   EXPECT_EQ(1, syncer::SyncDataRemote(sync_changes[0].sync_data()).GetId());
   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, sync_changes[1].change_type());
   EXPECT_EQ(2, syncer::SyncDataRemote(sync_changes[1].sync_data()).GetId());
 }
 
 // Create delete directives for time ranges.  The expected entries should be
 // deleted.
 TEST_F(HistoryServiceTest, ProcessTimeRangeDeleteDirective) {
   ASSERT_TRUE(history_service_.get());
   const GURL test_url("http://www.google.com/");
-  for (int64 i = 1; i <= 10; ++i) {
+  for (int64_t i = 1; i <= 10; ++i) {
     base::Time t =
         base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(i);
     history_service_->AddPage(test_url, t, NULL, 0, GURL(),
                               history::RedirectList(),
                               ui::PAGE_TRANSITION_LINK,
                               history::SOURCE_BROWSED, false);
   }
 
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url));
   EXPECT_EQ(10, query_url_row_.visit_count());
@@ skipping 56 matching lines @@
   // Expect two sync changes for deleting processed directives.
   const syncer::SyncChangeList& sync_changes = change_processor.changes();
   ASSERT_EQ(2u, sync_changes.size());
   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, sync_changes[0].change_type());
   EXPECT_EQ(1, syncer::SyncDataRemote(sync_changes[0].sync_data()).GetId());
   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, sync_changes[1].change_type());
   EXPECT_EQ(2, syncer::SyncDataRemote(sync_changes[1].sync_data()).GetId());
 }
 
 }  // namespace history