Enable chrome://gcm-internals on Android

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 135 matching lines @@
 GCMStatsRecorderImpl::GCMStatsRecorderImpl()
     : is_recording_(false),
       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) {
   delegate_ = delegate;
 }
 
 void GCMStatsRecorderImpl::Clear() {
   checkin_activities_.clear();
   connection_activities_.clear();
   registration_activities_.clear();
   receiving_activities_.clear();
   sending_activities_.clear();
@@ skipping 113 matching lines @@
   inserted_data->app_id = app_id;
   inserted_data->source = source;
   inserted_data->event = event;
   inserted_data->details = details;
   NotifyActivityRecorded();
 }
 
 void GCMStatsRecorderImpl::RecordRegistrationSent(
     const std::string& app_id,
     const std::string& sender_ids) {
-  UMA_HISTOGRAM_COUNTS("GCM.RegistrationRequest", 1);
+  UMA_HISTOGRAM_BOOLEAN("GCM.RegistrationRequest", true);
   if (!is_recording_)
     return;
   RecordRegistration(app_id, sender_ids,
                      "Registration request sent", std::string());
 }
 
 void GCMStatsRecorderImpl::RecordRegistrationResponse(
     const std::string& app_id,
     const std::string& source,
     RegistrationRequest::Status status) {
@@ skipping 15 matching lines @@
       app_id,
       source,
       "Registration retry delayed",
       base::StringPrintf("Delayed for %" PRId64 " msec, retries left: %d",
                          delay_msec,
                          retries_left));
 }
 
 void GCMStatsRecorderImpl::RecordUnregistrationSent(
     const std::string& app_id, const std::string& source) {
-  UMA_HISTOGRAM_COUNTS("GCM.UnregistrationRequest", 1);
+  UMA_HISTOGRAM_BOOLEAN("GCM.UnregistrationRequest", true);
   if (!is_recording_)
     return;
   RecordRegistration(app_id, source, "Unregistration request sent",
                      std::string());
 }
 
 void GCMStatsRecorderImpl::RecordUnregistrationResponse(
     const std::string& app_id,
     const std::string& source,
     UnregistrationRequest::Status status) {
@@ skipping 38 matching lines @@
   NotifyActivityRecorded();
 }
 
 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);
+    UMA_HISTOGRAM_BOOLEAN("GCM.DataMessageReceived", true);
 
   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_LONG_TIMES(
@@ skipping 36 matching lines @@
         RecordReceiving(app_id, from, message_byte_size, "Data msg received",
                         "Message has been deleted on server");
         break;
       default:
         NOTREACHED();
     }
   }
 }
 
 void GCMStatsRecorderImpl::CollectActivities(
-    RecordedActivities* recorder_activities) const {
-  recorder_activities->checkin_activities.insert(
-      recorder_activities->checkin_activities.begin(),
+    RecordedActivities* recorded_activities) const {
+  recorded_activities->checkin_activities.insert(
+      recorded_activities->checkin_activities.begin(),
       checkin_activities_.begin(),
       checkin_activities_.end());
-  recorder_activities->connection_activities.insert(
-      recorder_activities->connection_activities.begin(),
+  recorded_activities->connection_activities.insert(
+      recorded_activities->connection_activities.begin(),
       connection_activities_.begin(),
       connection_activities_.end());
-  recorder_activities->registration_activities.insert(
-      recorder_activities->registration_activities.begin(),
+  recorded_activities->registration_activities.insert(
+      recorded_activities->registration_activities.begin(),
       registration_activities_.begin(),
       registration_activities_.end());
-  recorder_activities->receiving_activities.insert(
-      recorder_activities->receiving_activities.begin(),
+  recorded_activities->receiving_activities.insert(
+      recorded_activities->receiving_activities.begin(),
       receiving_activities_.begin(),
       receiving_activities_.end());
-  recorder_activities->sending_activities.insert(
-      recorder_activities->sending_activities.begin(),
+  recorded_activities->sending_activities.insert(
+      recorded_activities->sending_activities.begin(),
       sending_activities_.begin(),
       sending_activities_.end());
 }
 
 void GCMStatsRecorderImpl::RecordSending(const std::string& app_id,
                                          const std::string& receiver_id,
                                          const std::string& message_id,
                                          const std::string& event,
                                          const std::string& details) {
   SendingActivity data;
@@ skipping 43 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