Add checkin activity recording to gcm recorder.

google_apis/gcm/monitoring/gcm_stats_recorder.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 "google_apis/gcm/monitoring/gcm_stats_recorder.h"
 
 #include <deque>
 #include <vector>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 
 namespace gcm {
 
 const uint32 MAX_LOGGED_ACTIVITY_COUNT = 100;
 
 namespace {
 
-// Insert an itme to the front of deque while maintaining the size of the deque.
+// 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) {
     q->pop_back();
   }
   return &q->front();
 }
@@ skipping 107 matching lines @@
 
 }  // namespace
 
 GCMStatsRecorder::Activity::Activity()
     : time(base::Time::Now()) {
 }
 
 GCMStatsRecorder::Activity::~Activity() {
 }
 
+GCMStatsRecorder::CheckinActivity::CheckinActivity() {
+}
+
+GCMStatsRecorder::CheckinActivity::~CheckinActivity() {
+}
+
 GCMStatsRecorder::ConnectionActivity::ConnectionActivity() {
 }
 
 GCMStatsRecorder::ConnectionActivity::~ConnectionActivity() {
 }
 
 GCMStatsRecorder::RegistrationActivity::RegistrationActivity() {
 }
 
 GCMStatsRecorder::RegistrationActivity::~RegistrationActivity() {
@@ skipping 22 matching lines @@
 }
 
 GCMStatsRecorder::~GCMStatsRecorder() {
 }
 
 void GCMStatsRecorder::SetRecording(bool recording) {
   is_recording_ = recording;
 }
 
 void GCMStatsRecorder::Clear() {
+  checkin_activities_.clear();
   connection_activities_.clear();
   registration_activities_.clear();
   receiving_activities_.clear();
   sending_activities_.clear();
 }
 
+void GCMStatsRecorder::RecordCheckin(
+    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;
+}
+
+void GCMStatsRecorder::RecordCheckinInitiated(uint64 android_id) {
+  if (!is_recording_)
+    return;
+  RecordCheckin("Checkin initiated",
+                base::StringPrintf("Android Id: %" PRIu64, android_id));
+}
+
+void GCMStatsRecorder::RecordCheckinDelayedDueToBackoff(int64 delay_msec) {
+  if (!is_recording_)
+    return;
+  RecordCheckin("Checkin backoff",
+                base::StringPrintf("Delayed for %" PRId64 " msec",
+                                   delay_msec));
+}
+
+void GCMStatsRecorder::RecordCheckinSuccess() {
+  if (!is_recording_)
+    return;
+  RecordCheckin("Checkin succeeded", std::string());
+}
+
+void GCMStatsRecorder::RecordCheckinFailure(std::string status,
+                                            bool will_retry) {
+  if (!is_recording_)
+    return;
+  RecordCheckin("Checkin failed", base::StringPrintf(
+      "%s.%s",
+      status.c_str(),
+      will_retry ? " Will retry." : "Will not retry."));
+}
+
 void GCMStatsRecorder::RecordConnection(
     const std::string& event,
     const std::string& details) {
   ConnectionActivity data;
   ConnectionActivity* inserted_data = InsertCircularBuffer(
       &connection_activities_, data);
   inserted_data->event = event;
   inserted_data->details = details;
 }
 
@@ skipping 149 matching lines @@
                         "Message has been deleted on server");
         break;
       default:
         NOTREACHED();
     }
   }
 }
 
 void GCMStatsRecorder::CollectActivities(
     RecordedActivities* recorder_activities) const {
+  recorder_activities->checkin_activities.insert(
+      recorder_activities->checkin_activities.begin(),
+      checkin_activities_.begin(),
+      checkin_activities_.end());
   recorder_activities->connection_activities.insert(
       recorder_activities->connection_activities.begin(),
       connection_activities_.begin(),
       connection_activities_.end());
   recorder_activities->registration_activities.insert(
       recorder_activities->registration_activities.begin(),
       registration_activities_.begin(),
       registration_activities_.end());
   recorder_activities->receiving_activities.insert(
       recorder_activities->receiving_activities.begin(),
@@ skipping 56 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