Enable auto-refreshing of the gcm-internals page whenever a GCM activity is recorded.

google_apis/gcm/monitoring/gcm_stats_recorder.h

 // 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.
 
 #ifndef GOOGLE_APIS_GCM_GCM_STATS_RECORDER_H_
 #define GOOGLE_APIS_GCM_GCM_STATS_RECORDER_H_
 
 #include <deque>
 #include <string>
 #include <vector>
@@ skipping 77 matching lines @@
     RecordedActivities();
     virtual ~RecordedActivities();
 
     std::vector<GCMStatsRecorder::CheckinActivity> checkin_activities;
     std::vector<GCMStatsRecorder::ConnectionActivity> connection_activities;
     std::vector<GCMStatsRecorder::RegistrationActivity> registration_activities;
     std::vector<GCMStatsRecorder::ReceivingActivity> receiving_activities;
     std::vector<GCMStatsRecorder::SendingActivity> sending_activities;
   };
 
+  // A delegate interface that allows the GCMStatsRecorder instance to interact
+  // with its container.
+  class Delegate {
+   public:
+    // Called when the GCMStatsRecorder is recording activities and a new
+    // activity has just been recorded.
+    virtual void OnActivityRecorded() = 0;
+  };
+
   GCMStatsRecorder();
   virtual ~GCMStatsRecorder();
 
   // Indicates whether the recorder is currently recording activities or not.
   bool is_recording() const {
     return is_recording_;
   }
 
   // Turns recording on/off.
   void SetRecording(bool recording);
 
+  // Set a delegate to receive callback from the recorder.
+  void SetDelegate(Delegate* delegate);
+
   // Clear all recorded activities.
   void Clear();
 
   // All RecordXXXX methods below will record one activity. It will be inserted
   // to the front of a queue so that entries in the queue had reverse
   // chronological order.
 
   // Records that a check-in has been initiated.
   void RecordCheckinInitiated(uint64 android_id);
 
@@ skipping 93 matching lines @@
     return registration_activities_;
   }
   const std::deque<ReceivingActivity>& receiving_activities() const {
     return receiving_activities_;
   }
   const std::deque<SendingActivity>& sending_activities() const {
     return sending_activities_;
   }
 
  protected:
+  // Notify the recorder delegate, if it exists, that an activity has been
+  // recorded.
+  void NotifyActivityRecorded();
+
   void RecordCheckin(const std::string& event,
                      const std::string& details);
+
   void RecordConnection(const std::string& event,
                         const std::string& details);
+
   void RecordRegistration(const std::string& app_id,
                           const std::string& sender_id,
                           const std::string& event,
                           const std::string& details);
+
   void RecordReceiving(const std::string& app_id,
                        const std::string& from,
                        int message_byte_size,
                        const std::string& event,
                        const std::string& details);
+
   void RecordSending(const std::string& app_id,
                      const std::string& receiver_id,
                      const std::string& message_id,
                      const std::string& event,
                      const std::string& details);
 
   bool is_recording_;
+  Delegate* delegate_;
 
   std::deque<CheckinActivity> checkin_activities_;
   std::deque<ConnectionActivity> connection_activities_;
   std::deque<RegistrationActivity> registration_activities_;
   std::deque<ReceivingActivity> receiving_activities_;
   std::deque<SendingActivity> sending_activities_;
 
   DISALLOW_COPY_AND_ASSIGN(GCMStatsRecorder);
 };
 
 }  // namespace gcm
 
 #endif  // GOOGLE_APIS_GCM_GCM_STATS_RECORDER_H_