GCM: Add Android UMA, and UMA for deleted/collapsed messages

components/gcm_driver/gcm_client_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_client_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 64 matching lines @@
   INFINITE_STORE_RESET,
   // NOTE: always keep this entry at the end. Add new value only immediately
   // above this line. Make sure to update the corresponding histogram enum
   // accordingly.
   RESET_STORE_ERROR_COUNT
 };
 
 const char kGCMScope[] = "GCM";
 const int kMaxRegistrationRetries = 5;
 const int kMaxUnregistrationRetries = 5;
+const char kDeletedCountKey[] = "total_deleted";
 const char kMessageTypeDataMessage[] = "gcm";
 const char kMessageTypeDeletedMessagesKey[] = "deleted_messages";
 const char kMessageTypeKey[] = "message_type";
 const char kMessageTypeSendErrorKey[] = "send_error";
 const char kSendErrorMessageIdKey[] = "google.message_id";
 const char kSubtypeKey[] = "subtype";
 const char kSendMessageFromValue[] = "gcm@chrome.com";
 const int64_t kDefaultUserSerialNumber = 0LL;
 const int kDestroyGCMStoreDelayMS = 5 * 60 * 1000;  // 5 minutes.
 
@@ skipping 1233 matching lines @@
     message_type = DecodeMessageType(type_iter->second);
     message_data.erase(type_iter);
   }
 
   switch (message_type) {
     case DATA_MESSAGE:
       HandleIncomingDataMessage(app_id, use_subtype, data_message_stanza,
                                 message_data);
       break;
     case DELETED_MESSAGES:
-      recorder_.RecordDataMessageReceived(app_id, data_message_stanza.from(),
-                                          data_message_stanza.ByteSize(), true,
-                                          GCMStatsRecorder::DELETED_MESSAGES);
-      delegate_->OnMessagesDeleted(app_id);
+      HandleIncomingDeletedMessages(app_id, data_message_stanza, message_data);
       break;
     case SEND_ERROR:
       HandleIncomingSendError(app_id, data_message_stanza, message_data);
       break;
     case UNKNOWN:
       DVLOG(1) << "Unknown message_type received. Message ignored. "
                << "App ID: " << app_id << ".";
       break;
   }
 }
@@ skipping 42 matching lines @@
     if (instance_id_token_iter != registrations_.end()) {
       if (was_subtype != InstanceIDUsesSubtypeForAppId(app_id)) {
         DLOG(ERROR) << "GCM message for " << app_id
                     << " incorrectly had was_subtype = " << was_subtype;
       } else {
         registered = true;
       }
     }
   }
 
+  UMA_HISTOGRAM_BOOLEAN("GCM.DataMessageReceivedHasRegisteredApp", registered);
+  if (registered) {
+    UMA_HISTOGRAM_BOOLEAN("GCM.DataMessageReceived", true);
+    bool has_collapse_key =
+        data_message_stanza.has_token() && !data_message_stanza.token().empty();
+    UMA_HISTOGRAM_BOOLEAN("GCM.DataMessageReceivedHasCollapseKey",
+                          has_collapse_key);
+  }
   recorder_.RecordDataMessageReceived(app_id, sender,
       data_message_stanza.ByteSize(), registered,
       GCMStatsRecorder::DATA_MESSAGE);
   if (!registered)
     return;
 
   IncomingMessage incoming_message;
   incoming_message.sender_id = data_message_stanza.from();
   if (data_message_stanza.has_token())
     incoming_message.collapse_key = data_message_stanza.token();
   incoming_message.data = message_data;
   incoming_message.raw_data = data_message_stanza.raw_data();
 
   delegate_->OnMessageReceived(app_id, incoming_message);
 }
 
+void GCMClientImpl::HandleIncomingDeletedMessages(
+    const std::string& app_id,
+    const mcs_proto::DataMessageStanza& data_message_stanza,
+    MessageData& message_data) {
+  int deleted_count = 0;
+  MessageData::iterator count_iter = message_data.find(kDeletedCountKey);
+  if (count_iter != message_data.end()) {
+    if (!base::StringToInt(count_iter->second, &deleted_count))
+      deleted_count = 0;
+  }
+  UMA_HISTOGRAM_COUNTS_1000("GCM.DeletedMessagesReceived", deleted_count);
+
+  recorder_.RecordDataMessageReceived(app_id, data_message_stanza.from(),
+                                      data_message_stanza.ByteSize(),
+                                      true /* to_registered_app */,
+                                      GCMStatsRecorder::DELETED_MESSAGES);
+  delegate_->OnMessagesDeleted(app_id);
+}
+
 void GCMClientImpl::HandleIncomingSendError(
     const std::string& app_id,
     const mcs_proto::DataMessageStanza& data_message_stanza,
     MessageData& message_data) {
   SendErrorDetails send_error_details;
   send_error_details.additional_data = message_data;
   send_error_details.result = SERVER_ERROR;
 
   MessageData::iterator iter =
       send_error_details.additional_data.find(kSendErrorMessageIdKey);
@@ skipping 10 matching lines @@
 bool GCMClientImpl::HasStandaloneRegisteredApp() const {
   if (registrations_.empty())
     return false;
   // Note that account mapper is not counted as a standalone app since it is
   // automatically started when other app uses GCM.
   return registrations_.size() > 1 ||
          !ExistsGCMRegistrationInMap(registrations_, kGCMAccountMapperAppId);
 }
 
 }  // namespace gcm