Switch to standard integer types in components/, part 2 of 4.

components/invalidation/public/invalidation.cc

 // Copyright 2014 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 "components/invalidation/public/invalidation.h"
 
 #include <cstddef>
 
 #include "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "components/invalidation/public/ack_handler.h"
 #include "components/invalidation/public/invalidation_util.h"
 
 namespace syncer {
 
 namespace {
 const char kObjectIdKey[] = "objectId";
 const char kIsUnknownVersionKey[] = "isUnknownVersion";
 const char kVersionKey[] = "version";
 const char kPayloadKey[] = "payload";
-const int64 kInvalidVersion = -1;
+const int64_t kInvalidVersion = -1;
 }
 
 Invalidation Invalidation::Init(const invalidation::ObjectId& id,
-                                int64 version,
+                                int64_t version,
                                 const std::string& payload) {
   return Invalidation(id, false, version, payload, AckHandle::CreateUnique());
 }
 
 Invalidation Invalidation::InitUnknownVersion(
     const invalidation::ObjectId& id) {
   return Invalidation(
       id, true, kInvalidVersion, std::string(), AckHandle::CreateUnique());
 }
 
@@ skipping 19 matching lines @@
     return scoped_ptr<Invalidation>();
   }
   if (is_unknown_version) {
     return scoped_ptr<Invalidation>(new Invalidation(
         id,
         true,
         kInvalidVersion,
         std::string(),
         AckHandle::CreateUnique()));
   }
-  int64 version = 0;
+  int64_t version = 0;
   std::string version_as_string;
   if (!value.GetString(kVersionKey, &version_as_string)
       || !base::StringToInt64(version_as_string, &version)) {
     DLOG(WARNING) << "Failed to parse version";
     return scoped_ptr<Invalidation>();
   }
   std::string payload;
   if (!value.GetString(kPayloadKey, &payload)) {
     DLOG(WARNING) << "Failed to parse payload";
     return scoped_ptr<Invalidation>();
@@ skipping 10 matching lines @@
 }
 
 invalidation::ObjectId Invalidation::object_id() const {
   return id_;
 }
 
 bool Invalidation::is_unknown_version() const {
   return is_unknown_version_;
 }
 
-int64 Invalidation::version() const {
+int64_t Invalidation::version() const {
   DCHECK(!is_unknown_version_);
   return version_;
 }
 
 const std::string& Invalidation::payload() const {
   DCHECK(!is_unknown_version_);
   return payload_;
 }
 
 const AckHandle& Invalidation::ack_handle() const {
@@ skipping 48 matching lines @@
 std::string Invalidation::ToString() const {
   std::string output;
   JSONStringValueSerializer serializer(&output);
   serializer.set_pretty_print(true);
   serializer.Serialize(*ToValue().get());
   return output;
 }
 
 Invalidation::Invalidation(const invalidation::ObjectId& id,
                            bool is_unknown_version,
-                           int64 version,
+                           int64_t version,
                            const std::string& payload,
                            AckHandle ack_handle)
     : id_(id),
       is_unknown_version_(is_unknown_version),
       version_(version),
       payload_(payload),
-      ack_handle_(ack_handle) {
-}
+      ack_handle_(ack_handle) {}
 
 }  // namespace syncer