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

components/gcm_driver/gcm_client_impl_unittest.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/gcm_driver/gcm_client_impl.h"
 
+#include <stdint.h>
+
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/clock.h"
 #include "base/timer/timer.h"
 #include "google_apis/gcm/base/fake_encryptor.h"
 #include "google_apis/gcm/base/mcs_message.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/engine/fake_connection_factory.h"
@@ skipping 17 matching lines @@
   LOADING_COMPLETED,
   REGISTRATION_COMPLETED,
   UNREGISTRATION_COMPLETED,
   MESSAGE_SEND_ERROR,
   MESSAGE_SEND_ACK,
   MESSAGE_RECEIVED,
   MESSAGES_DELETED,
 };
 
 const char kChromeVersion[] = "45.0.0.1";
-const uint64 kDeviceAndroidId = 54321;
-const uint64 kDeviceSecurityToken = 12345;
-const uint64 kDeviceAndroidId2 = 11111;
-const uint64 kDeviceSecurityToken2 = 2222;
-const int64 kSettingsCheckinInterval = 16 * 60 * 60;
+const uint64_t kDeviceAndroidId = 54321;
+const uint64_t kDeviceSecurityToken = 12345;
+const uint64_t kDeviceAndroidId2 = 11111;
+const uint64_t kDeviceSecurityToken2 = 2222;
+const int64_t kSettingsCheckinInterval = 16 * 60 * 60;
 const char kAppId[] = "app_id";
 const char kSender[] = "project_id";
 const char kSender2[] = "project_id2";
 const char kSender3[] = "project_id3";
 const char kRegistrationResponsePrefix[] = "token=";
 const char kUnregistrationResponsePrefix[] = "deleted=";
 const char kRawData[] = "example raw data";
 
 const char kInstanceID[] = "iid_1";
 const char kScope[] = "GCM";
@@ skipping 37 matching lines @@
   return email_token_map;
 }
 
 class FakeMCSClient : public MCSClient {
  public:
   FakeMCSClient(base::Clock* clock,
                 ConnectionFactory* connection_factory,
                 GCMStore* gcm_store,
                 GCMStatsRecorder* recorder);
   ~FakeMCSClient() override;
-  void Login(uint64 android_id, uint64 security_token) override;
+  void Login(uint64_t android_id, uint64_t security_token) override;
   void SendMessage(const MCSMessage& message) override;
 
-  uint64 last_android_id() const { return last_android_id_; }
-  uint64 last_security_token() const { return last_security_token_; }
-  uint8 last_message_tag() const { return last_message_tag_; }
+  uint64_t last_android_id() const { return last_android_id_; }
+  uint64_t last_security_token() const { return last_security_token_; }
+  uint8_t last_message_tag() const { return last_message_tag_; }
   const mcs_proto::DataMessageStanza& last_data_message_stanza() const {
     return last_data_message_stanza_;
   }
 
  private:
-  uint64 last_android_id_;
-  uint64 last_security_token_;
-  uint8 last_message_tag_;
+  uint64_t last_android_id_;
+  uint64_t last_security_token_;
+  uint8_t last_message_tag_;
   mcs_proto::DataMessageStanza last_data_message_stanza_;
 };
 
 FakeMCSClient::FakeMCSClient(base::Clock* clock,
                              ConnectionFactory* connection_factory,
                              GCMStore* gcm_store,
                              GCMStatsRecorder* recorder)
     : MCSClient("", clock, connection_factory, gcm_store, recorder),
       last_android_id_(0u),
       last_security_token_(0u),
       last_message_tag_(kNumProtoTypes) {
 }
 
 FakeMCSClient::~FakeMCSClient() {
 }
 
-void FakeMCSClient::Login(uint64 android_id, uint64 security_token) {
+void FakeMCSClient::Login(uint64_t android_id, uint64_t security_token) {
   last_android_id_ = android_id;
   last_security_token_ = security_token;
 }
 
 void FakeMCSClient::SendMessage(const MCSMessage& message) {
   last_message_tag_ = message.tag();
   if (last_message_tag_ == kDataMessageStanzaTag) {
     last_data_message_stanza_.CopyFrom(
         reinterpret_cast<const mcs_proto::DataMessageStanza&>(
             message.GetProtobuf()));
@@ skipping 104 matching lines @@
   void InitializeGCMClient();
   void StartGCMClient();
   void Register(const std::string& app_id,
                 const std::vector<std::string>& senders);
   void Unregister(const std::string& app_id);
   void ReceiveMessageFromMCS(const MCSMessage& message);
   void ReceiveOnMessageSentToMCS(
       const std::string& app_id,
       const std::string& message_id,
       const MCSClient::MessageSendStatus status);
-  void CompleteCheckin(uint64 android_id,
-                       uint64 security_token,
+  void CompleteCheckin(uint64_t android_id,
+                       uint64_t security_token,
                        const std::string& digest,
                        const std::map<std::string, std::string>& settings);
   void CompleteRegistration(const std::string& registration_id);
   void CompleteUnregistration(const std::string& app_id);
   void VerifyPendingRequestFetcherDeleted();
 
   bool ExistsRegistration(const std::string& app_id) const;
   void AddRegistration(const std::string& app_id,
                        const std::vector<std::string>& sender_ids,
                        const std::string& registration_id);
@@ skipping 73 matching lines @@
     return temp_directory_.path();
   }
 
   base::FilePath gcm_store_path() const {
     // Pass an non-existent directory as store path to match the exact
     // behavior in the production code. Currently GCMStoreImpl checks if
     // the directory exist or not to determine the store existence.
     return temp_directory_.path().Append(FILE_PATH_LITERAL("GCM Store"));
   }
 
-  int64 CurrentTime();
+  int64_t CurrentTime();
 
   // Tooling.
   void PumpLoopUntilIdle();
   bool CreateUniqueTempDir();
   AutoAdvancingTestClock* clock() const {
     return reinterpret_cast<AutoAdvancingTestClock*>(gcm_client_->clock_.get());
   }
   net::TestURLFetcherFactory* url_fetcher_factory() {
     return &url_fetcher_factory_;
   }
@@ skipping 63 matching lines @@
 bool GCMClientImplTest::CreateUniqueTempDir() {
   return temp_directory_.CreateUniqueTempDir();
 }
 
 void GCMClientImplTest::BuildGCMClient(base::TimeDelta clock_step) {
   gcm_client_.reset(new GCMClientImpl(make_scoped_ptr<GCMInternalsBuilder>(
       new FakeGCMInternalsBuilder(clock_step))));
 }
 
 void GCMClientImplTest::CompleteCheckin(
-    uint64 android_id,
-    uint64 security_token,
+    uint64_t android_id,
+    uint64_t security_token,
     const std::string& digest,
     const std::map<std::string, std::string>& settings) {
   checkin_proto::AndroidCheckinResponse response;
   response.set_stats_ok(true);
   response.set_android_id(android_id);
   response.set_security_token(security_token);
 
   // For testing G-services settings.
   if (!digest.empty()) {
     response.set_digest(digest);
@@ skipping 161 matching lines @@
   last_error_details_ = send_error_details;
 }
 
 void GCMClientImplTest::OnSendAcknowledged(const std::string& app_id,
                                            const std::string& message_id) {
   last_event_ = MESSAGE_SEND_ACK;
   last_app_id_ = app_id;
   last_message_id_ = message_id;
 }
 
-int64 GCMClientImplTest::CurrentTime() {
+int64_t GCMClientImplTest::CurrentTime() {
   return clock()->Now().ToInternalValue() / base::Time::kMicrosecondsPerSecond;
 }
 
 TEST_F(GCMClientImplTest, LoadingCompleted) {
   EXPECT_EQ(LOADING_COMPLETED, last_event());
   EXPECT_EQ(kDeviceAndroidId, mcs_client()->last_android_id());
   EXPECT_EQ(kDeviceSecurityToken, mcs_client()->last_security_token());
 
   // Checking freshly loaded CheckinInfo.
   EXPECT_EQ(kDeviceAndroidId, device_checkin_info().android_id);
@@ skipping 1005 matching lines @@
   // No need to call CompleteDeleteToken since unregistration request should
   // not be triggered.
   PumpLoopUntilIdle();
 
   EXPECT_EQ(UNREGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
 }
 
 }  // namespace gcm