Switch to standard integer types in sync/.

sync/syncable/directory_unittest.cc

 // Copyright 2014 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 "sync/syncable/directory_unittest.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <cstdlib>
 
+#include "base/macros.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/values_test_util.h"
 #include "sync/internal_api/public/base/attachment_id_proto.h"
 #include "sync/syncable/syncable_proto_util.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/syncable/syncable_write_transaction.h"
 #include "sync/test/engine/test_syncable_utils.h"
 #include "sync/test/test_directory_backing_store.h"
@@ skipping 162 matching lines @@
 
     ReadTransaction trans(FROM_HERE, dir_.get());
     sync_pb::DataTypeContext context;
     dir_->GetDataTypeContext(&trans, it.Get(), &context);
     EXPECT_TRUE(context.SerializeAsString().empty());
   }
   EXPECT_FALSE(types_to_purge.Has(BOOKMARKS));
   EXPECT_TRUE(dir_->InitialSyncEndedForType(BOOKMARKS));
 }
 
-bool SyncableDirectoryTest::IsInDirtyMetahandles(int64 metahandle) {
+bool SyncableDirectoryTest::IsInDirtyMetahandles(int64_t metahandle) {
   return 1 == dir_->kernel()->dirty_metahandles.count(metahandle);
 }
 
-bool SyncableDirectoryTest::IsInMetahandlesToPurge(int64 metahandle) {
+bool SyncableDirectoryTest::IsInMetahandlesToPurge(int64_t metahandle) {
   return 1 == dir_->kernel()->metahandles_to_purge.count(metahandle);
 }
 
 scoped_ptr<Directory>& SyncableDirectoryTest::dir() {
   return dir_;
 }
 
 DirectoryChangeDelegate* SyncableDirectoryTest::directory_change_delegate() {
   return &delegate_;
 }
 
 Encryptor* SyncableDirectoryTest::encryptor() {
   return &encryptor_;
 }
 
 
 TestUnrecoverableErrorHandler*
 SyncableDirectoryTest::unrecoverable_error_handler() {
   return &handler_;
 }
 
 void SyncableDirectoryTest::ValidateEntry(BaseTransaction* trans,
-                                          int64 id,
+                                          int64_t id,
                                           bool check_name,
                                           const std::string& name,
-                                          int64 base_version,
-                                          int64 server_version,
+                                          int64_t base_version,
+                                          int64_t server_version,
                                           bool is_del) {
   Entry e(trans, GET_BY_ID, TestIdFactory::FromNumber(id));
   ASSERT_TRUE(e.good());
   if (check_name)
     ASSERT_TRUE(name == e.GetNonUniqueName());
   ASSERT_TRUE(base_version == e.GetBaseVersion());
   ASSERT_TRUE(server_version == e.GetServerVersion());
   ASSERT_TRUE(is_del == e.GetIsDel());
 }
 
@@ skipping 36 matching lines @@
 
   dir()->HandleSaveChangesFailure(snapshot1);
 
   Directory::SaveChangesSnapshot snapshot2;
   dir()->TakeSnapshotForSaveChanges(&snapshot2);
   EXPECT_TRUE(all_handles == snapshot2.metahandles_to_purge);
 }
 
 TEST_F(SyncableDirectoryTest, TakeSnapshotGetsAllDirtyHandlesTest) {
   const int metahandles_to_create = 100;
-  std::vector<int64> expected_dirty_metahandles;
+  std::vector<int64_t> expected_dirty_metahandles;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     for (int i = 0; i < metahandles_to_create; i++) {
       MutableEntry e(&trans, CREATE, BOOKMARKS, trans.root_id(), "foo");
       expected_dirty_metahandles.push_back(e.GetMetahandle());
       e.PutIsUnsynced(true);
     }
   }
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
     base::AutoLock scoped_lock(dir()->kernel()->save_changes_mutex);
     dir()->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there's an entry for each new metahandle.  Make sure all
     // entries are marked dirty.
     ASSERT_EQ(expected_dirty_metahandles.size(), snapshot.dirty_metas.size());
     for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
          i != snapshot.dirty_metas.end();
          ++i) {
       ASSERT_TRUE((*i)->is_dirty());
     }
     dir()->VacuumAfterSaveChanges(snapshot);
   }
   // Put a new value with existing transactions as well as adding new ones.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
-    std::vector<int64> new_dirty_metahandles;
-    for (std::vector<int64>::const_iterator i =
+    std::vector<int64_t> new_dirty_metahandles;
+    for (std::vector<int64_t>::const_iterator i =
              expected_dirty_metahandles.begin();
-         i != expected_dirty_metahandles.end();
-         ++i) {
+         i != expected_dirty_metahandles.end(); ++i) {
       // Change existing entries to directories to dirty them.
       MutableEntry e1(&trans, GET_BY_HANDLE, *i);
       e1.PutIsDir(true);
       e1.PutIsUnsynced(true);
       // Add new entries
       MutableEntry e2(&trans, CREATE, BOOKMARKS, trans.root_id(), "bar");
       e2.PutIsUnsynced(true);
       new_dirty_metahandles.push_back(e2.GetMetahandle());
     }
     expected_dirty_metahandles.insert(expected_dirty_metahandles.end(),
@@ skipping 15 matching lines @@
     }
     dir()->VacuumAfterSaveChanges(snapshot);
   }
 }
 
 TEST_F(SyncableDirectoryTest, TakeSnapshotGetsOnlyDirtyHandlesTest) {
   const int metahandles_to_create = 100;
 
   // half of 2 * metahandles_to_create
   const unsigned int number_changed = 100u;
-  std::vector<int64> expected_dirty_metahandles;
+  std::vector<int64_t> expected_dirty_metahandles;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     for (int i = 0; i < metahandles_to_create; i++) {
       MutableEntry e(&trans, CREATE, BOOKMARKS, trans.root_id(), "foo");
       expected_dirty_metahandles.push_back(e.GetMetahandle());
       e.PutIsUnsynced(true);
     }
   }
   dir()->SaveChanges();
   // Put a new value with existing transactions as well as adding new ones.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
-    std::vector<int64> new_dirty_metahandles;
-    for (std::vector<int64>::const_iterator i =
+    std::vector<int64_t> new_dirty_metahandles;
+    for (std::vector<int64_t>::const_iterator i =
              expected_dirty_metahandles.begin();
-         i != expected_dirty_metahandles.end();
-         ++i) {
+         i != expected_dirty_metahandles.end(); ++i) {
       // Change existing entries to directories to dirty them.
       MutableEntry e1(&trans, GET_BY_HANDLE, *i);
       ASSERT_TRUE(e1.good());
       e1.PutIsDir(true);
       e1.PutIsUnsynced(true);
       // Add new entries
       MutableEntry e2(&trans, CREATE, BOOKMARKS, trans.root_id(), "bar");
       e2.PutIsUnsynced(true);
       new_dirty_metahandles.push_back(e2.GetMetahandle());
     }
     expected_dirty_metahandles.insert(expected_dirty_metahandles.end(),
                                       new_dirty_metahandles.begin(),
                                       new_dirty_metahandles.end());
   }
   dir()->SaveChanges();
   // Don't make any changes whatsoever and ensure nothing comes back.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
-    for (std::vector<int64>::const_iterator i =
+    for (std::vector<int64_t>::const_iterator i =
              expected_dirty_metahandles.begin();
-         i != expected_dirty_metahandles.end();
-         ++i) {
+         i != expected_dirty_metahandles.end(); ++i) {
       MutableEntry e(&trans, GET_BY_HANDLE, *i);
       ASSERT_TRUE(e.good());
       // We aren't doing anything to dirty these entries.
     }
   }
   // Fake SaveChanges() and make sure we got what we expected.
   {
     Directory::SaveChangesSnapshot snapshot;
     base::AutoLock scoped_lock(dir()->kernel()->save_changes_mutex);
     dir()->TakeSnapshotForSaveChanges(&snapshot);
     // Make sure there are no dirty_metahandles.
     EXPECT_EQ(0u, snapshot.dirty_metas.size());
     dir()->VacuumAfterSaveChanges(snapshot);
   }
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     bool should_change = false;
-    for (std::vector<int64>::const_iterator i =
+    for (std::vector<int64_t>::const_iterator i =
              expected_dirty_metahandles.begin();
-         i != expected_dirty_metahandles.end();
-         ++i) {
+         i != expected_dirty_metahandles.end(); ++i) {
       // Maybe change entries by flipping IS_DIR.
       MutableEntry e(&trans, GET_BY_HANDLE, *i);
       ASSERT_TRUE(e.good());
       should_change = !should_change;
       if (should_change) {
         bool not_dir = !e.GetIsDir();
         e.PutIsDir(not_dir);
         e.PutIsUnsynced(true);
       }
     }
@@ skipping 19 matching lines @@
 TEST_F(SyncableDirectoryTest, ManageDeleteJournals) {
   sync_pb::EntitySpecifics bookmark_specifics;
   AddDefaultFieldValue(BOOKMARKS, &bookmark_specifics);
   bookmark_specifics.mutable_bookmark()->set_url("url");
 
   // The first two IDs are server IDs.
   Id id1 = TestIdFactory::FromNumber(1);
   Id id2 = TestIdFactory::FromNumber(2);
   // The third one is a client ID.
   Id id3 = TestIdFactory::FromNumber(-3);
-  int64 handle1 = 0;
-  int64 handle2 = 0;
-  int64 handle3 = 0;
+  int64_t handle1 = 0;
+  int64_t handle2 = 0;
+  int64_t handle3 = 0;
   {
     // Create 3 bookmark entries and save in database.
     {
       WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
 
       MutableEntry item1(&trans, CREATE, BOOKMARKS, trans.root_id(), "item1");
       item1.PutId(id1);
       item1.PutSpecifics(bookmark_specifics);
       item1.PutServerSpecifics(bookmark_specifics);
       item1.PutIsUnappliedUpdate(true);
@@ skipping 121 matching lines @@
   }
 }
 
 TEST_F(SyncableDirectoryTest, TestPurgeDeletedEntriesOnReload) {
   sync_pb::EntitySpecifics specifics;
   AddDefaultFieldValue(PREFERENCES, &specifics);
 
   const int kClientCount = 2;
   const int kServerCount = 5;
   const int kTestCount = kClientCount + kServerCount;
-  int64 handles[kTestCount];
+  int64_t handles[kTestCount];
 
   // The idea is to recreate various combinations of IDs, IS_DEL,
   // IS_UNSYNCED, and IS_UNAPPLIED_UPDATE flags to test all combinations
   // for DirectoryBackingStore::SafeToPurgeOnLoading.
   // 0: client ID, IS_DEL, IS_UNSYNCED
   // 1: client ID, IS_UNSYNCED
   // 2: server ID, IS_DEL, IS_UNSYNCED, IS_UNAPPLIED_UPDATE
   // 3: server ID, IS_DEL, IS_UNSYNCED
   // 4: server ID, IS_DEL, IS_UNAPPLIED_UPDATE
   // 5: server ID, IS_DEL
@@ skipping 35 matching lines @@
         item.PutIsUnappliedUpdate(true);
     }
   }
   ASSERT_EQ(OPENED, SimulateSaveAndReloadDir());
 
   // Expect items 0 and 5 to be purged according to
   // DirectoryBackingStore::SafeToPurgeOnLoading:
   // - Item 0 is an item with IS_DEL flag and client ID.
   // - Item 5 is an item with IS_DEL flag which has both
   //   IS_UNSYNCED and IS_UNAPPLIED_UPDATE unset.
-  std::vector<int64> expected_purged;
+  std::vector<int64_t> expected_purged;
   expected_purged.push_back(0);
   expected_purged.push_back(5);
 
-  std::vector<int64> actually_purged;
+  std::vector<int64_t> actually_purged;
   {
     ReadTransaction trans(FROM_HERE, dir().get());
     for (int i = 0; i < kTestCount; i++) {
       Entry item(&trans, GET_BY_HANDLE, handles[i]);
       if (!item.good()) {
         actually_purged.push_back(i);
       }
     }
   }
 
@@ skipping 30 matching lines @@
   e2.PutIsDel(false);
   e3.PutIsDel(false);
 
   e1.PutIsDel(true);
   e2.PutIsDel(true);
   e3.PutIsDel(true);
 }
 
 TEST_F(SyncableDirectoryTest, TestGetUnsynced) {
   Directory::Metahandles handles;
-  int64 handle1, handle2;
+  int64_t handle1, handle2;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
 
     dir()->GetUnsyncedMetaHandles(&trans, &handles);
     ASSERT_EQ(0u, handles.size());
 
     MutableEntry e1(&trans, CREATE, BOOKMARKS, trans.root_id(), "abba");
     ASSERT_TRUE(e1.good());
     handle1 = e1.GetMetahandle();
     e1.PutBaseVersion(1);
@@ skipping 49 matching lines @@
   dir()->SaveChanges();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     dir()->GetUnsyncedMetaHandles(&trans, &handles);
     ASSERT_EQ(1u, handles.size());
     ASSERT_TRUE(handle2 == handles[0]);
   }
 }
 
 TEST_F(SyncableDirectoryTest, TestGetUnappliedUpdates) {
-  std::vector<int64> handles;
-  int64 handle1, handle2;
+  std::vector<int64_t> handles;
+  int64_t handle1, handle2;
   const FullModelTypeSet all_types = FullModelTypeSet::All();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
 
     dir()->GetUnappliedUpdateMetaHandles(&trans, all_types, &handles);
     ASSERT_EQ(0u, handles.size());
 
     MutableEntry e1(&trans, CREATE, BOOKMARKS, trans.root_id(), "abba");
     ASSERT_TRUE(e1.good());
     handle1 = e1.GetMetahandle();
@@ skipping 52 matching lines @@
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     dir()->GetUnappliedUpdateMetaHandles(&trans, all_types, &handles);
     ASSERT_EQ(1u, handles.size());
     ASSERT_TRUE(handle2 == handles[0]);
   }
 }
 
 TEST_F(SyncableDirectoryTest, DeleteBug_531383) {
   // Try to evoke a check failure...
   TestIdFactory id_factory;
-  int64 grandchild_handle;
+  int64_t grandchild_handle;
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, dir().get());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, id_factory.root(), "Bob");
     ASSERT_TRUE(parent.good());
     parent.PutIsDir(true);
     parent.PutId(id_factory.NewServerId());
     parent.PutBaseVersion(1);
     MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent.GetId(), "Bob");
     ASSERT_TRUE(child.good());
     child.PutIsDir(true);
@@ skipping 67 matching lines @@
   ASSERT_FALSE(IsLegalNewParent(child, grandchild));
   ASSERT_TRUE(IsLegalNewParent(child, parent2));
   ASSERT_TRUE(IsLegalNewParent(child, grandchild2));
   ASSERT_FALSE(IsLegalNewParent(parent, grandchild));
   ASSERT_FALSE(IsLegalNewParent(root, grandchild));
   ASSERT_FALSE(IsLegalNewParent(parent, grandchild));
 }
 
 TEST_F(SyncableDirectoryTest, TestEntryIsInFolder) {
   // Create a subdir and an entry.
-  int64 entry_handle;
+  int64_t entry_handle;
   syncable::Id folder_id;
   syncable::Id entry_id;
   std::string entry_name = "entry";
 
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     MutableEntry folder(&trans, CREATE, BOOKMARKS, trans.root_id(), "folder");
     ASSERT_TRUE(folder.good());
     folder.PutIsDir(true);
     EXPECT_TRUE(folder.PutIsUnsynced(true));
@@ skipping 469 matching lines @@
     child.PutSpecifics(specifics);
 
     EXPECT_TRUE(child.ShouldMaintainPosition());
     EXPECT_TRUE(!child.GetUniquePosition().IsValid());
   }
 
   EXPECT_EQ(FAILED_DATABASE_CORRUPT, SimulateSaveAndReloadDir());
 }
 
 TEST_F(SyncableDirectoryTest, General) {
-  int64 written_metahandle;
+  int64_t written_metahandle;
   const Id id = TestIdFactory::FromNumber(99);
   std::string name = "Jeff";
   // Test simple read operations on an empty DB.
   {
     ReadTransaction rtrans(FROM_HERE, dir().get());
     Entry e(&rtrans, GET_BY_ID, id);
     ASSERT_FALSE(e.good());  // Hasn't been written yet.
 
     Directory::Metahandles child_handles;
     dir()->GetChildHandlesById(&rtrans, rtrans.root_id(), &child_handles);
@@ skipping 56 matching lines @@
     MutableEntry e(&trans, GET_BY_HANDLE, written_metahandle);
     e.PutIsDel(true);
 
     EXPECT_EQ(0, CountEntriesWithName(&trans, trans.root_id(), name));
   }
 
   dir()->SaveChanges();
 }
 
 TEST_F(SyncableDirectoryTest, ChildrenOps) {
-  int64 written_metahandle;
+  int64_t written_metahandle;
   const Id id = TestIdFactory::FromNumber(99);
   std::string name = "Jeff";
   {
     ReadTransaction rtrans(FROM_HERE, dir().get());
     Entry e(&rtrans, GET_BY_ID, id);
     ASSERT_FALSE(e.good());  // Hasn't been written yet.
 
     Entry root(&rtrans, GET_BY_ID, rtrans.root_id());
     ASSERT_TRUE(root.good());
     EXPECT_FALSE(dir()->HasChildren(&rtrans, rtrans.root_id()));
@@ skipping 40 matching lines @@
     Entry root(&rtrans, GET_BY_ID, rtrans.root_id());
     ASSERT_TRUE(root.good());
     EXPECT_FALSE(dir()->HasChildren(&rtrans, rtrans.root_id()));
     EXPECT_TRUE(root.GetFirstChildId().IsNull());
   }
 
   dir()->SaveChanges();
 }
 
 TEST_F(SyncableDirectoryTest, ClientIndexRebuildsProperly) {
-  int64 written_metahandle;
+  int64_t written_metahandle;
   TestIdFactory factory;
   const Id id = factory.NewServerId();
   std::string name = "cheesepuffs";
   std::string tag = "dietcoke";
 
   // Test creating a new meta entry.
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, dir().get());
     MutableEntry me(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(), name);
     ASSERT_TRUE(me.good());
@@ skipping 559 matching lines @@
   EXPECT_FALSE(dir()->InitialSyncEndedForType(&trans, PREFERENCES));
 
   // Mark as complete and verify.
   dir()->MarkInitialSyncEndedForType(&trans, PREFERENCES);
   EXPECT_TRUE(dir()->InitialSyncEndedForType(&trans, PREFERENCES));
 }
 
 }  // namespace syncable
 
 }  // namespace syncer