Record latencies of connection and arrival of first message 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 125 matching lines @@
     default:
       NOTREACHED();
       return "UNKNOWN_STATUS";
   }
 }
 
 }  // namespace
 
 GCMStatsRecorderImpl::GCMStatsRecorderImpl()
     : is_recording_(false),
-      delegate_(NULL) {
+      delegate_(NULL),
+      data_message_received_since_connected_(false),
+      received_data_message_burst_size_(0) {
 }
 
 GCMStatsRecorderImpl::~GCMStatsRecorderImpl() {
 }
 
 void GCMStatsRecorderImpl::SetRecording(bool recording) {
   is_recording_ = recording;
 }
 
 void GCMStatsRecorderImpl::SetDelegate(Delegate* delegate) {
@@ skipping 60 matching lines @@
     const std::string& details) {
   ConnectionActivity data;
   ConnectionActivity* inserted_data = InsertCircularBuffer(
       &connection_activities_, data);
   inserted_data->event = event;
   inserted_data->details = details;
   NotifyActivityRecorded();
 }
 
 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) {
   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(
+      "GCM.ConnectionLatency",
+      (base::TimeTicks::Now() - last_connection_initiation_time_));
+  last_connection_success_time_ = base::TimeTicks::Now();
+  last_connection_initiation_time_ = base::TimeTicks();
   if (!is_recording_)
     return;
   RecordConnection("Connection succeeded", std::string());
 }
 
 void GCMStatsRecorderImpl::RecordConnectionFailure(int network_error) {
   if (!is_recording_)
     return;
   RecordConnection("Connection failed",
                    base::StringPrintf("With network error %d", network_error));
@@ skipping 105 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);
 
-  base::Time new_timestamp = base::Time::Now();
+  base::TimeTicks new_timestamp = base::TimeTicks::Now();
   if (last_received_data_message_burst_start_time_.is_null()) {
     last_received_data_message_burst_start_time_ = new_timestamp;
+    last_received_data_message_time_within_burst_ = new_timestamp;
+    received_data_message_burst_size_ = 1;
   } else if ((new_timestamp - last_received_data_message_burst_start_time_) >=
              base::TimeDelta::FromSeconds(
                  RECEIVED_DATA_MESSAGE_BURST_LENGTH_SECONDS)) {
-    UMA_HISTOGRAM_COUNTS(
-        "GCM.DataMessageBurstReceivedIntervalSeconds",
-        (new_timestamp - last_received_data_message_burst_start_time_)
-            .InSeconds());
+    UMA_HISTOGRAM_LONG_TIMES(
+        "GCM.DataMessageBurstReceivedInterval",
+        (new_timestamp - last_received_data_message_burst_start_time_));
+    UMA_HISTOGRAM_COUNTS("GCM.ReceivedDataMessageBurstSize",
+                         received_data_message_burst_size_);
     last_received_data_message_burst_start_time_ = new_timestamp;
+    last_received_data_message_time_within_burst_ = new_timestamp;
+    received_data_message_burst_size_ = 1;
+  } else {
+    UMA_HISTOGRAM_TIMES(
+        "GCM.ReceivedDataMessageIntervalWithinBurst",
+        (new_timestamp - last_received_data_message_time_within_burst_));
+    last_received_data_message_time_within_burst_ = new_timestamp;
+    ++received_data_message_burst_size_;
+  }
+  if (!data_message_received_since_connected_) {
+    DCHECK(!last_connection_success_time_.is_null());
+    UMA_HISTOGRAM_TIMES("GCM.FirstReceivedDataMessageLatencyAfterConnection",
+                        (new_timestamp - last_connection_success_time_));
+    data_message_received_since_connected_ = true;
   }
 
   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");
+    RecordReceiving(app_id,
+                    from,
+                    message_byte_size,
+                    "Data msg received",
+                    "No such registered app found");
   } else {
     switch(message_type) {
       case GCMStatsRecorderImpl::DATA_MESSAGE:
         RecordReceiving(app_id, from, message_byte_size, "Data msg received",
                         std::string());
         break;
       case GCMStatsRecorderImpl::DELETED_MESSAGES:
         RecordReceiving(app_id, from, message_byte_size, "Data msg received",
                         "Message has been deleted on server");
         break;
@@ skipping 79 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