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

components/gcm_driver/gcm_stats_recorder_impl.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_stats_recorder_impl.h"
 
 #include <deque>
 #include <vector>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 
 namespace gcm {
 
-const uint32 MAX_LOGGED_ACTIVITY_COUNT = 100;
-const int64 RECEIVED_DATA_MESSAGE_BURST_LENGTH_SECONDS = 2;
+const uint32_t MAX_LOGGED_ACTIVITY_COUNT = 100;
+const int64_t RECEIVED_DATA_MESSAGE_BURST_LENGTH_SECONDS = 2;
 
 namespace {
 
 // Insert an item to the front of deque while maintaining the size of the deque.
 // Overflow item is discarded.
 template <typename T>
 T* InsertCircularBuffer(std::deque<T>* q, const T& item) {
   DCHECK(q);
   q->push_front(item);
   if (q->size() > MAX_LOGGED_ACTIVITY_COUNT) {
@@ skipping 144 matching lines @@
     const std::string& event,
     const std::string& details) {
   CheckinActivity data;
   CheckinActivity* inserted_data = InsertCircularBuffer(
       &checkin_activities_, data);
   inserted_data->event = event;
   inserted_data->details = details;
   NotifyActivityRecorded();
 }
 
-void GCMStatsRecorderImpl::RecordCheckinInitiated(uint64 android_id) {
+void GCMStatsRecorderImpl::RecordCheckinInitiated(uint64_t android_id) {
   if (!is_recording_)
     return;
   RecordCheckin("Checkin initiated",
                 base::StringPrintf("Android Id: %" PRIu64, android_id));
 }
 
-void GCMStatsRecorderImpl::RecordCheckinDelayedDueToBackoff(int64 delay_msec) {
+void GCMStatsRecorderImpl::RecordCheckinDelayedDueToBackoff(
+    int64_t delay_msec) {
   if (!is_recording_)
     return;
   RecordCheckin("Checkin backoff",
                 base::StringPrintf("Delayed for %" PRId64 " msec",
                                    delay_msec));
 }
 
 void GCMStatsRecorderImpl::RecordCheckinSuccess() {
   if (!is_recording_)
     return;
@@ skipping 24 matching lines @@
 void GCMStatsRecorderImpl::RecordConnectionInitiated(const std::string& host) {
   last_connection_initiation_time_ = base::TimeTicks::Now();
   last_connection_success_time_ = base::TimeTicks();
   data_message_received_since_connected_ = false;
   if (!is_recording_)
     return;
   RecordConnection("Connection initiated", host);
 }
 
 void GCMStatsRecorderImpl::RecordConnectionDelayedDueToBackoff(
-    int64 delay_msec) {
+    int64_t delay_msec) {
   if (!is_recording_)
     return;
   RecordConnection("Connection backoff",
                    base::StringPrintf("Delayed for %" PRId64 " msec",
                                       delay_msec));
 }
 
 void GCMStatsRecorderImpl::RecordConnectionSuccess() {
   DCHECK(!last_connection_initiation_time_.is_null());
   UMA_HISTOGRAM_MEDIUM_TIMES(
@@ skipping 53 matching lines @@
   if (!is_recording_)
     return;
   RecordRegistration(app_id, source,
                      "Registration response received",
                      GetRegistrationStatusString(status));
 }
 
 void GCMStatsRecorderImpl::RecordRegistrationRetryDelayed(
     const std::string& app_id,
     const std::string& source,
-    int64 delay_msec,
+    int64_t delay_msec,
     int retries_left) {
   if (!is_recording_)
     return;
   RecordRegistration(
       app_id,
       source,
       "Registration retry delayed",
       base::StringPrintf("Delayed for %" PRId64 " msec, retries left: %d",
                          delay_msec,
                          retries_left));
@@ skipping 16 matching lines @@
     return;
   RecordRegistration(app_id,
                      source,
                      "Unregistration response received",
                      GetUnregistrationStatusString(status));
 }
 
 void GCMStatsRecorderImpl::RecordUnregistrationRetryDelayed(
     const std::string& app_id,
     const std::string& source,
-    int64 delay_msec,
+    int64_t delay_msec,
     int retries_left) {
   if (!is_recording_)
     return;
   RecordRegistration(
       app_id,
       source,
       "Unregistration retry delayed",
       base::StringPrintf("Delayed for %" PRId64 " msec, retries left: %d",
                          delay_msec,
                          retries_left));
@@ skipping 155 matching lines @@
     const std::string& receiver_id,
     const std::string& message_id) {
   UMA_HISTOGRAM_COUNTS("GCM.IncomingSendErrors", 1);
   if (!is_recording_)
     return;
   RecordSending(app_id, receiver_id, message_id, "Received 'send error' msg",
                 std::string());
 }
 
 }  // namespace gcm