Switch to standard integer types in google_apis/.

google_apis/gcm/engine/mcs_client.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/engine/mcs_client.h"
 
+#include <stddef.h>
+
 #include <set>
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/base/socket_stream.h"
@@ skipping 59 matching lines @@
   ~CollapseKey();
 
   // Comparison operator for use in maps.
   bool operator<(const CollapseKey& right) const;
 
   // Whether the message had a valid collapse key.
   bool IsValid() const;
 
   std::string token() const { return token_; }
   std::string app_id() const { return app_id_; }
-  int64 device_user_id() const { return device_user_id_; }
+  int64_t device_user_id() const { return device_user_id_; }
 
  private:
   const std::string token_;
   const std::string app_id_;
-  const int64 device_user_id_;
+  const int64_t device_user_id_;
 };
 
 CollapseKey::CollapseKey(const mcs_proto::DataMessageStanza& message)
     : token_(message.token()),
       app_id_(message.category()),
       device_user_id_(message.device_user_id()) {}
 
 CollapseKey::~CollapseKey() {}
 
 bool CollapseKey::IsValid() const {
   // Device user id is optional, but the application id and token are not.
   return !token_.empty() && !app_id_.empty();
 }
 
 bool CollapseKey::operator<(const CollapseKey& right) const {
   if (device_user_id_ != right.device_user_id())
     return device_user_id_ < right.device_user_id();
   if (app_id_ != right.app_id())
     return app_id_ < right.app_id();
   return token_ < right.token();
 }
 
 struct ReliablePacketInfo {
   ReliablePacketInfo();
   ~ReliablePacketInfo();
 
   // The stream id with which the message was sent.
-  uint32 stream_id;
+  uint32_t stream_id;
 
   // If reliable delivery was requested, the persistent id of the message.
   std::string persistent_id;
 
   // The type of message itself (for easier lookup).
-  uint8 tag;
+  uint8_t tag;
 
   // The protobuf of the message itself.
   MCSProto protobuf;
 };
 
 ReliablePacketInfo::ReliablePacketInfo()
   : stream_id(0), tag(0) {
 }
 ReliablePacketInfo::~ReliablePacketInfo() {}
 
@@ skipping 81 matching lines @@
                                  << " is non-zero.";
 
   DVLOG(1) << "RMQ Load finished with " << load_result->incoming_messages.size()
            << " incoming acks pending and "
            << load_result->outgoing_messages.size()
            << " outgoing messages pending.";
 
   restored_unackeds_server_ids_ = load_result->incoming_messages;
 
   // First go through and order the outgoing messages by recency.
-  std::map<uint64, google::protobuf::MessageLite*> ordered_messages;
+  std::map<uint64_t, google::protobuf::MessageLite*> ordered_messages;
   std::vector<PersistentId> expired_ttl_ids;
   for (GCMStore::OutgoingMessageMap::iterator iter =
            load_result->outgoing_messages.begin();
        iter != load_result->outgoing_messages.end(); ++iter) {
-    uint64 timestamp = 0;
+    uint64_t timestamp = 0;
     if (!base::StringToUint64(iter->first, &timestamp)) {
       LOG(ERROR) << "Invalid restored message.";
       // TODO(fgorski): Error: data unreadable
       mcs_error_callback_.Run();
       return;
     }
 
     // Check if the TTL has expired for this message.
     if (HasTTLExpired(*iter->second, clock_)) {
       expired_ttl_ids.push_back(iter->first);
       NotifyMessageSendStatus(*iter->second, TTL_EXCEEDED);
       continue;
     }
 
     ordered_messages[timestamp] = iter->second.release();
   }
 
   if (!expired_ttl_ids.empty()) {
     gcm_store_->RemoveOutgoingMessages(
         expired_ttl_ids,
         base::Bind(&MCSClient::OnGCMUpdateFinished,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // Now go through and add the outgoing messages to the send queue in their
   // appropriate order (oldest at front, most recent at back).
-  for (std::map<uint64, google::protobuf::MessageLite*>::iterator
-           iter = ordered_messages.begin();
+  for (std::map<uint64_t, google::protobuf::MessageLite*>::iterator iter =
+           ordered_messages.begin();
        iter != ordered_messages.end(); ++iter) {
     ReliablePacketInfo* packet_info = new ReliablePacketInfo();
     packet_info->protobuf.reset(iter->second);
     packet_info->tag = GetMCSProtoTag(*iter->second);
     packet_info->persistent_id = base::Uint64ToString(iter->first);
     to_send_.push_back(make_linked_ptr(packet_info));
 
     if (packet_info->tag == kDataMessageStanzaTag) {
       mcs_proto::DataMessageStanza* data_message =
           reinterpret_cast<mcs_proto::DataMessageStanza*>(
               packet_info->protobuf.get());
       CollapseKey collapse_key(*data_message);
       if (collapse_key.IsValid())
         collapse_key_map_[collapse_key] = packet_info;
     }
   }
 
   // Establish if there is any custom client interval persisted from the last
   // run and set it on the heartbeat manager.
   custom_heartbeat_intervals_.swap(load_result->heartbeat_intervals);
   int min_interval_ms = GetMinHeartbeatIntervalMs();
   heartbeat_manager_.SetClientHeartbeatIntervalMs(min_interval_ms);
 }
 
-void MCSClient::Login(uint64 android_id, uint64 security_token) {
+void MCSClient::Login(uint64_t android_id, uint64_t security_token) {
   DCHECK_EQ(state_, LOADED);
   DCHECK(android_id_ == 0 || android_id_ == android_id);
   DCHECK(security_token_ == 0 || security_token_ == security_token);
 
   if (android_id != android_id_ && security_token != security_token_) {
     DCHECK(android_id);
     DCHECK(security_token);
     android_id_ = android_id;
     security_token_ = security_token;
   }
@@ skipping 260 matching lines @@
 
 void MCSClient::SendPacketToWire(ReliablePacketInfo* packet_info) {
   packet_info->stream_id = ++stream_id_out_;
   DVLOG(1) << "Sending packet of type " << packet_info->protobuf->GetTypeName();
 
   // Set the queued time as necessary.
   if (packet_info->tag == kDataMessageStanzaTag) {
     mcs_proto::DataMessageStanza* data_message =
         reinterpret_cast<mcs_proto::DataMessageStanza*>(
             packet_info->protobuf.get());
-    uint64 sent = data_message->sent();
+    uint64_t sent = data_message->sent();
     DCHECK_GT(sent, 0U);
     int queued = (clock_->Now().ToInternalValue() /
         base::Time::kMicrosecondsPerSecond) - sent;
     DVLOG(1) << "Message was queued for " << queued << " seconds.";
     data_message->set_queued(queued);
     recorder_->RecordDataSentToWire(
         data_message->category(),
         data_message->to(),
         data_message->id(),
         queued);
@@ skipping 52 matching lines @@
 
   if (send) {
     SendMessage(MCSMessage(kDataMessageStanzaTag, response.Pass()));
   }
 }
 
 void MCSClient::HandlePacketFromWire(
     scoped_ptr<google::protobuf::MessageLite> protobuf) {
   if (!protobuf.get())
     return;
-  uint8 tag = GetMCSProtoTag(*protobuf);
+  uint8_t tag = GetMCSProtoTag(*protobuf);
   PersistentId persistent_id = GetPersistentId(*protobuf);
   StreamId last_stream_id_received = GetLastStreamIdReceived(*protobuf);
 
   if (last_stream_id_received != 0) {
     last_device_to_server_stream_id_received_ = last_stream_id_received;
 
     // Process device to server messages that have now been acknowledged by the
     // server. Because messages are stored in order, just pop off all that have
     // a stream id lower than server's last received stream id.
     HandleStreamAck(last_stream_id_received);
@@ skipping 311 matching lines @@
         reinterpret_cast<mcs_proto::DataMessageStanza*>(packet->protobuf.get());
     CollapseKey collapse_key(*data_message);
     if (collapse_key.IsValid())
       collapse_key_map_.erase(collapse_key);
   }
 
   return packet;
 }
 
 } // namespace gcm