Push API: Add and cleanup UMA logging for unregister/get/delivery.

chrome/browser/services/gcm/push_messaging_service_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 "chrome/browser/services/gcm/push_messaging_service_impl.h"
 
 #include <bitset>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 41 matching lines @@
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #endif
 
 namespace gcm {
 
 namespace {
 const int kMaxRegistrations = 1000000;
 
+void RecordDeliveryStatus(content::PushDeliveryStatus status) {
+  UMA_HISTOGRAM_ENUMERATION("PushMessaging.DeliveryStatus",
+                            status,
+                            content::PUSH_DELIVERY_STATUS_LAST + 1);
+}
+
 void RecordUserVisibleStatus(content::PushUserVisibleStatus status) {
   UMA_HISTOGRAM_ENUMERATION("PushMessaging.UserVisibleStatus",
                             status,
                             content::PUSH_USER_VISIBLE_STATUS_LAST + 1);
 }
 
 blink::WebPushPermissionStatus ToPushPermission(ContentSetting setting) {
   switch (setting) {
     case CONTENT_SETTING_ALLOW:
       return blink::WebPushPermissionStatusGranted;
@@ skipping 164 matching lines @@
                  application_id.app_id_guid(), application_id.origin(),
                  application_id.service_worker_registration_id(), message));
 }
 
 void PushMessagingServiceImpl::DeliverMessageCallback(
     const std::string& app_id_guid,
     const GURL& requesting_origin,
     int64 service_worker_registration_id,
     const GCMClient::IncomingMessage& message,
     content::PushDeliveryStatus status) {
-  // TODO(mvanouwerkerk): UMA logging.
   // TODO(mvanouwerkerk): Show a warning in the developer console of the
   // Service Worker corresponding to app_id (and/or on an internals page).
   // TODO(mvanouwerkerk): Is there a way to recover from failure?
   switch (status) {
     // Call RequireUserVisibleUX if the message was delivered to the Service
     // Worker JS, even if the website's event handler failed (to prevent sites
     // deliberately failing in order to avoid having to show notifications).
     case content::PUSH_DELIVERY_STATUS_SUCCESS:
     case content::PUSH_DELIVERY_STATUS_EVENT_WAITUNTIL_REJECTED:
       RequireUserVisibleUX(requesting_origin, service_worker_registration_id);
       break;
     case content::PUSH_DELIVERY_STATUS_INVALID_MESSAGE:
     case content::PUSH_DELIVERY_STATUS_SERVICE_WORKER_ERROR:
       break;
     case content::PUSH_DELIVERY_STATUS_UNKNOWN_APP_ID:
     case content::PUSH_DELIVERY_STATUS_PERMISSION_DENIED:
     case content::PUSH_DELIVERY_STATUS_NO_SERVICE_WORKER:
       Unregister(app_id_guid, message.sender_id, true /* retry_on_failure */,
                  UnregisterCallback());
       break;
   }
+  RecordDeliveryStatus(status);
 }
 
 void PushMessagingServiceImpl::RequireUserVisibleUX(
     const GURL& requesting_origin, int64 service_worker_registration_id) {
 #if defined(ENABLE_NOTIFICATIONS)
   // TODO(johnme): Relax this heuristic slightly.
   PlatformNotificationServiceImpl* notification_service =
       PlatformNotificationServiceImpl::GetInstance();
   // Can't use g_browser_process->notification_ui_manager(), since the test uses
   // PlatformNotificationServiceImpl::SetNotificationUIManagerForTesting.
@@ skipping 300 matching lines @@
   callback.Run(registration_id, status);
 }
 
 void PushMessagingServiceImpl::DidRegister(
     const PushMessagingApplicationId& application_id,
     const content::PushMessagingService::RegisterCallback& callback,
     const std::string& registration_id,
     GCMClient::Result result) {
   content::PushRegistrationStatus status =
       content::PUSH_REGISTRATION_STATUS_SERVICE_ERROR;
-  if (result == GCMClient::SUCCESS) {
-    status = content::PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE;
-    application_id.PersistToDisk(profile_);
-    IncreasePushRegistrationCount(1, false /* is_pending */);
+  switch (result) {
+    case GCMClient::SUCCESS:
+      status = content::PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE;
+      application_id.PersistToDisk(profile_);
+      IncreasePushRegistrationCount(1, false /* is_pending */);
+      break;
+    case GCMClient::INVALID_PARAMETER:
+    case GCMClient::GCM_DISABLED:
+    case GCMClient::ASYNC_OPERATION_PENDING:
+    case GCMClient::SERVER_ERROR:
+    case GCMClient::UNKNOWN_ERROR:
+      status = content::PUSH_REGISTRATION_STATUS_SERVICE_ERROR;
+      break;
+    case GCMClient::NETWORK_ERROR:
+    case GCMClient::TTL_EXCEEDED:
+      status = content::PUSH_REGISTRATION_STATUS_NETWORK_ERROR;
+      break;
   }
   RegisterEnd(callback, registration_id, status);
   DecreasePushRegistrationCount(1, true /* was_pending */);
 }
 
 void PushMessagingServiceImpl::DidRequestPermission(
     const PushMessagingApplicationId& application_id,
     const std::string& sender_id,
     const content::PushMessagingService::RegisterCallback& register_callback,
     bool allow) {
@@ skipping 89 matching lines @@
       return;
     }
 
     application_id.DeleteFromDisk(profile_);
     DecreasePushRegistrationCount(1, false /* was_pending */);
   }
 
   // Internal calls pass a null callback.
   if (!callback.is_null()) {
     switch (result) {
-    case GCMClient::SUCCESS:
-      callback.Run(content::PUSH_UNREGISTRATION_STATUS_SUCCESS_UNREGISTER);
-      break;
-    case GCMClient::NETWORK_ERROR:
-    case GCMClient::TTL_EXCEEDED:
-    case GCMClient::ASYNC_OPERATION_PENDING:
-      callback.Run(
-          retry_on_failure
-          ? content::
-            PUSH_UNREGISTRATION_STATUS_SUCCESS_WILL_RETRY_NETWORK_ERROR
-          : content::PUSH_UNREGISTRATION_STATUS_NETWORK_ERROR);
-      break;
-    case GCMClient::SERVER_ERROR:
-    case GCMClient::INVALID_PARAMETER:
-    case GCMClient::GCM_DISABLED:
-    case GCMClient::UNKNOWN_ERROR:
-      callback.Run(content::PUSH_UNREGISTRATION_STATUS_UNKNOWN_ERROR);
-      break;
-    default:
-      NOTREACHED() << "Unexpected GCMClient::Result value.";
-      callback.Run(content::PUSH_UNREGISTRATION_STATUS_UNKNOWN_ERROR);
-      break;
+      case GCMClient::SUCCESS:
+        callback.Run(content::PUSH_UNREGISTRATION_STATUS_SUCCESS_UNREGISTERED);
+        break;
+      case GCMClient::INVALID_PARAMETER:
+      case GCMClient::GCM_DISABLED:
+      case GCMClient::ASYNC_OPERATION_PENDING:
+      case GCMClient::SERVER_ERROR:
+      case GCMClient::UNKNOWN_ERROR:
+        callback.Run(content::PUSH_UNREGISTRATION_STATUS_SERVICE_ERROR);
+        break;
+      case GCMClient::NETWORK_ERROR:
+      case GCMClient::TTL_EXCEEDED:
+        callback.Run(
+            retry_on_failure
+            ? content::
+              PUSH_UNREGISTRATION_STATUS_PENDING_WILL_RETRY_NETWORK_ERROR
+            : content::PUSH_UNREGISTRATION_STATUS_NETWORK_ERROR);
+        break;
     }
   }
 }
 
 // OnContentSettingChanged methods ---------------------------------------------
 
 void PushMessagingServiceImpl::OnContentSettingChanged(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
@@ skipping 45 matching lines @@
   return permission_context->GetPermissionStatus(origin, origin) ==
       CONTENT_SETTING_ALLOW;
 }
 
 void PushMessagingServiceImpl::SetProfileForTesting(Profile* profile) {
   profile_ = profile;
   profile_->GetHostContentSettingsMap()->AddObserver(this);
 }
 
 }  // namespace gcm