Switch to standard integer types in google_apis/.

google_apis/gcm/engine/checkin_request_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 <stdint.h>
+
 #include <string>
 
 #include "google_apis/gcm/engine/checkin_request.h"
 #include "google_apis/gcm/engine/gcm_request_test_base.h"
 #include "google_apis/gcm/monitoring/fake_gcm_stats_recorder.h"
 #include "google_apis/gcm/protocol/checkin.pb.h"
 
 namespace gcm {
 
-const uint64 kAndroidId = 42UL;
-const uint64 kBlankAndroidId = 999999UL;
-const uint64 kBlankSecurityToken = 999999UL;
+const uint64_t kAndroidId = 42UL;
+const uint64_t kBlankAndroidId = 999999UL;
+const uint64_t kBlankSecurityToken = 999999UL;
 const char kCheckinURL[] = "http://foo.bar/checkin";
 const char kChromeVersion[] = "Version String";
-const uint64 kSecurityToken = 77;
+const uint64_t kSecurityToken = 77;
 const char kSettingsDigest[] = "settings_digest";
 const char kEmailAddress[] = "test_user@gmail.com";
 const char kTokenValue[] = "token_value";
 
 class CheckinRequestTest : public GCMRequestTestBase {
  public:
   enum ResponseScenario {
     VALID_RESPONSE,  // Both android_id and security_token set in response.
     MISSING_ANDROID_ID,  // android_id is missing.
     MISSING_SECURITY_TOKEN,  // security_token is missing.
     ANDROID_ID_IS_ZER0,  // android_id is 0.
     SECURITY_TOKEN_IS_ZERO  // security_token is 0.
   };
 
   CheckinRequestTest();
   ~CheckinRequestTest() override;
 
   void FetcherCallback(
       const checkin_proto::AndroidCheckinResponse& response);
 
-  void CreateRequest(uint64 android_id, uint64 security_token);
+  void CreateRequest(uint64_t android_id, uint64_t security_token);
 
   void SetResponseScenario(ResponseScenario response_scenario);
 
  protected:
   bool callback_called_;
-  uint64 android_id_;
-  uint64 security_token_;
+  uint64_t android_id_;
+  uint64_t security_token_;
   int checkin_device_type_;
   checkin_proto::ChromeBuildProto chrome_build_proto_;
   scoped_ptr<CheckinRequest> request_;
   FakeGCMStatsRecorder recorder_;
 };
 
 CheckinRequestTest::CheckinRequestTest()
     : callback_called_(false),
       android_id_(kBlankAndroidId),
       security_token_(kBlankSecurityToken),
       checkin_device_type_(0) {
 }
 
 CheckinRequestTest::~CheckinRequestTest() {}
 
 void CheckinRequestTest::FetcherCallback(
     const checkin_proto::AndroidCheckinResponse& checkin_response) {
   callback_called_ = true;
   if (checkin_response.has_android_id())
     android_id_ = checkin_response.android_id();
   if (checkin_response.has_security_token())
     security_token_ = checkin_response.security_token();
 }
 
-void CheckinRequestTest::CreateRequest(uint64 android_id,
-                                       uint64 security_token) {
+void CheckinRequestTest::CreateRequest(uint64_t android_id,
+                                       uint64_t security_token) {
   // First setup a chrome_build protobuf.
   chrome_build_proto_.set_platform(
       checkin_proto::ChromeBuildProto::PLATFORM_LINUX);
   chrome_build_proto_.set_channel(
       checkin_proto::ChromeBuildProto::CHANNEL_CANARY);
   chrome_build_proto_.set_chrome_version(kChromeVersion);
 
   std::map<std::string, std::string> account_tokens;
   account_tokens[kEmailAddress] = kTokenValue;
 
@@ skipping 17 matching lines @@
   callback_called_ = false;
   android_id_ = kBlankAndroidId;
   security_token_ = kBlankSecurityToken;
 }
 
 void CheckinRequestTest::SetResponseScenario(
     ResponseScenario response_scenario) {
   checkin_proto::AndroidCheckinResponse response;
   response.set_stats_ok(true);
 
-  uint64 android_id = response_scenario == ANDROID_ID_IS_ZER0 ? 0 : kAndroidId;
-  uint64 security_token =
+  uint64_t android_id =
+      response_scenario == ANDROID_ID_IS_ZER0 ? 0 : kAndroidId;
+  uint64_t security_token =
       response_scenario == SECURITY_TOKEN_IS_ZERO ? 0 : kSecurityToken;
 
   if (response_scenario != MISSING_ANDROID_ID)
     response.set_android_id(android_id);
 
   if (response_scenario != MISSING_SECURITY_TOKEN)
     response.set_security_token(security_token);
 
   std::string response_string;
   response.SerializeToString(&response_string);
   SetResponse(net::HTTP_OK, response_string);
 }
 
 TEST_F(CheckinRequestTest, FetcherDataAndURL) {
   CreateRequest(kAndroidId, kSecurityToken);
   request_->Start();
 
   // Get data sent by request.
   net::TestURLFetcher* fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kCheckinURL), fetcher->GetOriginalURL());
 
   checkin_proto::AndroidCheckinRequest request_proto;
   request_proto.ParseFromString(fetcher->upload_data());
-  EXPECT_EQ(kAndroidId, static_cast<uint64>(request_proto.id()));
+  EXPECT_EQ(kAndroidId, static_cast<uint64_t>(request_proto.id()));
   EXPECT_EQ(kSecurityToken, request_proto.security_token());
   EXPECT_EQ(chrome_build_proto_.platform(),
             request_proto.checkin().chrome_build().platform());
   EXPECT_EQ(chrome_build_proto_.chrome_version(),
             request_proto.checkin().chrome_build().chrome_version());
   EXPECT_EQ(chrome_build_proto_.channel(),
             request_proto.checkin().chrome_build().channel());
   EXPECT_EQ(2, request_proto.account_cookie_size());
   EXPECT_EQ(kEmailAddress, request_proto.account_cookie(0));
   EXPECT_EQ(kTokenValue, request_proto.account_cookie(1));
@@ skipping 169 matching lines @@
 
   SetResponseScenario(VALID_RESPONSE);
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(kAndroidId, android_id_);
   EXPECT_EQ(kSecurityToken, security_token_);
 }
 
 }  // namespace gcm