Switch to standard integer types in sync/.

sync/protocol/proto_value_conversions.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.
 
 // Keep this file in sync with the .proto files in this directory.
 
 #include "sync/protocol/proto_value_conversions.h"
 
+#include <stdint.h>
+
 #include <algorithm>
 #include <string>
 
 #include "base/base64.h"
-#include "base/basictypes.h"
 #include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "sync/internal_api/public/base/unique_position.h"
 #include "sync/protocol/app_list_specifics.pb.h"
 #include "sync/protocol/app_notification_specifics.pb.h"
 #include "sync/protocol/app_setting_specifics.pb.h"
 #include "sync/protocol/app_specifics.pb.h"
@@ skipping 19 matching lines @@
 #include "sync/protocol/typed_url_specifics.pb.h"
 #include "sync/protocol/unique_position.pb.h"
 #include "sync/util/time.h"
 
 namespace syncer {
 
 namespace {
 
 // Basic Type -> Value functions.
 
-scoped_ptr<base::StringValue> MakeInt64Value(int64 x) {
+scoped_ptr<base::StringValue> MakeInt64Value(int64_t x) {
   return make_scoped_ptr(new base::StringValue(base::Int64ToString(x)));
 }
 
 // TODO(akalin): Perhaps make JSONWriter support BinaryValue and use
 // that instead of a StringValue.
 std::string Base64EncodeString(const std::string& bytes) {
   std::string bytes_base64;
   base::Base64Encode(bytes, &bytes_base64);
   return bytes_base64;
 }
 
 scoped_ptr<base::StringValue> MakeStringValue(const std::string& str) {
   return make_scoped_ptr(new base::StringValue(str));
 }
 
 // T is the field type, F is either RepeatedField or RepeatedPtrField,
 // and V is a subclass of Value.
 template <class T, class F, class V>
 scoped_ptr<base::ListValue> MakeRepeatedValue(const F& fields,
                                               V (*converter_fn)(T)) {
   scoped_ptr<base::ListValue> list(new base::ListValue());
   for (typename F::const_iterator it = fields.begin(); it != fields.end();
        ++it) {
     list->Append(converter_fn(*it));
   }
   return list;
 }
 
-base::string16 TimestampToString(int64 tm) {
+base::string16 TimestampToString(int64_t tm) {
   return base::TimeFormatShortDateAndTime(syncer::ProtoTimeToTime(tm));
 }
 
 }  // namespace
 
 // Helper macros to reduce the amount of boilerplate.
 
 #define SET_TYPE(field, set_fn, transform)           \
   if (proto.has_##field()) {                         \
     value->set_fn(#field, transform(proto.field())); \
@@ skipping 986 matching lines @@
 #undef SET_BYTES
 #undef SET_INT32
 #undef SET_INT64
 #undef SET_INT64_REP
 #undef SET_STR
 #undef SET_STR_REP
 
 #undef SET_FIELD
 
 }  // namespace syncer