Switch to standard integer types in sync/.

sync/engine/syncer_util_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/syncer_util.h"
 
+#include <stdint.h>
+
 #include "base/rand_util.h"
 #include "sync/internal_api/public/base/unique_position.h"
 #include "sync/internal_api/public/test/test_entry_factory.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/syncable_write_transaction.h"
 #include "sync/test/engine/test_directory_setter_upper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
@@ skipping 38 matching lines @@
 
   void InitSuffixIngredients() {
     update.set_originator_cache_guid("CacheGUID");
     update.set_originator_client_item_id("OrigID");
   }
 
   void InitProtoPosition() {
     test_position.ToProto(update.mutable_unique_position());
   }
 
-  void InitInt64Position(int64 pos_value) {
+  void InitInt64Position(int64_t pos_value) {
     update.set_position_in_parent(pos_value);
   }
 
   sync_pb::SyncEntity update;
   UniquePosition test_position;
   base::MessageLoop message_loop_;
   TestDirectorySetterUpper dir_maker_;
   scoped_ptr<TestEntryFactory> entry_factory_;
 };
 
@@ skipping 42 matching lines @@
   EXPECT_TRUE(pos.LessThan(
       UniquePosition::FromInt64(11, UniquePosition::RandomSuffix())));
 }
 
 TEST_F(GetUpdatePositionTest, FromProto) {
   InitSuffixIngredients();
   InitInt64Position(10);
 
   std::string suffix = GetUniqueBookmarkTagFromUpdate(update);
 
-  // The proto position is not set, so we should get one based on the int64.
+  // The proto position is not set, so we should get one based on the int64_t.
   // It should not match the proto we defined in the test harness.
   UniquePosition int64_pos = GetUpdatePosition(update, suffix);
   EXPECT_FALSE(int64_pos.Equals(test_position));
 
   // Move the test harness' position value into the update proto.
-  // Expect that it takes precedence over the int64-based position.
+  // Expect that it takes precedence over the int64_t-based position.
   InitProtoPosition();
   UniquePosition pos = GetUpdatePosition(update, suffix);
   EXPECT_TRUE(pos.Equals(test_position));
 }
 
 TEST_F(GetUpdatePositionTest, FromNothing) {
   // Init none of the ingredients necessary to make a position.
   // Verify we still generate a valid position locally.
 
   std::string suffix = GetUniqueBookmarkTagFromUpdate(update);
@@ skipping 10 matching lines @@
 }
 
 }  // namespace
 
 // Checks that whole cycle of unique_position updating from
 // server works fine and does not browser crash.
 TEST_F(GetUpdatePositionTest, UpdateServerFieldsFromUpdateTest) {
   InitSuffixIngredients();  // Initialize update with valid data.
 
   std::string root_server_id = syncable::Id::GetRoot().GetServerId();
-  int64 handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
+  int64_t handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
       "I", DefaultBookmarkSpecifics(), root_server_id);
 
   syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, directory());
   syncable::MutableEntry target(&trans, syncable::GET_BY_HANDLE, handle);
 
   // Before update, target has invalid bookmark tag and unique position.
   EXPECT_FALSE(UniquePosition::IsValidSuffix(target.GetUniqueBookmarkTag()));
   EXPECT_FALSE(target.GetServerUniquePosition().IsValid());
   UpdateServerFieldsFromUpdate(&target, update, "name");
 
   // After update, target has valid bookmark tag and unique position.
   EXPECT_TRUE(UniquePosition::IsValidSuffix(target.GetUniqueBookmarkTag()));
   EXPECT_TRUE(target.GetServerUniquePosition().IsValid());
 }
 
 // Checks that whole cycle of unique_position updating does not
 // browser crash even data from server is invalid.
 // It looks like server bug, but browser should not crash and work further.
 TEST_F(GetUpdatePositionTest, UpdateServerFieldsFromInvalidUpdateTest) {
   // Do not initialize data in update, update is invalid.
 
   std::string root_server_id = syncable::Id::GetRoot().GetServerId();
-  int64 handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
+  int64_t handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
       "I", DefaultBookmarkSpecifics(), root_server_id);
 
   syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, directory());
   syncable::MutableEntry target(&trans, syncable::GET_BY_HANDLE, handle);
 
   // Before update, target has invalid bookmark tag and unique position.
   EXPECT_FALSE(UniquePosition::IsValidSuffix(target.GetUniqueBookmarkTag()));
   EXPECT_FALSE(target.GetServerUniquePosition().IsValid());
   UpdateServerFieldsFromUpdate(&target, update, "name");
 
   // After update, target has valid bookmark tag and unique position.
   EXPECT_TRUE(UniquePosition::IsValidSuffix(target.GetUniqueBookmarkTag()));
   EXPECT_TRUE(target.GetServerUniquePosition().IsValid());
 }
 
 TEST_F(GetUpdatePositionTest, UpdateServerFieldsFromInvalidUniquePositionTest) {
   InitSuffixIngredients();  // Initialize update with valid data.
   sync_pb::SyncEntity invalid_update(update);
 
   // Create and Setup an invalid position
   sync_pb::UniquePosition* invalid_position = new sync_pb::UniquePosition();
   invalid_position->set_value("");
   invalid_update.set_allocated_unique_position(invalid_position);
 
   std::string root_server_id = syncable::Id::GetRoot().GetServerId();
-  int64 handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
+  int64_t handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
       "I", DefaultBookmarkSpecifics(), root_server_id);
 
   syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, directory());
   syncable::MutableEntry target(&trans, syncable::GET_BY_HANDLE, handle);
 
   // Before update, target has invalid bookmark tag and unique position.
   EXPECT_FALSE(UniquePosition::IsValidSuffix(target.GetUniqueBookmarkTag()));
   EXPECT_FALSE(target.GetServerUniquePosition().IsValid());
   UpdateServerFieldsFromUpdate(&target, invalid_update, "name");
 
   // After update, target has valid bookmark tag and unique position.
   EXPECT_TRUE(UniquePosition::IsValidSuffix(target.GetUniqueBookmarkTag()));
   EXPECT_TRUE(target.GetServerUniquePosition().IsValid());
 }
 
 }  // namespace syncer