Enable auto-refreshing of the gcm-internals page whenever a GCM activity is recorded, and fix a bug…

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"
@@ skipping 166 matching lines @@
 
 GCMStatsRecorder::SendingActivity::~SendingActivity() {
 }
 
 GCMStatsRecorder::RecordedActivities::RecordedActivities() {
 }
 
 GCMStatsRecorder::RecordedActivities::~RecordedActivities() {
 }
 
-GCMStatsRecorder::GCMStatsRecorder() : is_recording_(false) {
+GCMStatsRecorder::GCMStatsRecorder() : is_recording_(false), delegate_(NULL) {
 }
 
 GCMStatsRecorder::~GCMStatsRecorder() {
 }
 
 void GCMStatsRecorder::SetRecording(bool recording) {
   is_recording_ = recording;
 }
 
+void GCMStatsRecorder::SetDelegate(Delegate* delegate) {
+  delegate_ = delegate;
+}
+
 void GCMStatsRecorder::Clear() {
   checkin_activities_.clear();
   connection_activities_.clear();
   registration_activities_.clear();
   receiving_activities_.clear();
   sending_activities_.clear();
 }
 
+void GCMStatsRecorder::NotifyActivityRecorded() {
+  if (delegate_)
+    delegate_->OnActivityRecorded();
+}
+
 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;
+  NotifyActivityRecorded();
 }
 
 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) {
@@ skipping 21 matching lines @@
 }
 
 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;
+  NotifyActivityRecorded();
 }
 
 void GCMStatsRecorder::RecordConnectionInitiated(const std::string& host) {
   if (!is_recording_)
     return;
   RecordConnection("Connection initiated", host);
 }
 
 void GCMStatsRecorder::RecordConnectionDelayedDueToBackoff(int64 delay_msec) {
   if (!is_recording_)
@@ skipping 29 matching lines @@
     const std::string& sender_ids,
     const std::string& event,
     const std::string& details) {
   RegistrationActivity data;
   RegistrationActivity* inserted_data = InsertCircularBuffer(
       &registration_activities_, data);
   inserted_data->app_id = app_id;
   inserted_data->sender_ids = sender_ids;
   inserted_data->event = event;
   inserted_data->details = details;
+  NotifyActivityRecorded();
 }
 
 void GCMStatsRecorder::RecordRegistrationSent(
     const std::string& app_id,
     const std::string& sender_ids) {
   UMA_HISTOGRAM_COUNTS("GCM.RegistrationRequest", 1);
   if (!is_recording_)
     return;
   RecordRegistration(app_id, sender_ids,
                      "Registration request sent", std::string());
 }
 
 void GCMStatsRecorder::RecordRegistrationResponse(
     const std::string& app_id,
     const std::vector<std::string>& sender_ids,
     RegistrationRequest::Status status) {
+  if (!is_recording_)
+    return;
   RecordRegistration(app_id, JoinString(sender_ids, ","),
                      "Registration response received",
                      GetRegistrationStatusString(status));
 }
 
 void GCMStatsRecorder::RecordRegistrationRetryRequested(
     const std::string& app_id,
     const std::vector<std::string>& sender_ids,
     int retries_left) {
   if (!is_recording_)
@@ skipping 42 matching lines @@
     const std::string& event,
     const std::string& details) {
   ReceivingActivity data;
   ReceivingActivity* inserted_data = InsertCircularBuffer(
       &receiving_activities_, data);
   inserted_data->app_id = app_id;
   inserted_data->from = from;
   inserted_data->message_byte_size = message_byte_size;
   inserted_data->event = event;
   inserted_data->details = details;
+  NotifyActivityRecorded();
 }
 
 void GCMStatsRecorder::RecordDataMessageReceived(
     const std::string& app_id,
     const std::string& from,
     int message_byte_size,
     bool to_registered_app,
     ReceivedMessageType message_type) {
   if (to_registered_app)
     UMA_HISTOGRAM_COUNTS("GCM.DataMessageReceived", 1);
@@ skipping 49 matching lines @@
                                      const std::string& event,
                                      const std::string& details) {
   SendingActivity data;
   SendingActivity* inserted_data = InsertCircularBuffer(
       &sending_activities_, data);
   inserted_data->app_id = app_id;
   inserted_data->receiver_id = receiver_id;
   inserted_data->message_id = message_id;
   inserted_data->event = event;
   inserted_data->details = details;
+  NotifyActivityRecorded();
 }
 
 void GCMStatsRecorder::RecordDataSentToWire(
     const std::string& app_id,
     const std::string& receiver_id,
     const std::string& message_id,
     int queued) {
   if (!is_recording_)
     return;
   RecordSending(app_id, receiver_id, message_id, "Data msg sent to wire",
@@ skipping 25 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