Switch to standard integer types in sync/.

sync/engine/directory_update_handler_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/engine/directory_update_handler.h"
 
+#include <stdint.h>
+
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/internal_api/public/base/attachment_id_proto.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/test/test_entry_factory.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/sessions/directory_type_debug_info_emitter.h"
 #include "sync/sessions/status_controller.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/syncable_model_neutral_write_transaction.h"
 #include "sync/syncable/syncable_proto_util.h"
 #include "sync/syncable/syncable_read_transaction.h"
 #include "sync/syncable/syncable_write_transaction.h"
 #include "sync/test/engine/fake_model_worker.h"
 #include "sync/test/engine/test_directory_setter_upper.h"
 #include "sync/test/engine/test_id_factory.h"
 #include "sync/test/engine/test_syncable_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 using syncable::Id;
 using syncable::UNITTEST;
 
-static const int64 kDefaultVersion = 1000;
+static const int64_t kDefaultVersion = 1000;
 
 // A test harness for tests that focus on processing updates.
 //
 // Update processing is what occurs when we first download updates.  It converts
 // the received protobuf message into information in the syncable::Directory.
 // Any invalid or redundant updates will be dropped at this point.
 class DirectoryUpdateHandlerProcessUpdateTest : public ::testing::Test {
  public:
   DirectoryUpdateHandlerProcessUpdateTest()
       : ui_worker_(new FakeModelWorker(GROUP_UI)) {
@@ skipping 485 matching lines @@
   AddDefaultFieldValue(BOOKMARKS, &result);
   return result;
 }
 }  // namespace
 
 // Test update application for a few bookmark items.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SimpleBookmark) {
   sessions::StatusController status;
 
   std::string root_server_id = Id::GetRoot().GetServerId();
-  int64 parent_handle =
+  int64_t parent_handle =
       entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
           "parent", DefaultBookmarkSpecifics(), root_server_id);
-  int64 child_handle =
+  int64_t child_handle =
       entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
           "child", DefaultBookmarkSpecifics(), "parent");
 
   ApplyBookmarkUpdates(&status);
 
   const UpdateCounters& counter = GetBookmarksUpdateCounters();
   EXPECT_EQ(0, counter.num_encryption_conflict_application_failures)
       << "Simple update shouldn't result in conflicts";
   EXPECT_EQ(0, counter.num_hierarchy_conflict_application_failures)
       << "Simple update shouldn't result in conflicts";
@@ skipping 14 matching lines @@
     EXPECT_FALSE(child.GetIsUnsynced());
     EXPECT_FALSE(child.GetIsUnappliedUpdate());
   }
 }
 
 // Test that the applicator can handle updates delivered out of order.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        BookmarkChildrenBeforeParent) {
   // Start with some bookmarks whose parents are unknown.
   std::string root_server_id = Id::GetRoot().GetServerId();
-  int64 a_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
+  int64_t a_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
       "a_child_created_first", DefaultBookmarkSpecifics(), "parent");
-  int64 x_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
+  int64_t x_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
       "x_child_created_first", DefaultBookmarkSpecifics(), "parent");
 
   // Update application will fail.
   sessions::StatusController status1;
   ApplyBookmarkUpdates(&status1);
   EXPECT_EQ(0, status1.num_updates_applied());
   EXPECT_EQ(2, status1.num_hierarchy_conflicts());
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
@@ skipping 32 matching lines @@
     ASSERT_TRUE(x.good());
 
     EXPECT_FALSE(a.GetIsUnappliedUpdate());
     EXPECT_FALSE(x.GetIsUnappliedUpdate());
   }
 }
 
 // Try to apply changes on an item that is both IS_UNSYNCED and
 // IS_UNAPPLIED_UPDATE.  Conflict resolution should be performed.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SimpleBookmarkConflict) {
-  int64 handle = entry_factory()->CreateUnappliedAndUnsyncedBookmarkItem("x");
+  int64_t handle = entry_factory()->CreateUnappliedAndUnsyncedBookmarkItem("x");
 
   int original_server_version = -10;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
     original_server_version = e.GetServerVersion();
     ASSERT_NE(original_server_version, e.GetBaseVersion());
     EXPECT_TRUE(e.GetIsUnsynced());
   }
 
@@ skipping 18 matching lines @@
     EXPECT_TRUE(e.GetIsUnsynced());
   }
 }
 
 // Create a simple conflict that is also a hierarchy conflict.  If we were to
 // follow the normal "server wins" logic, we'd end up violating hierarchy
 // constraints.  The hierarchy conflict must take precedence.  We can not allow
 // the update to be applied.  The item must remain in the conflict state.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, HierarchyAndSimpleConflict) {
   // Create a simply-conflicting item.  It will start with valid parent ids.
-  int64 handle = entry_factory()->CreateUnappliedAndUnsyncedBookmarkItem(
+  int64_t handle = entry_factory()->CreateUnappliedAndUnsyncedBookmarkItem(
       "orphaned_by_server");
   {
     // Manually set the SERVER_PARENT_ID to bad value.
     // A bad parent indicates a hierarchy conflict.
     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     syncable::MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
 
     entry.PutServerParentId(TestIdFactory::MakeServer("bogus_parent"));
   }
@@ skipping 15 matching lines @@
   }
 }
 
 // Attempt to apply an udpate that would create a bookmark folder loop.  This
 // application should fail.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, BookmarkFolderLoop) {
   // Item 'X' locally has parent of 'root'.  Server is updating it to have
   // parent of 'Y'.
 
   // Create it as a child of root node.
-  int64 handle = entry_factory()->CreateSyncedItem("X", BOOKMARKS, true);
+  int64_t handle = entry_factory()->CreateSyncedItem("X", BOOKMARKS, true);
 
   {
     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     syncable::MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
 
     // Re-parent from root to "Y"
     entry.PutServerVersion(entry_factory()->GetNextRevision());
     entry.PutIsUnappliedUpdate(true);
     entry.PutServerParentId(TestIdFactory::MakeServer("Y"));
@@ skipping 23 matching lines @@
     EXPECT_TRUE(e.GetIsUnappliedUpdate());
     EXPECT_FALSE(e.GetIsUnsynced());
   }
 }
 
 // Test update application where the update has been orphaned by a local folder
 // deletion.  The update application attempt should fail.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        HierarchyConflictDeletedParent) {
   // Create a locally deleted parent item.
-  int64 parent_handle;
+  int64_t parent_handle;
   entry_factory()->CreateUnsyncedItem(
       Id::CreateFromServerId("parent"), TestIdFactory::root(),
       "parent", true, BOOKMARKS, &parent_handle);
   {
     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     syncable::MutableEntry entry(&trans,
                                  syncable::GET_BY_HANDLE,
                                  parent_handle);
     entry.PutIsDel(true);
   }
 
   // Create an incoming child from the server.
-  int64 child_handle = entry_factory()->CreateUnappliedNewItemWithParent(
+  int64_t child_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "child", DefaultBookmarkSpecifics(), "parent");
 
   // The server's update may seem valid to some other client, but on this client
   // that new item's parent no longer exists.  The update should not be applied
   // and the update applicator should indicate this is a hierarchy conflict.
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
   const UpdateCounters& counters = GetBookmarksUpdateCounters();
   EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures);
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry child(&trans, syncable::GET_BY_HANDLE, child_handle);
     ASSERT_TRUE(child.good());
     EXPECT_TRUE(child.GetIsUnappliedUpdate());
     EXPECT_FALSE(child.GetIsUnsynced());
   }
 }
 
 // Attempt to apply an update that deletes a folder where the folder has
 // locally-created children.  The update application should fail.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        HierarchyConflictDeleteNonEmptyDirectory) {
   // Create a server-deleted folder as a child of root node.
-  int64 parent_handle =
+  int64_t parent_handle =
       entry_factory()->CreateSyncedItem("parent", BOOKMARKS, true);
   {
     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     syncable::MutableEntry entry(&trans,
                                  syncable::GET_BY_HANDLE,
                                  parent_handle);
     ASSERT_TRUE(entry.good());
 
     // Delete it on the server.
     entry.PutServerVersion(entry_factory()->GetNextRevision());
@@ skipping 24 matching lines @@
     EXPECT_TRUE(parent.GetIsUnappliedUpdate());
     EXPECT_FALSE(parent.GetIsUnsynced());
   }
 }
 
 // Attempt to apply updates where the updated item's parent is not known to this
 // client.  The update application attempt should fail.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        HierarchyConflictUnknownParent) {
   // We shouldn't be able to do anything with either of these items.
-  int64 x_handle = entry_factory()->CreateUnappliedNewItemWithParent(
+  int64_t x_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "some_item", DefaultBookmarkSpecifics(), "unknown_parent");
-  int64 y_handle = entry_factory()->CreateUnappliedNewItemWithParent(
+  int64_t y_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "some_other_item", DefaultBookmarkSpecifics(), "some_item");
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
 
   const UpdateCounters& counters = GetBookmarksUpdateCounters();
   EXPECT_EQ(2, counters.num_hierarchy_conflict_application_failures)
       << "All updates with an unknown ancestors should be in conflict";
   EXPECT_EQ(0, counters.num_updates_applied)
       << "No item with an unknown ancestor should be applied";
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry x(&trans, syncable::GET_BY_HANDLE, x_handle);
     syncable::Entry y(&trans, syncable::GET_BY_HANDLE, y_handle);
     ASSERT_TRUE(x.good());
     ASSERT_TRUE(y.good());
     EXPECT_TRUE(x.GetIsUnappliedUpdate());
     EXPECT_TRUE(y.GetIsUnappliedUpdate());
     EXPECT_FALSE(x.GetIsUnsynced());
     EXPECT_FALSE(y.GetIsUnsynced());
   }
 }
 
 // Attempt application of a mix of items.  Some update application attempts will
 // fail due to hierarchy conflicts.  Others should succeed.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, ItemsBothKnownAndUnknown) {
   // See what happens when there's a mixture of good and bad updates.
   std::string root_server_id = Id::GetRoot().GetServerId();
-  int64 u1_handle = entry_factory()->CreateUnappliedNewItemWithParent(
+  int64_t u1_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "first_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent");
-  int64 k1_handle = entry_factory()->CreateUnappliedNewItemWithParent(
+  int64_t k1_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "first_known_item", DefaultBookmarkSpecifics(), root_server_id);
-  int64 u2_handle = entry_factory()->CreateUnappliedNewItemWithParent(
+  int64_t u2_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "second_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent");
-  int64 k2_handle = entry_factory()->CreateUnappliedNewItemWithParent(
+  int64_t k2_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "second_known_item", DefaultBookmarkSpecifics(), "first_known_item");
-  int64 k3_handle = entry_factory()->CreateUnappliedNewItemWithParent(
+  int64_t k3_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "third_known_item", DefaultBookmarkSpecifics(), "fourth_known_item");
-  int64 k4_handle = entry_factory()->CreateUnappliedNewItemWithParent(
+  int64_t k4_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "fourth_known_item", DefaultBookmarkSpecifics(), root_server_id);
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
 
   const UpdateCounters& counters = GetBookmarksUpdateCounters();
   EXPECT_EQ(2, counters.num_hierarchy_conflict_application_failures)
       << "The updates with unknown ancestors should be in conflict";
   EXPECT_EQ(4, counters.num_updates_applied)
       << "The updates with known ancestors should be successfully applied";
@@ skipping 34 matching lines @@
 
   KeyParams params = {"localhost", "dummy", "foobar"};
   cryptographer->AddKey(params);
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::PasswordSpecificsData data;
   data.set_origin("http://example.com");
 
   cryptographer->Encrypt(data,
                          specifics.mutable_password()->mutable_encrypted());
-  int64 handle =
+  int64_t handle =
       entry_factory()->CreateUnappliedNewItem("item", specifics, false);
 
   sessions::StatusController status;
   ApplyPasswordUpdates(&status);
 
   const UpdateCounters& counters = GetPasswordsUpdateCounters();
   EXPECT_EQ(1, counters.num_updates_applied)
       << "The updates that can be decrypted should be applied";
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(e.good());
     EXPECT_FALSE(e.GetIsUnappliedUpdate());
     EXPECT_FALSE(e.GetIsUnsynced());
   }
 }
 
 // Attempt application of encrypted items when the passphrase is not known.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, UndecryptableData) {
   // Undecryptable updates should not be applied.
   sync_pb::EntitySpecifics encrypted_bookmark;
   encrypted_bookmark.mutable_encrypted();
   AddDefaultFieldValue(BOOKMARKS, &encrypted_bookmark);
   std::string root_server_id = Id::GetRoot().GetServerId();
-  int64 folder_handle = entry_factory()->CreateUnappliedNewItemWithParent(
-      "folder",
-      encrypted_bookmark,
-      root_server_id);
-  int64 bookmark_handle = entry_factory()->CreateUnappliedNewItem(
-      "item2",
-      encrypted_bookmark,
-      false);
+  int64_t folder_handle = entry_factory()->CreateUnappliedNewItemWithParent(
+      "folder", encrypted_bookmark, root_server_id);
+  int64_t bookmark_handle = entry_factory()->CreateUnappliedNewItem(
+      "item2", encrypted_bookmark, false);
   sync_pb::EntitySpecifics encrypted_password;
   encrypted_password.mutable_password();
-  int64 password_handle = entry_factory()->CreateUnappliedNewItem(
-      "item3",
-      encrypted_password,
-      false);
+  int64_t password_handle = entry_factory()->CreateUnappliedNewItem(
+      "item3", encrypted_password, false);
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
   ApplyPasswordUpdates(&status);
 
   const UpdateCounters& bm_counters = GetBookmarksUpdateCounters();
   EXPECT_EQ(2, bm_counters.num_encryption_conflict_application_failures)
       << "Updates that can't be decrypted should be in encryption conflict";
   EXPECT_EQ(0, bm_counters.num_updates_applied)
       << "No update that can't be decrypted should be applied";
@@ skipping 15 matching lines @@
     EXPECT_TRUE(folder.GetIsUnappliedUpdate());
     EXPECT_TRUE(bm.GetIsUnappliedUpdate());
     EXPECT_TRUE(pw.GetIsUnappliedUpdate());
   }
 }
 
 // Test a mix of decryptable and undecryptable updates.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SomeUndecryptablePassword) {
   Cryptographer* cryptographer;
 
-  int64 decryptable_handle = -1;
-  int64 undecryptable_handle = -1;
+  int64_t decryptable_handle = -1;
+  int64_t undecryptable_handle = -1;
 
   // Only decryptable password updates should be applied.
   {
     sync_pb::EntitySpecifics specifics;
     sync_pb::PasswordSpecificsData data;
     data.set_origin("http://example.com/1");
     {
       syncable::ReadTransaction trans(FROM_HERE, directory());
       cryptographer = directory()->GetCryptographer(&trans);
 
@@ skipping 41 matching lines @@
     EXPECT_FALSE(e1.GetIsUnappliedUpdate());
     EXPECT_TRUE(e2.GetIsUnappliedUpdate());
   }
 }
 
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        SimpleConflictDifferentAttachmentMetadata) {
   const bool is_folder = false;
   sync_pb::EntitySpecifics specifics;
   *specifics.mutable_article() = sync_pb::ArticleSpecifics();
-  int64 handle = entry_factory()->CreateSyncedItem("art1", ARTICLES, is_folder);
+  int64_t handle =
+      entry_factory()->CreateSyncedItem("art1", ARTICLES, is_folder);
 
   sync_pb::AttachmentIdProto local_attachment_id =
       CreateAttachmentIdProto(0, 0);
   sync_pb::AttachmentIdProto server_attachment_id =
       CreateAttachmentIdProto(0, 0);
 
   // Add an attachment to the local attachment metadata.
   sync_pb::AttachmentMetadata local_metadata;
   sync_pb::AttachmentMetadataRecord* local_record = local_metadata.add_record();
   *local_record->mutable_id() = local_attachment_id;
@@ skipping 23 matching lines @@
   local_metadata = entry_factory()->GetLocalAttachmentMetadataForItem(handle);
   EXPECT_EQ(server_metadata.SerializeAsString(),
             local_metadata.SerializeAsString());
 }
 
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        SimpleConflictSameAttachmentMetadataDifferentOrder) {
   const bool is_folder = false;
   sync_pb::EntitySpecifics specifics;
   *specifics.mutable_article() = sync_pb::ArticleSpecifics();
-  int64 handle = entry_factory()->CreateSyncedItem("art1", ARTICLES, is_folder);
+  int64_t handle =
+      entry_factory()->CreateSyncedItem("art1", ARTICLES, is_folder);
 
   sync_pb::AttachmentIdProto id1 = CreateAttachmentIdProto(0, 0);
   sync_pb::AttachmentIdProto id2 = CreateAttachmentIdProto(0, 0);
 
   // Add id1, then id2 to the local attachment metadata.
   sync_pb::AttachmentMetadata local_metadata;
   sync_pb::AttachmentMetadataRecord* record = local_metadata.add_record();
   *record->mutable_id() = id1;
   record->set_is_on_server(true);
   record = local_metadata.add_record();
@@ skipping 20 matching lines @@
   const UpdateCounters& counters = GetArticlesUpdateCounters();
   EXPECT_EQ(1, counters.num_updates_applied);
   EXPECT_EQ(1, counters.num_local_overwrites);
   EXPECT_EQ(0, counters.num_server_overwrites);
   local_metadata = entry_factory()->GetLocalAttachmentMetadataForItem(handle);
   EXPECT_EQ(server_metadata.SerializeAsString(),
             local_metadata.SerializeAsString());
 }
 
 }  // namespace syncer