Switch to standard integer types in google_apis/.

google_apis/gcm/base/mcs_util.cc

 // Copyright 2013 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 "google_apis/gcm/base/mcs_util.h"
 
+#include <stddef.h>
+
 #include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
 
 namespace gcm {
 
 namespace {
 
 // Type names corresponding to MCSProtoTags. Useful for identifying what type
@@ skipping 25 matching lines @@
 const char kLoginDeviceIdPrefix[] = "android-";
 const char kLoginSettingDefaultName[] = "new_vc";
 const char kLoginSettingDefaultValue[] = "1";
 
 // Maximum amount of time to save an unsent outgoing message for.
 const int kMaxTTLSeconds = 24 * 60 * 60;  // 1 day.
 
 }  // namespace
 
 scoped_ptr<mcs_proto::LoginRequest> BuildLoginRequest(
-    uint64 auth_id,
-    uint64 auth_token,
+    uint64_t auth_id,
+    uint64_t auth_token,
     const std::string& version_string) {
   // Create a hex encoded auth id for the device id field.
   std::string auth_id_hex;
   auth_id_hex = base::StringPrintf("%" PRIx64, auth_id);
 
   std::string auth_id_str = base::Uint64ToString(auth_id);
   std::string auth_token_str = base::Uint64ToString(auth_token);
 
   scoped_ptr<mcs_proto::LoginRequest> login_request(
       new mcs_proto::LoginRequest());
@@ skipping 33 matching lines @@
   mcs_proto::SelectiveAck selective_ack;
   for (size_t i = 0; i < acked_ids.size(); ++i)
     selective_ack.add_id(acked_ids[i]);
   selective_ack_iq->mutable_extension()->set_data(
       selective_ack.SerializeAsString());
   return selective_ack_iq.Pass();
 }
 
 // Utility method to build a google::protobuf::MessageLite object from a MCS
 // tag.
-scoped_ptr<google::protobuf::MessageLite> BuildProtobufFromTag(uint8 tag) {
+scoped_ptr<google::protobuf::MessageLite> BuildProtobufFromTag(uint8_t tag) {
   switch(tag) {
     case kHeartbeatPingTag:
       return scoped_ptr<google::protobuf::MessageLite>(
           new mcs_proto::HeartbeatPing());
     case kHeartbeatAckTag:
       return scoped_ptr<google::protobuf::MessageLite>(
           new mcs_proto::HeartbeatAck());
     case kLoginRequestTag:
       return scoped_ptr<google::protobuf::MessageLite>(
           new mcs_proto::LoginRequest());
@@ skipping 60 matching lines @@
         set_persistent_id(persistent_id);
     return;
   } else if (protobuf->GetTypeName() == kProtoNames[kDataMessageStanzaTag]) {
     reinterpret_cast<mcs_proto::DataMessageStanza*>(protobuf)->
         set_persistent_id(persistent_id);
     return;
   }
   NOTREACHED();
 }
 
-uint32 GetLastStreamIdReceived(const google::protobuf::MessageLite& protobuf) {
+uint32_t GetLastStreamIdReceived(
+    const google::protobuf::MessageLite& protobuf) {
   if (protobuf.GetTypeName() == kProtoNames[kIqStanzaTag]) {
     return reinterpret_cast<const mcs_proto::IqStanza*>(&protobuf)->
         last_stream_id_received();
   } else if (protobuf.GetTypeName() == kProtoNames[kDataMessageStanzaTag]) {
     return reinterpret_cast<const mcs_proto::DataMessageStanza*>(&protobuf)->
         last_stream_id_received();
   } else if (protobuf.GetTypeName() == kProtoNames[kHeartbeatPingTag]) {
     return reinterpret_cast<const mcs_proto::HeartbeatPing*>(&protobuf)->
         last_stream_id_received();
   } else if (protobuf.GetTypeName() == kProtoNames[kHeartbeatAckTag]) {
     return reinterpret_cast<const mcs_proto::HeartbeatAck*>(&protobuf)->
         last_stream_id_received();
   } else if (protobuf.GetTypeName() == kProtoNames[kLoginResponseTag]) {
     return reinterpret_cast<const mcs_proto::LoginResponse*>(&protobuf)->
         last_stream_id_received();
   }
   // Not all message types have last stream ids. Just return 0.
   return 0;
 }
 
-void SetLastStreamIdReceived(uint32 val,
+void SetLastStreamIdReceived(uint32_t val,
                              google::protobuf::MessageLite* protobuf) {
   if (protobuf->GetTypeName() == kProtoNames[kIqStanzaTag]) {
     reinterpret_cast<mcs_proto::IqStanza*>(protobuf)->
         set_last_stream_id_received(val);
     return;
   } else if (protobuf->GetTypeName() == kProtoNames[kHeartbeatPingTag]) {
     reinterpret_cast<mcs_proto::HeartbeatPing*>(protobuf)->
         set_last_stream_id_received(val);
     return;
   } else if (protobuf->GetTypeName() == kProtoNames[kHeartbeatAckTag]) {
     reinterpret_cast<mcs_proto::HeartbeatAck*>(protobuf)->
         set_last_stream_id_received(val);
     return;
   } else if (protobuf->GetTypeName() == kProtoNames[kDataMessageStanzaTag]) {
     reinterpret_cast<mcs_proto::DataMessageStanza*>(protobuf)->
         set_last_stream_id_received(val);
     return;
   } else if (protobuf->GetTypeName() == kProtoNames[kLoginResponseTag]) {
     reinterpret_cast<mcs_proto::LoginResponse*>(protobuf)->
         set_last_stream_id_received(val);
     return;
   }
   NOTREACHED();
 }
 
 bool HasTTLExpired(const google::protobuf::MessageLite& protobuf,
                    base::Clock* clock) {
   if (protobuf.GetTypeName() != kProtoNames[kDataMessageStanzaTag])
     return false;
-  uint64 ttl = GetTTL(protobuf);
-  uint64 sent =
+  uint64_t ttl = GetTTL(protobuf);
+  uint64_t sent =
       reinterpret_cast<const mcs_proto::DataMessageStanza*>(&protobuf)->sent();
   DCHECK(sent);
   return ttl > 0 &&
       clock->Now() >
           base::Time::FromInternalValue(
               (sent + ttl) * base::Time::kMicrosecondsPerSecond);
 }
 
 int GetTTL(const google::protobuf::MessageLite& protobuf) {
   if (protobuf.GetTypeName() != kProtoNames[kDataMessageStanzaTag])
     return 0;
   const mcs_proto::DataMessageStanza* data_message =
       reinterpret_cast<const mcs_proto::DataMessageStanza*>(&protobuf);
   if (!data_message->has_ttl())
     return kMaxTTLSeconds;
   DCHECK_LE(data_message->ttl(), kMaxTTLSeconds);
   return data_message->ttl();
 }
 
 bool IsImmediateAckRequested(const google::protobuf::MessageLite& protobuf) {
   if (protobuf.GetTypeName() != kProtoNames[kDataMessageStanzaTag])
     return false;
   const mcs_proto::DataMessageStanza* data_message =
       reinterpret_cast<const mcs_proto::DataMessageStanza*>(&protobuf);
   return data_message->has_immediate_ack() && data_message->immediate_ack();
 }
 
 }  // namespace gcm