Switch to standard integer types in sync/.

sync/syncable/model_neutral_mutable_entry.cc

 // Copyright 2013 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/syncable/model_neutral_mutable_entry.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 
 #include "sync/internal_api/public/base/unique_position.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/scoped_kernel_lock.h"
 #include "sync/syncable/syncable_changes_version.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/syncable/syncable_write_transaction.h"
 
 using std::string;
@@ skipping 64 matching lines @@
   trans->TrackChangesTo(kernel.get());
 
   kernel_ = kernel.release();
 }
 
 ModelNeutralMutableEntry::ModelNeutralMutableEntry(
     BaseWriteTransaction* trans, GetById, const Id& id)
     : Entry(trans, GET_BY_ID, id), base_write_transaction_(trans) {
 }
 
-ModelNeutralMutableEntry::ModelNeutralMutableEntry(
-    BaseWriteTransaction* trans, GetByHandle, int64 metahandle)
-    : Entry(trans, GET_BY_HANDLE, metahandle), base_write_transaction_(trans) {
-}
+ModelNeutralMutableEntry::ModelNeutralMutableEntry(BaseWriteTransaction* trans,
+                                                   GetByHandle,
+                                                   int64_t metahandle)
+    : Entry(trans, GET_BY_HANDLE, metahandle), base_write_transaction_(trans) {}
 
 ModelNeutralMutableEntry::ModelNeutralMutableEntry(
     BaseWriteTransaction* trans, GetByClientTag, const std::string& tag)
     : Entry(trans, GET_BY_CLIENT_TAG, tag), base_write_transaction_(trans) {
 }
 
 ModelNeutralMutableEntry::ModelNeutralMutableEntry(
     BaseWriteTransaction* trans, GetTypeRoot, ModelType type)
     : Entry(trans, GET_TYPE_ROOT, type), base_write_transaction_(trans) {
 }
 
-void ModelNeutralMutableEntry::PutBaseVersion(int64 value) {
+void ModelNeutralMutableEntry::PutBaseVersion(int64_t value) {
   DCHECK(kernel_);
   if (kernel_->ref(BASE_VERSION) != value) {
     base_write_transaction_->TrackChangesTo(kernel_);
     kernel_->put(BASE_VERSION, value);
     MarkDirty();
   }
 }
 
-void ModelNeutralMutableEntry::PutServerVersion(int64 value) {
+void ModelNeutralMutableEntry::PutServerVersion(int64_t value) {
   DCHECK(kernel_);
   if (kernel_->ref(SERVER_VERSION) != value) {
     base_write_transaction_->TrackChangesTo(kernel_);
     ScopedKernelLock lock(dir());
     kernel_->put(SERVER_VERSION, value);
     MarkDirty();
   }
 }
 
 void ModelNeutralMutableEntry::PutServerMtime(base::Time value) {
@@ skipping 217 matching lines @@
   CHECK(!value.password().has_client_only_encrypted_data());
   // TODO(ncarter): This is unfortunately heavyweight.  Can we do
   // better?
   const std::string& serialized_value = value.SerializeAsString();
   if (serialized_value != kernel_->ref(SERVER_SPECIFICS).SerializeAsString()) {
     base_write_transaction_->TrackChangesTo(kernel_);
     if (kernel_->ref(IS_UNAPPLIED_UPDATE)) {
       // Remove ourselves from unapplied_update_metahandles with our
       // old server type.
       const ModelType old_server_type = kernel_->GetServerModelType();
-      const int64 metahandle = kernel_->ref(META_HANDLE);
+      const int64_t metahandle = kernel_->ref(META_HANDLE);
       size_t erase_count =
           dir()->kernel()->unapplied_update_metahandles[old_server_type]
           .erase(metahandle);
       DCHECK_EQ(erase_count, 1u);
     }
 
     // Check for potential sharing - SERVER_SPECIFICS is often
     // copied from SPECIFICS.
     if (serialized_value == kernel_->ref(SPECIFICS).SerializeAsString()) {
       kernel_->copy(SPECIFICS, SERVER_SPECIFICS);
     } else {
       kernel_->put(SERVER_SPECIFICS, value);
     }
     MarkDirty();
 
     if (kernel_->ref(IS_UNAPPLIED_UPDATE)) {
       // Add ourselves back into unapplied_update_metahandles with our
       // new server type.
       const ModelType new_server_type = kernel_->GetServerModelType();
-      const int64 metahandle = kernel_->ref(META_HANDLE);
+      const int64_t metahandle = kernel_->ref(META_HANDLE);
       dir()->kernel()->unapplied_update_metahandles[new_server_type]
           .insert(metahandle);
     }
   }
 }
 
 void ModelNeutralMutableEntry::PutBaseServerSpecifics(
     const sync_pb::EntitySpecifics& value) {
   DCHECK(kernel_);
   CHECK(!value.password().has_client_only_encrypted_data());
@@ skipping 55 matching lines @@
   DCHECK(!value || GetSyncing());
   kernel_->put(DIRTY_SYNC, value);
 }
 
 void ModelNeutralMutableEntry::PutParentIdPropertyOnly(const Id& parent_id) {
   base_write_transaction_->TrackChangesTo(kernel_);
   dir()->ReindexParentId(base_write_transaction(), kernel_, parent_id);
   MarkDirty();
 }
 
-void ModelNeutralMutableEntry::UpdateTransactionVersion(int64 value) {
+void ModelNeutralMutableEntry::UpdateTransactionVersion(int64_t value) {
   kernel_->put(TRANSACTION_VERSION, value);
   MarkDirty();
 }
 
 ModelNeutralMutableEntry::ModelNeutralMutableEntry(BaseWriteTransaction* trans)
   : Entry(trans), base_write_transaction_(trans) {}
 
 void ModelNeutralMutableEntry::MarkDirty() {
   kernel_->mark_dirty(&dir()->kernel()->dirty_metahandles);
 }
 
 }  // namespace syncable
 
 }  // namespace syncer