Switch to standard integer types in sync/.

sync/test/engine/mock_commit_queue.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/test/engine/mock_commit_queue.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/logging.h"
 
 namespace syncer_v2 {
 
 MockCommitQueue::MockCommitQueue() {
 }
 
 MockCommitQueue::~MockCommitQueue() {
 }
 
@@ skipping 43 matching lines @@
         return *it;
       }
     }
   }
 
   NOTREACHED() << "Could not find commit for tag hash " << tag_hash << ".";
   return CommitRequestData();
 }
 
 UpdateResponseData MockCommitQueue::UpdateFromServer(
-    int64 version_offset,
+    int64_t version_offset,
     const std::string& tag_hash,
     const sync_pb::EntitySpecifics& specifics) {
   // Overwrite the existing server version if this is the new highest version.
-  int64 old_version = GetServerVersion(tag_hash);
-  int64 version = old_version + version_offset;
+  int64_t old_version = GetServerVersion(tag_hash);
+  int64_t version = old_version + version_offset;
   if (version > old_version) {
     SetServerVersion(tag_hash, version);
   }
 
   EntityData data;
   data.id = GenerateId(tag_hash);
   data.client_tag_hash = tag_hash;
   data.specifics = specifics;
   // These elements should have no effect on behavior, but we set them anyway
   // so we can test they are properly copied around the system if we want to.
   data.creation_time = base::Time::UnixEpoch() + base::TimeDelta::FromDays(1);
   data.modification_time =
       data.creation_time + base::TimeDelta::FromSeconds(version);
   data.non_unique_name = specifics.preference().name();
 
   UpdateResponseData response_data;
   response_data.entity = data.Pass();
   response_data.response_version = version;
   response_data.encryption_key_name = server_encryption_key_name_;
 
   return response_data;
 }
 
 UpdateResponseData MockCommitQueue::TombstoneFromServer(
-    int64 version_offset,
+    int64_t version_offset,
     const std::string& tag_hash) {
-  int64 old_version = GetServerVersion(tag_hash);
-  int64 version = old_version + version_offset;
+  int64_t old_version = GetServerVersion(tag_hash);
+  int64_t version = old_version + version_offset;
   if (version > old_version) {
     SetServerVersion(tag_hash, version);
   }
 
   EntityData data;
   data.id = GenerateId(tag_hash);
   data.client_tag_hash = tag_hash;
   // These elements should have no effect on behavior, but we set them anyway
   // so we can test they are properly copied around the system if we want to.
   data.creation_time = base::Time::UnixEpoch() + base::TimeDelta::FromDays(1);
@@ skipping 22 matching lines @@
     response_data.id = entity.id;
   } else {
     // Otherwise we reuse the ID from the request.
     response_data.id = GenerateId(client_tag_hash);
   }
 
   response_data.client_tag_hash = client_tag_hash;
   response_data.sequence_number = request_data.sequence_number;
 
   // Increment the server version on successful commit.
-  int64 version = GetServerVersion(client_tag_hash);
+  int64_t version = GetServerVersion(client_tag_hash);
   version++;
   SetServerVersion(client_tag_hash, version);
 
   response_data.response_version = version;
 
   return response_data;
 }
 
 void MockCommitQueue::SetServerEncryptionKey(
     const std::string& key_name) {
   server_encryption_key_name_ = key_name;
 }
 
 std::string MockCommitQueue::GenerateId(const std::string& tag_hash) {
   return "FakeId:" + tag_hash;
 }
 
-int64 MockCommitQueue::GetServerVersion(const std::string& tag_hash) {
-  std::map<const std::string, int64>::const_iterator it;
+int64_t MockCommitQueue::GetServerVersion(const std::string& tag_hash) {
+  std::map<const std::string, int64_t>::const_iterator it;
   it = server_versions_.find(tag_hash);
   if (it == server_versions_.end()) {
     return 0;
   } else {
     return it->second;
   }
 }
 
 void MockCommitQueue::SetServerVersion(const std::string& tag_hash,
-                                               int64 version) {
+                                       int64_t version) {
   server_versions_[tag_hash] = version;
 }
 
 }  // namespace syncer_v2