Record GCM received data message intervals in UMA

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"
@@ skipping 124 matching lines @@
     default:
       NOTREACHED();
       return "UNKNOWN_STATUS";
   }
 }
 
 }  // namespace
 
 GCMStatsRecorderImpl::GCMStatsRecorderImpl()
     : is_recording_(false),
-      delegate_(NULL) {
+      delegate_(NULL),
+      clock_(new base::DefaultClock()),
+      last_data_message_received_timestamp_(0) {
 }
 
 GCMStatsRecorderImpl::~GCMStatsRecorderImpl() {
 }
 
 void GCMStatsRecorderImpl::SetRecording(bool recording) {
   is_recording_ = recording;
 }
 
 void GCMStatsRecorderImpl::SetDelegate(Delegate* delegate) {
@@ skipping 199 matching lines @@
 }
 
 void GCMStatsRecorderImpl::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);
+
+  int64 new_timestamp = clock_->Now().ToTimeT();

[jianli, 2014/06/19 17:24:06]

Why not calling Time::Now()?

[juyik, 2014/07/15 23:42:12]

Done.

+  if (last_data_message_received_timestamp_ > 0) {

[fgorski, 2014/06/18 20:06:19]

will this trigger only after all of the messages that arrive during reconnect
are consumed, or after the first one?

We should let all of them pass, and start recording after a second (?) after
connection was made.

[fgorski, 2014/06/20 14:23:45]

Ju-Yi, given that the wake-up period during sleep is supposed to be 2 sec., why
don't we discard all of the 2 second bursts. We can update the name of the enum
to reflect that.

[juyik, 2014/07/15 23:42:12]

This is triggered every time a data message is consumed. So when
last_data_message_received_timestamp_ is zero, it means it is the first time
we've seen received message so there is no interval to think about.

[juyik, 2014/07/15 23:42:13]

Done. Collapsed all received data message within 2 seconds into 1 count. Changed
the UMA name as well. So when reconnection happens, we will receive a whole
bunch of data messages within 2 seconds and they count for 1 burst.

+    UMA_HISTOGRAM_COUNTS("GCM.DataMessageReceivedIntervalSeconds",

[fgorski, 2014/06/18 20:06:19]

please update histograms as well.

[juyik, 2014/07/15 23:42:13]

Updated the name.

+                         new_timestamp - last_data_message_received_timestamp_);
+  }
+  last_data_message_received_timestamp_ = new_timestamp;
+
   if (!is_recording_)
     return;
   if (!to_registered_app) {
     RecordReceiving(app_id, from, message_byte_size, "Data msg received",
                     to_registered_app ? std::string() :
                                         "No such registered app found");
   } else {
     switch(message_type) {
       case GCMStatsRecorderImpl::DATA_MESSAGE:
         RecordReceiving(app_id, from, message_byte_size, "Data msg received",
@@ skipping 85 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