Switch to standard integer types in sync/.

sync/engine/syncer_unittest.cc

 // Copyright 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.
 //
 // Syncer unit tests. Unfortunately a lot of these tests
 // are outdated and need to be reworked and updated.
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <limits>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "sync/engine/backoff_delay_provider.h"
 #include "sync/engine/get_commit_ids.h"
 #include "sync/engine/net/server_connection_manager.h"
 #include "sync/engine/sync_scheduler_impl.h"
@@ skipping 464 matching lines @@
   }
 
   const std::string local_cache_guid() {
     return directory()->cache_guid();
   }
 
   const std::string foreign_cache_guid() {
     return "kqyg7097kro6GSUod+GSg==";
   }
 
-  int64 CreateUnsyncedDirectory(const string& entry_name,
-      const string& idstring) {
+  int64_t CreateUnsyncedDirectory(const string& entry_name,
+                                  const string& idstring) {
     return CreateUnsyncedDirectory(entry_name,
         syncable::Id::CreateFromServerId(idstring));
   }
 
-  int64 CreateUnsyncedDirectory(const string& entry_name,
-      const syncable::Id& id) {
+  int64_t CreateUnsyncedDirectory(const string& entry_name,
+                                  const syncable::Id& id) {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(
         &wtrans, CREATE, BOOKMARKS, wtrans.root_id(), entry_name);
     EXPECT_TRUE(entry.good());
     entry.PutIsUnsynced(true);
     entry.PutIsDir(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutBaseVersion(id.ServerKnows() ? 1 : 0);
     entry.PutId(id);
     return entry.GetMetahandle();
@@ skipping 1404 matching lines @@
                         wtrans.root_id(),
                         parent_name);
     ASSERT_TRUE(parent.good());
     parent.PutIsUnsynced(true);
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutId(parent_id_);
     parent.PutBaseVersion(1);
   }
 
-  int64 meta_handle_b;
+  int64_t meta_handle_b;
   const Id parent2_local_id = ids_.NewLocalId();
   const Id child_local_id = ids_.NewLocalId();
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent2(&wtrans, CREATE, BOOKMARKS, parent_id_, parent2_name);
     ASSERT_TRUE(parent2.good());
     parent2.PutIsUnsynced(true);
     parent2.PutIsDir(true);
     parent2.PutSpecifics(DefaultBookmarkSpecifics());
 
@@ skipping 51 matching lines @@
   mock_server_->AddUpdateDirectory(
       2, 0, std::string(), 2, 20, foreign_cache_guid(), "-2");
   mock_server_->SetLastUpdateDeleted();
   EXPECT_TRUE(SyncShareNudge());
 }
 
 TEST_F(SyncerTest, TestBasicUpdate) {
   string id = "some_id";
   string parent_id = "0";
   string name = "in_root";
-  int64 version = 10;
-  int64 timestamp = 10;
+  int64_t version = 10;
+  int64_t timestamp = 10;
   mock_server_->AddUpdateDirectory(id, parent_id, name, version, timestamp,
                                    foreign_cache_guid(), "-1");
 
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     Entry entry(&trans, GET_BY_ID,
                syncable::Id::CreateFromServerId("some_id"));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.GetIsDir());
@@ skipping 151 matching lines @@
 
   EXPECT_EQ(
       4,
       GetUpdateCounters(BOOKMARKS).num_hierarchy_conflict_application_failures);
 }
 
 // A commit with a lost response produces an update that has to be reunited with
 // its parent.
 TEST_F(SyncerTest, CommitReuniteUpdateAdjustsChildren) {
   // Create a folder in the root.
-  int64 metahandle_folder;
+  int64_t metahandle_folder;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(
         &trans, CREATE, BOOKMARKS, trans.root_id(), "new_folder");
     ASSERT_TRUE(entry.good());
     entry.PutIsDir(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutIsUnsynced(true);
     metahandle_folder = entry.GetMetahandle();
   }
 
   // Verify it and pull the ID out of the folder.
   syncable::Id folder_id;
-  int64 metahandle_entry;
+  int64_t metahandle_entry;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_folder);
     ASSERT_TRUE(entry.good());
     folder_id = entry.GetId();
     ASSERT_TRUE(!folder_id.ServerKnows());
   }
 
   // Create an entry in the newly created folder.
   {
@@ skipping 11 matching lines @@
     Entry entry(&trans, syncable::GET_BY_HANDLE, metahandle_entry);
     ASSERT_TRUE(entry.good());
     EXPECT_EQ(folder_id, entry.GetParentId());
     EXPECT_EQ("new_entry", entry.GetNonUniqueName());
     entry_id = entry.GetId();
     EXPECT_TRUE(!entry_id.ServerKnows());
     VerifyTestDataInEntry(&trans, &entry);
   }
 
   // Now, to emulate a commit response failure, we just don't commit it.
-  int64 new_version = 150;  // any larger value.
-  int64 timestamp = 20;  // arbitrary value.
+  int64_t new_version = 150;  // any larger value.
+  int64_t timestamp = 20;     // arbitrary value.
   syncable::Id new_folder_id =
       syncable::Id::CreateFromServerId("folder_server_id");
 
   // The following update should cause the folder to both apply the update, as
   // well as reassociate the id.
   mock_server_->AddUpdateDirectory(new_folder_id, root_id_,
       "new_folder", new_version, timestamp,
       local_cache_guid(), folder_id.GetServerId());
 
   // We don't want it accidentally committed, just the update applied.
@@ skipping 23 matching lines @@
     EXPECT_EQ(new_folder_id, entry.GetParentId());
     EXPECT_TRUE(!entry.GetId().ServerKnows());
     VerifyTestDataInEntry(&trans, &entry);
   }
 }
 
 // A commit with a lost response produces an update that has to be reunited with
 // its parent.
 TEST_F(SyncerTest, CommitReuniteUpdate) {
   // Create an entry in the root.
-  int64 entry_metahandle;
+  int64_t entry_metahandle;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "new_entry");
     ASSERT_TRUE(entry.good());
     entry_metahandle = entry.GetMetahandle();
     WriteTestDataToEntry(&trans, &entry);
   }
 
   // Verify it and pull the ID out.
   syncable::Id entry_id;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry entry(&trans, GET_BY_HANDLE, entry_metahandle);
     ASSERT_TRUE(entry.good());
     entry_id = entry.GetId();
     EXPECT_TRUE(!entry_id.ServerKnows());
     VerifyTestDataInEntry(&trans, &entry);
   }
 
   // Now, to emulate a commit response failure, we just don't commit it.
-  int64 new_version = 150;  // any larger value.
-  int64 timestamp = 20;  // arbitrary value.
+  int64_t new_version = 150;  // any larger value.
+  int64_t timestamp = 20;     // arbitrary value.
   syncable::Id new_entry_id = syncable::Id::CreateFromServerId("server_id");
 
   // Generate an update from the server with a relevant ID reassignment.
   mock_server_->AddUpdateBookmark(new_entry_id, root_id_,
       "new_entry", new_version, timestamp,
       local_cache_guid(), entry_id.GetServerId());
 
   // We don't want it accidentally committed, just the update applied.
   mock_server_->set_conflict_all_commits(true);
 
   // Alright! Apply that update!
   EXPECT_TRUE(SyncShareNudge());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, entry_metahandle);
     ASSERT_TRUE(entry.good());
     EXPECT_EQ(new_version, entry.GetBaseVersion());
     EXPECT_EQ(new_entry_id, entry.GetId());
     EXPECT_EQ("new_entry", entry.GetNonUniqueName());
   }
 }
 
 // A commit with a lost response must work even if the local entry was deleted
 // before the update is applied. We should not duplicate the local entry in
 // this case, but just create another one alongside. We may wish to examine
 // this behavior in the future as it can create hanging uploads that never
 // finish, that must be cleaned up on the server side after some time.
 TEST_F(SyncerTest, CommitReuniteUpdateDoesNotChokeOnDeletedLocalEntry) {
   // Create a entry in the root.
-  int64 entry_metahandle;
+  int64_t entry_metahandle;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "new_entry");
     ASSERT_TRUE(entry.good());
     entry_metahandle = entry.GetMetahandle();
     WriteTestDataToEntry(&trans, &entry);
   }
   // Verify it and pull the ID out.
   syncable::Id entry_id;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, entry_metahandle);
     ASSERT_TRUE(entry.good());
     entry_id = entry.GetId();
     EXPECT_TRUE(!entry_id.ServerKnows());
     VerifyTestDataInEntry(&trans, &entry);
   }
 
   // Now, to emulate a commit response failure, we just don't commit it.
-  int64 new_version = 150;  // any larger value.
-  int64 timestamp = 20;  // arbitrary value.
+  int64_t new_version = 150;  // any larger value.
+  int64_t timestamp = 20;     // arbitrary value.
   syncable::Id new_entry_id = syncable::Id::CreateFromServerId("server_id");
 
   // Generate an update from the server with a relevant ID reassignment.
   mock_server_->AddUpdateBookmark(new_entry_id, root_id_,
       "new_entry", new_version, timestamp,
       local_cache_guid(), entry_id.GetServerId());
 
   // We don't want it accidentally committed, just the update applied.
   mock_server_->set_conflict_all_commits(true);
 
@@ skipping 177 matching lines @@
 }
 
 TEST_F(SyncerTest, NegativeIDInUpdate) {
   mock_server_->AddUpdateBookmark(-10, 0, "bad", 40, 40,
                                   foreign_cache_guid(), "-100");
   EXPECT_TRUE(SyncShareNudge());
   // The negative id would make us CHECK!
 }
 
 TEST_F(SyncerTest, UnappliedUpdateOnCreatedItemItemDoesNotCrash) {
-  int64 metahandle_fred;
+  int64_t metahandle_fred;
   syncable::Id orig_id;
   {
     // Create an item.
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry fred_match(&trans, CREATE, BOOKMARKS, trans.root_id(),
                             "fred_match");
     ASSERT_TRUE(fred_match.good());
     metahandle_fred = fred_match.GetMetahandle();
     orig_id = fred_match.GetId();
     WriteTestDataToEntry(&trans, &fred_match);
@@ skipping 62 matching lines @@
 
   // Only one entry, since we just overwrite one.
   EXPECT_EQ(1u, children.size());
 }
 
 // We got this repro case when someone was editing bookmarks while sync was
 // occuring. The entry had changed out underneath the user.
 TEST_F(SyncerTest, CommitsUpdateDoesntAlterEntry) {
   const base::Time& test_time = ProtoTimeToTime(123456);
   syncable::Id local_id;
-  int64 entry_metahandle;
+  int64_t entry_metahandle;
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&wtrans, CREATE, BOOKMARKS, root_id_, "Pete");
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetId().ServerKnows());
     local_id = entry.GetId();
     entry.PutIsDir(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutIsUnsynced(true);
     entry.PutMtime(test_time);
     entry_metahandle = entry.GetMetahandle();
   }
   EXPECT_TRUE(SyncShareNudge());
   syncable::Id id;
-  int64 version;
+  int64_t version;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, syncable::GET_BY_HANDLE, entry_metahandle);
     ASSERT_TRUE(entry.good());
     id = entry.GetId();
     EXPECT_TRUE(id.ServerKnows());
     version = entry.GetBaseVersion();
   }
   sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
   update->set_originator_cache_guid(local_cache_guid());
@@ skipping 53 matching lines @@
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_TRUE(SyncShareNudge());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Directory::Metahandles children;
     directory()->GetChildHandlesById(&trans, root_id_, &children);
     EXPECT_EQ(1u, children.size());
     directory()->GetChildHandlesById(&trans, parent_id, &children);
     EXPECT_EQ(1u, children.size());
-    std::vector<int64> unapplied;
+    std::vector<int64_t> unapplied;
     directory()->GetUnappliedUpdateMetaHandles(&trans, all_types, &unapplied);
     EXPECT_EQ(0u, unapplied.size());
     syncable::Directory::Metahandles unsynced;
     directory()->GetUnsyncedMetaHandles(&trans, &unsynced);
     EXPECT_EQ(0u, unsynced.size());
   }
 }
 
 TEST_F(SyncerTest, CommittingNewDeleted) {
   {
@@ skipping 39 matching lines @@
 // Unexpected error during sync if we:
 //   make a new folder bob
 //   wait for sync
 //   make a new folder fred
 //   move bob into fred
 //   remove bob
 //   remove fred
 // if no syncing occured midway, bob will have an illegal parent
 TEST_F(SyncerTest, DeletingEntryInFolder) {
   // This test is a little fake.
-  int64 existing_metahandle;
+  int64_t existing_metahandle;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "existing");
     ASSERT_TRUE(entry.good());
     entry.PutIsDir(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutIsUnsynced(true);
     existing_metahandle = entry.GetMetahandle();
   }
   EXPECT_TRUE(SyncShareNudge());
@@ skipping 55 matching lines @@
   }
 
   EXPECT_TRUE(SyncShareNudge());
   // Since the hierarchy isn't really changed (the type has flat hierarchy)
   // this conflict must be discarded.
   EXPECT_EQ(0, session_->status_controller().num_local_overwrites());
   EXPECT_EQ(0, session_->status_controller().num_server_overwrites());
 }
 
 TEST_F(SyncerTest, DeletingEntryWithLocalEdits) {
-  int64 newfolder_metahandle;
+  int64_t newfolder_metahandle;
 
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10,
                                    foreign_cache_guid(), "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry newfolder(
         &trans, CREATE, BOOKMARKS, ids_.FromNumber(1), "local");
     ASSERT_TRUE(newfolder.good());
     newfolder.PutIsUnsynced(true);
@@ skipping 80 matching lines @@
     ASSERT_TRUE(id3.good());
     EXPECT_EQ("bob", id3.GetNonUniqueName());
     EXPECT_EQ(root_id_, id3.GetParentId());
   }
 }
 
 // Committing more than kDefaultMaxCommitBatchSize items requires that
 // we post more than one commit command to the server.  This test makes
 // sure that scenario works as expected.
 TEST_F(SyncerTest, CommitManyItemsInOneGo_Success) {
-  uint32 num_batches = 3;
-  uint32 items_to_commit = kDefaultMaxCommitBatchSize * num_batches;
+  uint32_t num_batches = 3;
+  uint32_t items_to_commit = kDefaultMaxCommitBatchSize * num_batches;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    for (uint32 i = 0; i < items_to_commit; i++) {
+    for (uint32_t i = 0; i < items_to_commit; i++) {
       string nameutf8 = base::UintToString(i);
       string name(nameutf8.begin(), nameutf8.end());
       MutableEntry e(&trans, CREATE, BOOKMARKS, trans.root_id(), name);
       e.PutIsUnsynced(true);
       e.PutIsDir(true);
       e.PutSpecifics(DefaultBookmarkSpecifics());
     }
   }
   ASSERT_EQ(items_to_commit, directory()->unsynced_entity_count());
 
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(num_batches, mock_server_->commit_messages().size());
   EXPECT_EQ(0, directory()->unsynced_entity_count());
 }
 
 // Test that a single failure to contact the server will cause us to exit the
 // commit loop immediately.
 TEST_F(SyncerTest, CommitManyItemsInOneGo_PostBufferFail) {
-  uint32 num_batches = 3;
-  uint32 items_to_commit = kDefaultMaxCommitBatchSize * num_batches;
+  uint32_t num_batches = 3;
+  uint32_t items_to_commit = kDefaultMaxCommitBatchSize * num_batches;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    for (uint32 i = 0; i < items_to_commit; i++) {
+    for (uint32_t i = 0; i < items_to_commit; i++) {
       string nameutf8 = base::UintToString(i);
       string name(nameutf8.begin(), nameutf8.end());
       MutableEntry e(&trans, CREATE, BOOKMARKS, trans.root_id(), name);
       e.PutIsUnsynced(true);
       e.PutIsDir(true);
       e.PutSpecifics(DefaultBookmarkSpecifics());
     }
   }
   ASSERT_EQ(items_to_commit, directory()->unsynced_entity_count());
 
   // The second commit should fail.  It will be preceded by one successful
   // GetUpdate and one succesful commit.
   mock_server_->FailNthPostBufferToPathCall(3);
   EXPECT_FALSE(SyncShareNudge());
 
   EXPECT_EQ(1U, mock_server_->commit_messages().size());
   EXPECT_EQ(SYNC_SERVER_ERROR,
             session_->status_controller().model_neutral_state().commit_result);
   EXPECT_EQ(items_to_commit - kDefaultMaxCommitBatchSize,
             directory()->unsynced_entity_count());
 }
 
 // Test that a single conflict response from the server will cause us to exit
 // the commit loop immediately.
 TEST_F(SyncerTest, CommitManyItemsInOneGo_CommitConflict) {
-  uint32 num_batches = 2;
-  uint32 items_to_commit = kDefaultMaxCommitBatchSize * num_batches;
+  uint32_t num_batches = 2;
+  uint32_t items_to_commit = kDefaultMaxCommitBatchSize * num_batches;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    for (uint32 i = 0; i < items_to_commit; i++) {
+    for (uint32_t i = 0; i < items_to_commit; i++) {
       string nameutf8 = base::UintToString(i);
       string name(nameutf8.begin(), nameutf8.end());
       MutableEntry e(&trans, CREATE, BOOKMARKS, trans.root_id(), name);
       e.PutIsUnsynced(true);
       e.PutIsDir(true);
       e.PutSpecifics(DefaultBookmarkSpecifics());
     }
   }
   ASSERT_EQ(items_to_commit, directory()->unsynced_entity_count());
 
@@ skipping 226 matching lines @@
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateDirectory(2, 0, "bob", 2, 20,
                                    foreign_cache_guid(), "-2");
   EXPECT_TRUE(SyncShareNudge());  // USED TO CAUSE AN ASSERT
 }
 
 TEST_F(SyncerTest, NewEntryAndAlteredServerEntrySharePath) {
   mock_server_->AddUpdateBookmark(1, 0, "Foo.htm", 10, 10,
                                   foreign_cache_guid(), "-1");
   EXPECT_TRUE(SyncShareNudge());
-  int64 local_folder_handle;
+  int64_t local_folder_handle;
   syncable::Id local_folder_id;
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry new_entry(
         &wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "Bar.htm");
     ASSERT_TRUE(new_entry.good());
     local_folder_id = new_entry.GetId();
     local_folder_handle = new_entry.GetMetahandle();
     new_entry.PutIsUnsynced(true);
     new_entry.PutSpecifics(DefaultBookmarkSpecifics());
@@ skipping 46 matching lines @@
         server.GetSpecifics().bookmark().url());
   }
 }
 
 // Same as NewEntryAnddServerEntrySharePath, but using the old-style protocol.
 TEST_F(SyncerTest, NewEntryAndAlteredServerEntrySharePath_OldBookmarksProto) {
   mock_server_->set_use_legacy_bookmarks_protocol(true);
   mock_server_->AddUpdateBookmark(1, 0, "Foo.htm", 10, 10,
                                   foreign_cache_guid(), "-1");
   EXPECT_TRUE(SyncShareNudge());
-  int64 local_folder_handle;
+  int64_t local_folder_handle;
   syncable::Id local_folder_id;
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry new_entry(
         &wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "Bar.htm");
     ASSERT_TRUE(new_entry.good());
     local_folder_id = new_entry.GetId();
     local_folder_handle = new_entry.GetMetahandle();
     new_entry.PutIsUnsynced(true);
     new_entry.PutSpecifics(DefaultBookmarkSpecifics());
@@ skipping 125 matching lines @@
     ASSERT_TRUE(B.good());
     EXPECT_FALSE(B.GetIsUnsynced());
     EXPECT_FALSE(B.GetIsUnappliedUpdate());
   }
 }
 
 // When we undelete an entity as a result of conflict resolution, we reuse the
 // existing server id and preserve the old version, simply updating the server
 // version with the new non-deleted entity.
 TEST_F(SyncerTest, ResolveWeWroteTheyDeleted) {
-  int64 bob_metahandle;
+  int64_t bob_metahandle;
 
   mock_server_->AddUpdateBookmark(1, 0, "bob", 1, 10,
                                   foreign_cache_guid(), "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob_metahandle = bob.GetMetahandle();
     WriteTestDataToEntry(&trans, &bob);
@@ skipping 248 matching lines @@
   mock_server_->AddUpdateDirectory(1, 0, "foo", 1, 1,
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateDirectory(2, 1, "bar", 1, 2,
                                    foreign_cache_guid(), "-2");
   EXPECT_TRUE(SyncShareNudge());
   mock_server_->AddUpdateDirectory(2, 1, "bar", 2, 3,
                                    foreign_cache_guid(), "-2");
   mock_server_->SetLastUpdateDeleted();
   EXPECT_TRUE(SyncShareNudge());
 
-  int64 metahandle;
+  int64_t metahandle;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.GetIsDel());
     metahandle = entry.GetMetahandle();
   }
   mock_server_->AddUpdateDirectory(1, 0, "foo", 2, 4,
                                    foreign_cache_guid(), "-1");
   mock_server_->SetLastUpdateDeleted();
@@ skipping 73 matching lines @@
 
     Entry in_in_root(&trans, GET_BY_ID, in_in_root_id);
     ASSERT_TRUE(in_in_root.good());
     EXPECT_EQ("in_in_root_name", in_in_root.GetNonUniqueName());
     EXPECT_EQ(in_root_id, in_in_root.GetParentId());
   }
 }
 
 TEST_F(SyncerTest, DirectoryCommitTest) {
   syncable::Id in_root_id, in_dir_id;
-  int64 foo_metahandle;
-  int64 bar_metahandle;
+  int64_t foo_metahandle;
+  int64_t bar_metahandle;
 
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, root_id_, "foo");
     ASSERT_TRUE(parent.good());
     parent.PutIsUnsynced(true);
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     in_root_id = parent.GetId();
     foo_metahandle = parent.GetMetahandle();
@@ skipping 137 matching lines @@
   }
   EXPECT_TRUE(SyncShareNudge());
   const sync_pb::CommitMessage& commit = mock_server_->last_sent_commit();
   ASSERT_EQ(2, commit.entries_size());
   EXPECT_EQ("2", commit.entries(0).parent_id_string());
   EXPECT_EQ("0", commit.entries(0).old_parent_id());
   EXPECT_FALSE(commit.entries(1).has_old_parent_id());
 }
 
 TEST_F(SyncerTest, Test64BitVersionSupport) {
-  int64 really_big_int = std::numeric_limits<int64>::max() - 12;
+  int64_t really_big_int = std::numeric_limits<int64_t>::max() - 12;
   const string name("ringo's dang orang ran rings around my o-ring");
-  int64 item_metahandle;
+  int64_t item_metahandle;
 
-  // Try writing max int64 to the version fields of a meta entry.
+  // Try writing max int64_t to the version fields of a meta entry.
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(), name);
     ASSERT_TRUE(entry.good());
     entry.PutBaseVersion(really_big_int);
     entry.PutServerVersion(really_big_int);
     entry.PutId(ids_.NewServerId());
     item_metahandle = entry.GetMetahandle();
   }
-  // Now read it back out and make sure the value is max int64.
+  // Now read it back out and make sure the value is max int64_t.
   syncable::ReadTransaction rtrans(FROM_HERE, directory());
   Entry entry(&rtrans, syncable::GET_BY_HANDLE, item_metahandle);
   ASSERT_TRUE(entry.good());
   EXPECT_EQ(really_big_int, entry.GetBaseVersion());
 }
 
 TEST_F(SyncerTest, TestSimpleUndelete) {
   Id id = ids_.MakeServer("undeletion item"), root = TestIdFactory::root();
   mock_server_->set_conflict_all_commits(true);
   // Let there be an entry from the server.
@@ skipping 186 matching lines @@
 
     Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "permfolder");
     ASSERT_TRUE(perm_folder.good());
     EXPECT_FALSE(perm_folder.GetIsUnappliedUpdate());
     EXPECT_FALSE(perm_folder.GetIsUnsynced());
     EXPECT_EQ("permitem1", perm_folder.GetNonUniqueName());
   }
 }
 
 TEST_F(SyncerTest, ClientTagUncommittedTagMatchesUpdate) {
-  int64 original_metahandle = 0;
+  int64_t original_metahandle = 0;
 
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry pref(
         &trans, CREATE, PREFERENCES, ids_.root(), "name");
     ASSERT_TRUE(pref.good());
     pref.PutUniqueClientTag("tag");
     pref.PutIsUnsynced(true);
     EXPECT_FALSE(pref.GetIsUnappliedUpdate());
     EXPECT_FALSE(pref.GetId().ServerKnows());
@@ skipping 92 matching lines @@
 
   syncable::Id id1 = TestIdFactory::MakeServer("1");
   mock_server_->AddUpdatePref(id1.GetServerId(), "", "tag1", 10, 100);
 
   syncable::Id id4 = TestIdFactory::MakeServer("4");
   mock_server_->AddUpdatePref(id4.GetServerId(), "", "tag2", 11, 110);
 
   mock_server_->set_conflict_all_commits(true);
 
   EXPECT_TRUE(SyncShareNudge());
-  int64 tag1_metahandle = syncable::kInvalidMetaHandle;
-  int64 tag2_metahandle = syncable::kInvalidMetaHandle;
+  int64_t tag1_metahandle = syncable::kInvalidMetaHandle;
+  int64_t tag2_metahandle = syncable::kInvalidMetaHandle;
   // This should cause client tag overwrite.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry tag1(&trans, GET_BY_CLIENT_TAG, "tag1");
     ASSERT_TRUE(tag1.good());
     ASSERT_TRUE(tag1.GetId().ServerKnows());
     ASSERT_EQ(id1, tag1.GetId());
     EXPECT_FALSE(tag1.GetIsDel());
     EXPECT_FALSE(tag1.GetIsUnappliedUpdate());
@@ skipping 210 matching lines @@
     // Verify that there is still one node under the type root.
     syncable::Directory::Metahandles children;
     directory()->GetChildHandlesById(&trans, pref_root_id, &children);
     ASSERT_EQ(1U, children.size());
   }
 }
 
 TEST_F(SyncerTest, UniqueServerTagUpdates) {
   // As a hurdle, introduce an item whose name is the same as the tag value
   // we'll use later.
-  int64 hurdle_handle = CreateUnsyncedDirectory("bob", "id_bob");
+  int64_t hurdle_handle = CreateUnsyncedDirectory("bob", "id_bob");
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry hurdle(&trans, GET_BY_HANDLE, hurdle_handle);
     ASSERT_TRUE(hurdle.good());
     ASSERT_TRUE(!hurdle.GetIsDel());
     ASSERT_TRUE(hurdle.GetUniqueServerTag().empty());
     ASSERT_EQ("bob", hurdle.GetNonUniqueName());
 
     // Try to lookup by the tagname.  These should fail.
     Entry tag_alpha(&trans, GET_BY_SERVER_TAG, "alpha");
@@ skipping 66 matching lines @@
 }
 
 // A typical scenario: server and client each have one update for the other.
 // This is the "happy path" alternative to UpdateFailsThenDontCommit.
 TEST_F(SyncerTest, UpdateThenCommit) {
   syncable::Id to_receive = ids_.NewServerId();
   syncable::Id to_commit = ids_.NewLocalId();
 
   mock_server_->AddUpdateDirectory(to_receive, ids_.root(), "x", 1, 10,
                                    foreign_cache_guid(), "-1");
-  int64 commit_handle = CreateUnsyncedDirectory("y", to_commit);
+  int64_t commit_handle = CreateUnsyncedDirectory("y", to_commit);
   EXPECT_TRUE(SyncShareNudge());
 
   // The sync cycle should have included a GetUpdate, then a commit.  By the
   // time the commit happened, we should have known for sure that there were no
   // hierarchy conflicts, and reported this fact to the server.
   ASSERT_TRUE(mock_server_->last_request().has_commit());
   VerifyNoHierarchyConflictsReported(mock_server_->last_request());
 
   syncable::ReadTransaction trans(FROM_HERE, directory());
 
@@ skipping 10 matching lines @@
 
 // Same as above, but this time we fail to download updates.
 // We should not attempt to commit anything unless we successfully downloaded
 // updates, otherwise we risk causing a server-side conflict.
 TEST_F(SyncerTest, UpdateFailsThenDontCommit) {
   syncable::Id to_receive = ids_.NewServerId();
   syncable::Id to_commit = ids_.NewLocalId();
 
   mock_server_->AddUpdateDirectory(to_receive, ids_.root(), "x", 1, 10,
                                    foreign_cache_guid(), "-1");
-  int64 commit_handle = CreateUnsyncedDirectory("y", to_commit);
+  int64_t commit_handle = CreateUnsyncedDirectory("y", to_commit);
   mock_server_->FailNextPostBufferToPathCall();
   EXPECT_FALSE(SyncShareNudge());
 
   syncable::ReadTransaction trans(FROM_HERE, directory());
 
   // We did not receive this update.
   Entry received(&trans, GET_BY_ID, to_receive);
   ASSERT_FALSE(received.good());
 
   // And our local update remains unapplied.
@@ skipping 183 matching lines @@
     MutableEntry entry(&trans, GET_BY_HANDLE, metahandle_);
     ASSERT_TRUE(entry.good());
     EXPECT_EQ(metahandle_, entry.GetMetahandle());
     EXPECT_TRUE(entry.GetIsDel());
     entry.PutIsDel(false);
     entry.PutIsUnsynced(true);
     if (entry.GetSyncing())
       entry.PutDirtySync(true);
   }
 
-  int64 GetMetahandleOfTag() {
+  int64_t GetMetahandleOfTag() {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
     EXPECT_TRUE(entry.good());
     if (!entry.good()) {
       return syncable::kInvalidMetaHandle;
     }
     return entry.GetMetahandle();
   }
 
   Id GetServerId() {
@@ skipping 78 matching lines @@
     EXPECT_TRUE(entry.GetIsDel());
     EXPECT_TRUE(entry.GetServerIsDel());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_GE(entry.GetBaseVersion(), 0);
     EXPECT_GE(entry.GetServerVersion(), 0);
   }
 
  protected:
   syncable::Id local_id_;
-  int64 metahandle_;
+  int64_t metahandle_;
 };
 
 TEST_F(SyncerBookmarksTest, CreateSyncThenDeleteSync) {
   Create();
   ExpectUnsyncedCreation();
   EXPECT_TRUE(SyncShareNudge());
   ExpectSyncedAndCreated();
   Delete();
   ExpectUnsyncedDeletion();
   EXPECT_TRUE(SyncShareNudge());
@@ skipping 127 matching lines @@
     MutableEntry entry(&trans, GET_BY_CLIENT_TAG, client_tag_);
     ASSERT_TRUE(entry.good());
     EXPECT_EQ(metahandle_, entry.GetMetahandle());
     EXPECT_TRUE(entry.GetIsDel());
     entry.PutIsDel(false);
     entry.PutIsUnsynced(true);
     if (entry.GetSyncing())
       entry.PutDirtySync(true);
   }
 
-  int64 GetMetahandleOfTag() {
+  int64_t GetMetahandleOfTag() {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_CLIENT_TAG, client_tag_);
     EXPECT_TRUE(entry.good());
     if (!entry.good()) {
       return syncable::kInvalidMetaHandle;
     }
     return entry.GetMetahandle();
   }
 
   void ExpectUnsyncedCreation() {
@@ skipping 69 matching lines @@
     EXPECT_TRUE(entry.GetServerIsDel());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_GE(entry.GetBaseVersion(), 0);
     EXPECT_GE(entry.GetServerVersion(), 0);
   }
 
  protected:
   const std::string client_tag_;
   syncable::Id local_id_;
-  int64 metahandle_;
+  int64_t metahandle_;
 };
 
 TEST_F(SyncerUndeletionTest, UndeleteDuringCommit) {
   Create();
   ExpectUnsyncedCreation();
   EXPECT_TRUE(SyncShareNudge());
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
@@ skipping 416 matching lines @@
     EXPECT_EQ("xyz", final_monitor_records["xyz"].extension_id);
     EXPECT_EQ(2049U, final_monitor_records["ABC"].bookmark_write_count);
     EXPECT_EQ(4U,    final_monitor_records["xyz"].bookmark_write_count);
   } else {
     EXPECT_TRUE(final_monitor_records.empty())
         << "Should not restore records after successful bookmark commit.";
   }
 }
 
 }  // namespace syncer