Switch to standard integer types in sync/.

sync/syncable/entry_kernel.h

 // 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.
 
 #ifndef SYNC_SYNCABLE_ENTRY_KERNEL_H_
 #define SYNC_SYNCABLE_ENTRY_KERNEL_H_
 
+#include <stdint.h>
+
 #include <algorithm>
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/time/time.h"
 #include "base/values.h"
 #include "sync/base/sync_export.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/base/unique_position.h"
@@ skipping 15 matching lines @@
 //  - EntryKernel struct in this file
 //  - syncable_columns.h
 //  - syncable_enum_conversions{.h,.cc,_unittest.cc}
 //  - EntryKernel::EntryKernel(), EntryKernel::ToValue() in entry_kernel.cc
 //  - operator<< in Entry.cc
 //  - BindFields() and UnpackEntry() in directory_backing_store.cc
 //  - kCurrentDBVersion, DirectoryBackingStore::InitializeTables in
 //    directory_backing_store.cc
 //  - TestSimpleFieldsPreservedDuringSaveChanges in syncable_unittest.cc
 
-static const int64 kInvalidMetaHandle = 0;
+static const int64_t kInvalidMetaHandle = 0;
 
 enum {
   BEGIN_FIELDS = 0,
   INT64_FIELDS_BEGIN = BEGIN_FIELDS
 };
 
 enum MetahandleField {
   // Primary key into the table.  Keep this as a handle to the meta entry
   // across transactions.
   META_HANDLE = INT64_FIELDS_BEGIN
@@ skipping 143 matching lines @@
 };
 
 struct SYNC_EXPORT EntryKernel {
  private:
   typedef syncer::ProtoValuePtr<sync_pb::EntitySpecifics> EntitySpecificsPtr;
   typedef syncer::ProtoValuePtr<sync_pb::AttachmentMetadata>
       AttachmentMetadataPtr;
 
   std::string string_fields[STRING_FIELDS_COUNT];
   EntitySpecificsPtr specifics_fields[PROTO_FIELDS_COUNT];
-  int64 int64_fields[INT64_FIELDS_COUNT];
+  int64_t int64_fields[INT64_FIELDS_COUNT];
   base::Time time_fields[TIME_FIELDS_COUNT];
   Id id_fields[ID_FIELDS_COUNT];
   UniquePosition unique_position_fields[UNIQUE_POSITION_FIELDS_COUNT];
   AttachmentMetadataPtr
       attachment_metadata_fields[ATTACHMENT_METADATA_FIELDS_COUNT];
   std::bitset<BIT_FIELDS_COUNT> bit_fields;
   std::bitset<BIT_TEMPS_COUNT> bit_temps;
 
   friend std::ostream& operator<<(std::ostream& s, const EntryKernel& e);
 
@@ skipping 21 matching lines @@
       dirty_index->erase(ref(META_HANDLE));
     }
     dirty_ = false;
   }
 
   inline bool is_dirty() const {
     return dirty_;
   }
 
   // Setters.
-  inline void put(MetahandleField field, int64 value) {
+  inline void put(MetahandleField field, int64_t value) {
     int64_fields[field - INT64_FIELDS_BEGIN] = value;
   }
-  inline void put(Int64Field field, int64 value) {
+  inline void put(Int64Field field, int64_t value) {
     int64_fields[field - INT64_FIELDS_BEGIN] = value;
   }
   inline void put(TimeField field, const base::Time& value) {
     // Round-trip to proto time format and back so that we have
     // consistent time resolutions (ms).
     time_fields[field - TIME_FIELDS_BEGIN] =
         ProtoTimeToTime(TimeToProtoTime(value));
   }
   inline void put(IdField field, const Id& value) {
     id_fields[field - ID_FIELDS_BEGIN] = value;
   }
-  inline void put(BaseVersion field, int64 value) {
+  inline void put(BaseVersion field, int64_t value) {
     int64_fields[field - INT64_FIELDS_BEGIN] = value;
   }
   inline void put(IndexedBitField field, bool value) {
     bit_fields[field - BIT_FIELDS_BEGIN] = value;
   }
   inline void put(IsDelField field, bool value) {
     bit_fields[field - BIT_FIELDS_BEGIN] = value;
   }
   inline void put(BitField field, bool value) {
     bit_fields[field - BIT_FIELDS_BEGIN] = value;
@@ skipping 10 matching lines @@
   inline void put(AttachmentMetadataField field,
                   const sync_pb::AttachmentMetadata& value) {
     attachment_metadata_fields[field - ATTACHMENT_METADATA_FIELDS_BEGIN]
         .set_value(value);
   }
   inline void put(BitTemp field, bool value) {
     bit_temps[field - BIT_TEMPS_BEGIN] = value;
   }
 
   // Const ref getters.
-  inline int64 ref(MetahandleField field) const {
+  inline int64_t ref(MetahandleField field) const {
     return int64_fields[field - INT64_FIELDS_BEGIN];
   }
-  inline int64 ref(Int64Field field) const {
+  inline int64_t ref(Int64Field field) const {
     return int64_fields[field - INT64_FIELDS_BEGIN];
   }
   inline const base::Time& ref(TimeField field) const {
     return time_fields[field - TIME_FIELDS_BEGIN];
   }
   inline const Id& ref(IdField field) const {
     return id_fields[field - ID_FIELDS_BEGIN];
   }
-  inline int64 ref(BaseVersion field) const {
+  inline int64_t ref(BaseVersion field) const {
     return int64_fields[field - INT64_FIELDS_BEGIN];
   }
   inline bool ref(IndexedBitField field) const {
     return bit_fields[field - BIT_FIELDS_BEGIN];
   }
   inline bool ref(IsDelField field) const {
     return bit_fields[field - BIT_FIELDS_BEGIN];
   }
   inline bool ref(BitField field) const {
     return bit_fields[field - BIT_FIELDS_BEGIN];
@@ skipping 77 matching lines @@
   }
 };
 
 typedef std::set<const EntryKernel*, EntryKernelLessByMetaHandle>
     EntryKernelSet;
 
 struct EntryKernelMutation {
   EntryKernel original, mutated;
 };
 
-typedef std::map<int64, EntryKernelMutation> EntryKernelMutationMap;
+typedef std::map<int64_t, EntryKernelMutation> EntryKernelMutationMap;
 
 typedef Immutable<EntryKernelMutationMap> ImmutableEntryKernelMutationMap;
 
 // Caller owns the return value.
 base::DictionaryValue* EntryKernelMutationToValue(
     const EntryKernelMutation& mutation);
 
 // Caller owns the return value.
 base::ListValue* EntryKernelMutationMapToValue(
     const EntryKernelMutationMap& mutations);
 
 std::ostream& operator<<(std::ostream& os, const EntryKernel& entry_kernel);
 
 }  // namespace syncable
 }  // namespace syncer
 
 #endif  // SYNC_SYNCABLE_ENTRY_KERNEL_H_