Switch to standard integer types in sync/.

sync/test/engine/mock_connection_manager.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.
 //
 // Mock ServerConnectionManager class for use in client regression tests.
 
 #include "sync/test/engine/mock_connection_manager.h"
 
+#include <stdint.h>
+
 #include <map>
 
 #include "base/location.h"
 #include "base/strings/stringprintf.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/syncable_write_transaction.h"
 #include "sync/test/engine/test_id_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 188 matching lines @@
       entity->mutable_specifics()->mutable_bookmark()->
           set_url("http://google.com");
     }
   }
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
     int id,
     int parent_id,
     const string& name,
-    int64 version,
-    int64 sync_ts,
+    int64_t version,
+    int64_t sync_ts,
     const std::string& originator_cache_guid,
     const std::string& originator_client_item_id) {
   return AddUpdateDirectory(TestIdFactory::FromNumber(id),
                             TestIdFactory::FromNumber(parent_id),
                             name,
                             version,
                             sync_ts,
                             originator_cache_guid,
                             originator_client_item_id);
 }
 
 void MockConnectionManager::SetGUClientCommand(
     sync_pb::ClientCommand* command) {
   gu_client_command_.reset(command);
 }
 
 void MockConnectionManager::SetCommitClientCommand(
     sync_pb::ClientCommand* command) {
   commit_client_command_.reset(command);
 }
 
 void MockConnectionManager::SetTransientErrorId(syncable::Id id) {
   transient_error_ids_.push_back(id);
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
     int id,
     int parent_id,
     const string& name,
-    int64 version,
-    int64 sync_ts,
+    int64_t version,
+    int64_t sync_ts,
     const string& originator_client_item_id,
     const string& originator_cache_guid) {
   return AddUpdateBookmark(TestIdFactory::FromNumber(id),
                            TestIdFactory::FromNumber(parent_id),
                            name,
                            version,
                            sync_ts,
                            originator_client_item_id,
                            originator_cache_guid);
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateSpecifics(
     int id,
     int parent_id,
     const string& name,
-    int64 version,
-    int64 sync_ts,
+    int64_t version,
+    int64_t sync_ts,
     bool is_dir,
-    int64 position,
+    int64_t position,
     const sync_pb::EntitySpecifics& specifics) {
   sync_pb::SyncEntity* ent = AddUpdateMeta(
       TestIdFactory::FromNumber(id).GetServerId(),
       TestIdFactory::FromNumber(parent_id).GetServerId(),
       name, version, sync_ts);
   ent->set_position_in_parent(position);
   ent->mutable_specifics()->CopyFrom(specifics);
   ent->set_folder(is_dir);
   return ent;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateSpecifics(
     int id,
     int parent_id,
     const string& name,
-    int64 version,
-    int64 sync_ts,
+    int64_t version,
+    int64_t sync_ts,
     bool is_dir,
-    int64 position,
+    int64_t position,
     const sync_pb::EntitySpecifics& specifics,
     const string& originator_cache_guid,
     const string& originator_client_item_id) {
   sync_pb::SyncEntity* ent = AddUpdateSpecifics(
       id, parent_id, name, version, sync_ts, is_dir, position, specifics);
   ent->set_originator_cache_guid(originator_cache_guid);
   ent->set_originator_client_item_id(originator_client_item_id);
   return ent;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::SetNigori(
     int id,
-    int64 version,
-    int64 sync_ts,
+    int64_t version,
+    int64_t sync_ts,
     const sync_pb::EntitySpecifics& specifics) {
   sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
   ent->set_id_string(TestIdFactory::FromNumber(id).GetServerId());
   ent->set_parent_id_string(TestIdFactory::FromNumber(0).GetServerId());
   ent->set_server_defined_unique_tag(ModelTypeToRootTag(NIGORI));
   ent->set_name("Nigori");
   ent->set_non_unique_name("Nigori");
   ent->set_version(version);
   ent->set_sync_timestamp(sync_ts);
   ent->set_mtime(sync_ts);
   ent->set_ctime(1);
   ent->set_position_in_parent(0);
   ent->set_folder(false);
   ent->mutable_specifics()->CopyFrom(specifics);
   return ent;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdatePref(
     const string& id,
     const string& parent_id,
     const string& client_tag,
-    int64 version,
-    int64 sync_ts) {
+    int64_t version,
+    int64_t sync_ts) {
   sync_pb::SyncEntity* ent =
       AddUpdateMeta(id, parent_id, " ", version, sync_ts);
 
   ent->set_client_defined_unique_tag(client_tag);
 
   sync_pb::EntitySpecifics specifics;
   AddDefaultFieldValue(PREFERENCES, &specifics);
   ent->mutable_specifics()->CopyFrom(specifics);
 
   return ent;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateFull(
     const string& id,
     const string& parent_id,
     const string& name,
-    int64 version,
-    int64 sync_ts,
+    int64_t version,
+    int64_t sync_ts,
     bool is_dir) {
   sync_pb::SyncEntity* ent =
       AddUpdateMeta(id, parent_id, name, version, sync_ts);
   AddDefaultBookmarkData(ent, is_dir);
   return ent;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateMeta(
     const string& id,
     const string& parent_id,
     const string& name,
-    int64 version,
-    int64 sync_ts) {
+    int64_t version,
+    int64_t sync_ts) {
   sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
   ent->set_id_string(id);
   ent->set_parent_id_string(parent_id);
   ent->set_non_unique_name(name);
   ent->set_name(name);
   ent->set_version(version);
   ent->set_sync_timestamp(sync_ts);
   ent->set_mtime(sync_ts);
   ent->set_ctime(1);
   ent->set_position_in_parent(GeneratePositionInParent());
@@ skipping 10 matching lines @@
   ent->set_originator_cache_guid(kCacheGuid);
   ent->set_originator_client_item_id(id);
 
   return ent;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
     const string& id,
     const string& parent_id,
     const string& name,
-    int64 version,
-    int64 sync_ts,
+    int64_t version,
+    int64_t sync_ts,
     const std::string& originator_cache_guid,
     const std::string& originator_client_item_id) {
   sync_pb::SyncEntity* ret =
       AddUpdateFull(id, parent_id, name, version, sync_ts, true);
   ret->set_originator_cache_guid(originator_cache_guid);
   ret->set_originator_client_item_id(originator_client_item_id);
   return ret;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
     const string& id,
     const string& parent_id,
     const string& name,
-    int64 version,
-    int64 sync_ts,
+    int64_t version,
+    int64_t sync_ts,
     const string& originator_cache_guid,
     const string& originator_client_item_id) {
   sync_pb::SyncEntity* ret =
       AddUpdateFull(id, parent_id, name, version, sync_ts, false);
   ret->set_originator_cache_guid(originator_cache_guid);
   ret->set_originator_client_item_id(originator_client_item_id);
   return ret;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateFromLastCommit() {
@@ skipping 65 matching lines @@
 }
 
 void MockConnectionManager::SetLastUpdateServerTag(const string& tag) {
   GetMutableLastUpdate()->set_server_defined_unique_tag(tag);
 }
 
 void MockConnectionManager::SetLastUpdateClientTag(const string& tag) {
   GetMutableLastUpdate()->set_client_defined_unique_tag(tag);
 }
 
-void MockConnectionManager::SetLastUpdatePosition(int64 server_position) {
+void MockConnectionManager::SetLastUpdatePosition(int64_t server_position) {
   GetMutableLastUpdate()->set_position_in_parent(server_position);
 }
 
 void MockConnectionManager::SetNewTimestamp(int ts) {
   next_token_ = base::StringPrintf("mock connection ts = %d", ts);
   ApplyToken();
 }
 
 sync_pb::DataTypeProgressMarker*
 MockConnectionManager::AddUpdateProgressMarker() {
   return GetUpdateResponse()->add_new_progress_marker();
 }
 
 void MockConnectionManager::ApplyToken() {
   if (!update_queue_.empty()) {
     GetUpdateResponse()->clear_new_progress_marker();
     sync_pb::DataTypeProgressMarker* new_marker = AddUpdateProgressMarker();
     new_marker->set_data_type_id(-1);  // Invalid -- clients shouldn't see.
     new_marker->set_token(next_token_);
   }
 }
 
-void MockConnectionManager::SetChangesRemaining(int64 timestamp) {
+void MockConnectionManager::SetChangesRemaining(int64_t timestamp) {
   GetUpdateResponse()->set_changes_remaining(timestamp);
 }
 
 void MockConnectionManager::ProcessGetUpdates(
     sync_pb::ClientToServerMessage* csm,
     sync_pb::ClientToServerResponse* response) {
   CHECK(csm->has_get_updates());
   ASSERT_EQ(csm->message_contents(), ClientToServerMessage::GET_UPDATES);
   const GetUpdatesMessage& gu = csm->get_updates();
   num_get_updates_requests_++;
@@ skipping 140 matching lines @@
     sync_pb::ClientToServerResponse* response) {
   CHECK(csm->has_clear_server_data());
   ASSERT_EQ(csm->message_contents(), ClientToServerMessage::CLEAR_SERVER_DATA);
   response->mutable_clear_server_data();
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
     syncable::Id id,
     syncable::Id parent_id,
     const string& name,
-    int64 version,
-    int64 sync_ts,
+    int64_t version,
+    int64_t sync_ts,
     const string& originator_cache_guid,
     const string& originator_client_item_id) {
   return AddUpdateDirectory(id.GetServerId(), parent_id.GetServerId(),
                             name, version, sync_ts, originator_cache_guid,
                             originator_client_item_id);
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
     syncable::Id id,
     syncable::Id parent_id,
     const string& name,
-    int64 version,
-    int64 sync_ts,
+    int64_t version,
+    int64_t sync_ts,
     const string& originator_cache_guid,
     const string& originator_client_item_id) {
   return AddUpdateBookmark(id.GetServerId(), parent_id.GetServerId(),
                            name, version, sync_ts, originator_cache_guid,
                            originator_client_item_id);
 }
 
 sync_pb::SyncEntity* MockConnectionManager::GetMutableLastUpdate() {
   sync_pb::GetUpdatesResponse* updates = GetUpdateResponse();
   EXPECT_GT(updates->entries_size(), 0);
@@ skipping 69 matching lines @@
     server_status_ = HttpResponse::SERVER_CONNECTION_OK;
   }
 }
 
 void MockConnectionManager::SetServerStatus(
     HttpResponse::ServerConnectionCode server_status) {
   server_status_ = server_status;
 }
 
 }  // namespace syncer