Switch to standard integer types in sync/.

sync/internal_api/base_node.cc

 // Copyright (c) 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/internal_api/public/base_node.h"
 
+#include <stdint.h>
+
 #include <stack>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "sync/internal_api/public/base_transaction.h"
 #include "sync/internal_api/syncapi_internal.h"
 #include "sync/protocol/app_specifics.pb.h"
 #include "sync/protocol/autofill_specifics.pb.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/protocol/extension_specifics.pb.h"
 #include "sync/protocol/nigori_specifics.pb.h"
 #include "sync/protocol/password_specifics.pb.h"
 #include "sync/protocol/session_specifics.pb.h"
 #include "sync/protocol/theme_specifics.pb.h"
 #include "sync/protocol/typed_url_specifics.pb.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/syncable_base_transaction.h"
 #include "sync/syncable/syncable_id.h"
 #include "sync/util/time.h"
 
 using sync_pb::AutofillProfileSpecifics;
 
 namespace syncer {
 
 using syncable::SPECIFICS;
 
-// Helper function to look up the int64 metahandle of an object given the ID
+// Helper function to look up the int64_t metahandle of an object given the ID
 // string.
-static int64 IdToMetahandle(syncable::BaseTransaction* trans,
-                            const syncable::Id& id) {
+static int64_t IdToMetahandle(syncable::BaseTransaction* trans,
+                              const syncable::Id& id) {
   if (id.IsNull())
     return kInvalidId;
   syncable::Entry entry(trans, syncable::GET_BY_ID, id);
   if (!entry.good())
     return kInvalidId;
   return entry.GetMetahandle();
 }
 
 BaseNode::BaseNode() : password_data_(new sync_pb::PasswordSpecificsData) {}
 
@@ skipping 85 matching lines @@
         DCHECK_EQ(GetModelTypeFromSpecifics(unencrypted_data_), BOOKMARKS);
         return unencrypted_data_;
       }
     } else {
       DCHECK_EQ(GetModelTypeFromSpecifics(unencrypted_data_), UNSPECIFIED);
       return specifics;
     }
   }
 }
 
-int64 BaseNode::GetParentId() const {
+int64_t BaseNode::GetParentId() const {
   return IdToMetahandle(GetTransaction()->GetWrappedTrans(),
                         GetEntry()->GetParentId());
 }
 
-int64 BaseNode::GetId() const {
+int64_t BaseNode::GetId() const {
   return GetEntry()->GetMetahandle();
 }
 
 base::Time BaseNode::GetModificationTime() const {
   return GetEntry()->GetMtime();
 }
 
 bool BaseNode::GetIsFolder() const {
   return GetEntry()->GetIsDir();
 }
@@ skipping 20 matching lines @@
   }
   return result;
 }
 
 bool BaseNode::HasChildren() const {
   syncable::Directory* dir = GetTransaction()->GetDirectory();
   syncable::BaseTransaction* trans = GetTransaction()->GetWrappedTrans();
   return dir->HasChildren(trans, GetEntry()->GetId());
 }
 
-int64 BaseNode::GetPredecessorId() const {
+int64_t BaseNode::GetPredecessorId() const {
   syncable::Id id_string = GetEntry()->GetPredecessorId();
   if (id_string.IsNull())
     return kInvalidId;
   return IdToMetahandle(GetTransaction()->GetWrappedTrans(), id_string);
 }
 
-int64 BaseNode::GetSuccessorId() const {
+int64_t BaseNode::GetSuccessorId() const {
   syncable::Id id_string = GetEntry()->GetSuccessorId();
   if (id_string.IsNull())
     return kInvalidId;
   return IdToMetahandle(GetTransaction()->GetWrappedTrans(), id_string);
 }
 
-int64 BaseNode::GetFirstChildId() const {
+int64_t BaseNode::GetFirstChildId() const {
   syncable::Id id_string = GetEntry()->GetFirstChildId();
   if (id_string.IsNull())
     return kInvalidId;
   return IdToMetahandle(GetTransaction()->GetWrappedTrans(), id_string);
 }
 
-void BaseNode::GetChildIds(std::vector<int64>* result) const {
+void BaseNode::GetChildIds(std::vector<int64_t>* result) const {
   GetEntry()->GetChildHandles(result);
 }
 
 int BaseNode::GetTotalNodeCount() const {
   return GetEntry()->GetTotalNodeCount();
 }
 
 int BaseNode::GetPositionIndex() const {
   return GetEntry()->GetPositionIndex();
 }
 
 base::DictionaryValue* BaseNode::ToValue() const {
   return GetEntry()->ToValue(GetTransaction()->GetCryptographer());
 }
 
-int64 BaseNode::GetExternalId() const {
+int64_t BaseNode::GetExternalId() const {
   return GetEntry()->GetLocalExternalId();
 }
 
 const syncable::Id& BaseNode::GetSyncId() const {
   return GetEntry()->GetId();
 }
 
 const sync_pb::BookmarkSpecifics& BaseNode::GetBookmarkSpecifics() const {
   DCHECK_EQ(GetModelType(), BOOKMARKS);
   return GetEntitySpecifics().bookmark();
@@ skipping 41 matching lines @@
     const sync_pb::EntitySpecifics& specifics) {
   ModelType type = GetModelTypeFromSpecifics(specifics);
   DCHECK_NE(UNSPECIFIED, type);
   if (GetModelType() != UNSPECIFIED) {
     DCHECK_EQ(GetModelType(), type);
   }
   unencrypted_data_.CopyFrom(specifics);
 }
 
 }  // namespace syncer