Switch to standard integer types in google_apis/.

google_apis/gcm/engine/mcs_client_unittest.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 <stdint.h>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/simple_test_clock.h"
 #include "base/timer/timer.h"
 #include "google_apis/gcm/base/fake_encryptor.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/engine/fake_connection_factory.h"
 #include "google_apis/gcm/engine/fake_connection_handler.h"
 #include "google_apis/gcm/engine/gcm_store_impl.h"
 #include "google_apis/gcm/monitoring/fake_gcm_stats_recorder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gcm {
 
 namespace {
 
-const uint64 kAndroidId = 54321;
-const uint64 kSecurityToken = 12345;
+const uint64_t kAndroidId = 54321;
+const uint64_t kSecurityToken = 12345;
 
 // Number of messages to send when testing batching.
 // Note: must be even for tests that split batches in half.
 const int kMessageBatchSize = 6;
 
 // The number of unacked messages the client will receive before sending a
 // stream ack.
 // TODO(zea): get this (and other constants) directly from the mcs client.
 const int kAckLimitSize = 10;
 
 // TTL value for reliable messages.
 const int kTTLValue = 5 * 60;  // 5 minutes.
 
 // Specifies whether immediate ACK should be requested.
 enum RequestImmediateAck {
   IMMEDIATE_ACK_IGNORE,  // Ignores the field and does not set it.
   IMMEDIATE_ACK_NO,      // Sets the field to false.
   IMMEDIATE_ACK_YES      // Sets the field to true.
 };
 
 // Helper for building arbitrary data messages.
 MCSMessage BuildDataMessage(const std::string& from,
                             const std::string& category,
                             const std::string& message_id,
                             int last_stream_id_received,
                             const std::string& persistent_id,
                             int ttl,
-                            uint64 sent,
+                            uint64_t sent,
                             int queued,
                             const std::string& token,
-                            const uint64& user_id,
+                            const uint64_t& user_id,
                             RequestImmediateAck immediate_ack) {
   mcs_proto::DataMessageStanza data_message;
   data_message.set_id(message_id);
   data_message.set_from(from);
   data_message.set_category(category);
   data_message.set_last_stream_id_received(last_stream_id_received);
   if (!persistent_id.empty())
     data_message.set_persistent_id(persistent_id);
   data_message.set_ttl(ttl);
   data_message.set_sent(sent);
@@ skipping 15 matching lines @@
                 gcm::GCMStatsRecorder* recorder)
     : MCSClient("", clock, connection_factory, gcm_store, recorder),
       next_id_(0) {
   }
 
   std::string GetNextPersistentId() override {
     return base::UintToString(++next_id_);
   }
 
  private:
-  uint32 next_id_;
+  uint32_t next_id_;
 };
 
 class TestConnectionListener : public ConnectionFactory::ConnectionListener {
  public:
   TestConnectionListener() : disconnect_counter_(0) { }
   ~TestConnectionListener() override { }
 
   void OnConnected(const GURL& current_server,
                    const net::IPEndPoint& ip_endpoint) override { }
   void OnDisconnected() override {
@@ skipping 21 matching lines @@
       int heartbeat_interval_ms);
   void AddExpectedLoginRequest(const std::vector<std::string>& acknowledged_ids,
                                int heartbeat_interval_ms);
 
   base::SimpleTestClock* clock() { return &clock_; }
   TestMCSClient* mcs_client() const { return mcs_client_.get(); }
   FakeConnectionFactory* connection_factory() {
     return &connection_factory_;
   }
   bool init_success() const { return init_success_; }
-  uint64 restored_android_id() const { return restored_android_id_; }
-  uint64 restored_security_token() const { return restored_security_token_; }
+  uint64_t restored_android_id() const { return restored_android_id_; }
+  uint64_t restored_security_token() const { return restored_security_token_; }
   MCSMessage* received_message() const { return received_message_.get(); }
   std::string sent_message_id() const { return sent_message_id_;}
   MCSClient::MessageSendStatus message_send_status() const {
     return message_send_status_;
   }
 
   void SetDeviceCredentialsCallback(bool success);
 
   FakeConnectionHandler* GetFakeHandler() const;
 
   void WaitForMCSEvent();
   void PumpLoop();
 
  private:
   void ErrorCallback();
   void MessageReceivedCallback(const MCSMessage& message);
-  void MessageSentCallback(int64 user_serial_number,
+  void MessageSentCallback(int64_t user_serial_number,
                            const std::string& app_id,
                            const std::string& message_id,
                            MCSClient::MessageSendStatus status);
 
   base::SimpleTestClock clock_;
 
   base::ScopedTempDir temp_directory_;
   base::MessageLoop message_loop_;
   scoped_ptr<base::RunLoop> run_loop_;
   scoped_ptr<GCMStore> gcm_store_;
 
   FakeConnectionFactory connection_factory_;
   scoped_ptr<TestMCSClient> mcs_client_;
   bool init_success_;
-  uint64 restored_android_id_;
-  uint64 restored_security_token_;
+  uint64_t restored_android_id_;
+  uint64_t restored_security_token_;
   scoped_ptr<MCSMessage> received_message_;
   std::string sent_message_id_;
   MCSClient::MessageSendStatus message_send_status_;
 
   gcm::FakeGCMStatsRecorder recorder_;
 };
 
 MCSClientTest::MCSClientTest()
     : run_loop_(new base::RunLoop()),
       init_success_(true),
@@ skipping 96 matching lines @@
   DVLOG(1) << "Error callback invoked, killing loop.";
   run_loop_->Quit();
 }
 
 void MCSClientTest::MessageReceivedCallback(const MCSMessage& message) {
   received_message_.reset(new MCSMessage(message));
   DVLOG(1) << "Message received callback invoked, killing loop.";
   run_loop_->Quit();
 }
 
-void MCSClientTest::MessageSentCallback(int64 user_serial_number,
+void MCSClientTest::MessageSentCallback(int64_t user_serial_number,
                                         const std::string& app_id,
                                         const std::string& message_id,
                                         MCSClient::MessageSendStatus status) {
   DVLOG(1) << "Message sent callback invoked, killing loop.";
   sent_message_id_ = message_id;
   message_send_status_ = status;
   run_loop_->Quit();
 }
 
 void MCSClientTest::SetDeviceCredentialsCallback(bool success) {
@@ skipping 872 matching lines @@
   GetFakeHandler()->ReceiveMessage(message);
   WaitForMCSEvent();
   PumpLoop();
 
   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 }
 
 } // namespace
 
 }  // namespace gcm