Switch to standard integer types in sync/.

sync/engine/entity_tracker.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/entity_tracker.h"
 
+#include <stdint.h>
+
 #include "base/logging.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/non_blocking_sync_common.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/util/time.h"
 
 namespace syncer_v2 {
 
 scoped_ptr<EntityTracker> EntityTracker::FromUpdateResponse(
     const UpdateResponseData& data) {
   return make_scoped_ptr(new EntityTracker(
       data.entity->id, data.entity->client_tag_hash, 0, data.response_version));
 }
 
 scoped_ptr<EntityTracker> EntityTracker::FromCommitRequest(
     const CommitRequestData& data) {
   return make_scoped_ptr(
       new EntityTracker(data.entity->id, data.entity->client_tag_hash, 0, 0));
 }
 
 EntityTracker::EntityTracker(const std::string& id,
                              const std::string& client_tag_hash,
-                             int64 highest_commit_response_version,
-                             int64 highest_gu_response_version)
+                             int64_t highest_commit_response_version,
+                             int64_t highest_gu_response_version)
     : id_(id),
       client_tag_hash_(client_tag_hash),
       highest_commit_response_version_(highest_commit_response_version),
       highest_gu_response_version_(highest_gu_response_version),
       sequence_number_(0),
       base_version_(kUncommittedVersion) {}
 
 EntityTracker::~EntityTracker() {}
 
 bool EntityTracker::HasPendingCommit() const {
   return !!pending_commit_;
 }
 
 void EntityTracker::PrepareCommitProto(sync_pb::SyncEntity* commit_entity,
-                                       int64* sequence_number) const {
+                                       int64_t* sequence_number) const {
   DCHECK(HasPendingCommit());
   DCHECK(!client_tag_hash_.empty());
 
   if (!id_.empty()) {
     commit_entity->set_id_string(id_);
   }
 
   const EntityData& entity = pending_commit_->entity.value();
   DCHECK_EQ(client_tag_hash_, entity.client_tag_hash);
 
@@ skipping 52 matching lines @@
   if (IsInConflict()) {
     ClearPendingCommit();
     return;
   }
 
   // Otherwise, keep the data associated with this pending commit
   // so it can be committed at the next possible opportunity.
 }
 
 void EntityTracker::ReceiveCommitResponse(const std::string& response_id,
-                                          int64 response_version,
-                                          int64 sequence_number) {
+                                          int64_t response_version,
+                                          int64_t sequence_number) {
   // Commit responses, especially after the first commit, can update our ID.
   id_ = response_id;
 
   DCHECK_GT(response_version, highest_commit_response_version_)
       << "Had expected higher response version."
       << " id: " << id_;
 
   // Commits are synchronous, so there's no reason why the sequence numbers
   // wouldn't match.
   DCHECK_EQ(sequence_number_, sequence_number)
       << "Unexpected sequence number mismatch."
       << " id: " << id_;
 
   highest_commit_response_version_ = response_version;
 
   // Because an in-progress commit blocks the sync thread, we can assume that
   // the item we just committed successfully is exactly the one we have now.
   // Nothing changed it while the commit was happening.  Since we're now in
   // sync with the server, we can clear the pending commit.
   ClearPendingCommit();
 }
 
-void EntityTracker::ReceiveUpdate(int64 version) {
+void EntityTracker::ReceiveUpdate(int64_t version) {
   if (version <= highest_gu_response_version_)
     return;
 
   highest_gu_response_version_ = version;
 
   // Got an applicable update newer than any pending updates.  It must be safe
   // to discard the old pending update, if there was one.
   ClearPendingUpdate();
 
   if (IsInConflict()) {
@@ skipping 50 matching lines @@
 
 bool EntityTracker::IsServerKnown() const {
   return base_version_ != kUncommittedVersion;
 }
 
 void EntityTracker::ClearPendingCommit() {
   pending_commit_.reset();
 }
 
 }  // namespace syncer_v2