Switch to standard integer types in sync/.

sync/syncable/mutable_entry.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.
 
 #include "sync/syncable/mutable_entry.h"
 
+#include <stdint.h>
+
 #include "base/memory/scoped_ptr.h"
 #include "sync/internal_api/public/base/unique_position.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/scoped_kernel_lock.h"
 #include "sync/syncable/scoped_parent_child_index_updater.h"
 #include "sync/syncable/syncable-inl.h"
 #include "sync/syncable/syncable_changes_version.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/syncable/syncable_write_transaction.h"
 
@@ skipping 79 matching lines @@
 MutableEntry::MutableEntry(WriteTransaction* trans, CreateNewUpdateItem,
                            const Id& id)
     : ModelNeutralMutableEntry(trans, CREATE_NEW_UPDATE_ITEM, id),
       write_transaction_(trans) {}
 
 MutableEntry::MutableEntry(WriteTransaction* trans, GetById, const Id& id)
     : ModelNeutralMutableEntry(trans, GET_BY_ID, id),
       write_transaction_(trans) {
 }
 
-MutableEntry::MutableEntry(WriteTransaction* trans, GetByHandle,
-                           int64 metahandle)
+MutableEntry::MutableEntry(WriteTransaction* trans,
+                           GetByHandle,
+                           int64_t metahandle)
     : ModelNeutralMutableEntry(trans, GET_BY_HANDLE, metahandle),
-      write_transaction_(trans) {
-}
+      write_transaction_(trans) {}
 
 MutableEntry::MutableEntry(WriteTransaction* trans, GetByClientTag,
                            const std::string& tag)
     : ModelNeutralMutableEntry(trans, GET_BY_CLIENT_TAG, tag),
       write_transaction_(trans) {
 }
 
 MutableEntry::MutableEntry(WriteTransaction* trans, GetTypeRoot, ModelType type)
     : ModelNeutralMutableEntry(trans, GET_TYPE_ROOT, type),
       write_transaction_(trans) {
 }
 
-void MutableEntry::PutLocalExternalId(int64 value) {
+void MutableEntry::PutLocalExternalId(int64_t value) {
   DCHECK(kernel_);
   if (kernel_->ref(LOCAL_EXTERNAL_ID) != value) {
     write_transaction()->TrackChangesTo(kernel_);
     ScopedKernelLock lock(dir());
     kernel_->put(LOCAL_EXTERNAL_ID, value);
     MarkDirty();
   }
 }
 
 void MutableEntry::PutMtime(base::Time value) {
@@ skipping 176 matching lines @@
   DCHECK(!e->IsRoot()) << "We shouldn't mark a permanent object for syncing.";
   if (!(e->PutIsUnsynced(true)))
     return false;
   if (e->GetSyncing())
     e->PutDirtySync(true);
   return true;
 }
 
 }  // namespace syncable
 }  // namespace syncer