service worker: Add UMA for start status grouped by start purpose.

content/browser/service_worker/service_worker_metrics.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 "content/browser/service_worker/service_worker_metrics.h"
 
 #include <limits>
 #include <string>
 
 #include "base/metrics/histogram_macros.h"
@@ skipping 90 matching lines @@
     case EventType::FETCH_SUB_FRAME:
       return "Fetch Sub Frame";
     case EventType::FETCH_SHARED_WORKER:
       return "Fetch Shared Worker";
     case EventType::FETCH_SUB_RESOURCE:
       return "Fetch Subresource";
     case EventType::UNKNOWN:
       return "Unknown";
     case EventType::FOREIGN_FETCH:
       return "Foreign Fetch";
-    case EventType::DEPRECATED_FETCH:
     case EventType::NUM_TYPES:
       break;
   }
   NOTREACHED() << "Got unexpected event type: " << static_cast<int>(event_type);
   return "error";
 }
 
 bool ServiceWorkerMetrics::ShouldExcludeSiteFromHistogram(Site site) {
   return site == ServiceWorkerMetrics::Site::NEW_TAB_PAGE;
 }
@@ skipping 61 matching lines @@
   if (ShouldExcludeSiteFromHistogram(site))
     return;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&RecordURLMetricOnUI, url));
 }
 
 void ServiceWorkerMetrics::RecordStartWorkerStatus(
     ServiceWorkerStatusCode status,
     EventType purpose,
     bool is_installed) {
-  if (is_installed) {
-    UMA_HISTOGRAM_ENUMERATION("ServiceWorker.StartWorker.Status", status,
+  if (!is_installed) {
+    UMA_HISTOGRAM_ENUMERATION("ServiceWorker.StartNewWorker.Status", status,
                               SERVICE_WORKER_ERROR_MAX_VALUE);
-    UMA_HISTOGRAM_ENUMERATION("ServiceWorker.StartWorker.Purpose",
+    return;
+  }
+
+  UMA_HISTOGRAM_ENUMERATION("ServiceWorker.StartWorker.Status", status,
+                            SERVICE_WORKER_ERROR_MAX_VALUE);
+  switch (purpose) {
+    case EventType::ACTIVATE:
+      UMA_HISTOGRAM_ENUMERATION(
+          "ServiceWorker.StartWorker.StatusByPurpose_ACTIVATE", status,
+          SERVICE_WORKER_ERROR_MAX_VALUE);
+      break;
+    case EventType::INSTALL:
+      UMA_HISTOGRAM_ENUMERATION(
+          "ServiceWorker.StartWorker.StatusByPurpose_INSTALL", status,
+          SERVICE_WORKER_ERROR_MAX_VALUE);
+      break;
+    case EventType::SYNC:
+      UMA_HISTOGRAM_ENUMERATION(
+          "ServiceWorker.StartWorker.StatusByPurpose_SYNC", status,
+          SERVICE_WORKER_ERROR_MAX_VALUE);
+      break;
+    case EventType::NOTIFICATION_CLICK:
+      UMA_HISTOGRAM_ENUMERATION(
+          "ServiceWorker.StartWorker.StatusByPurpose_NOTIFICATION_CLICK",
+          status, SERVICE_WORKER_ERROR_MAX_VALUE);
+      break;
+    case EventType::PUSH:
+      UMA_HISTOGRAM_ENUMERATION(
+          "ServiceWorker.StartWorker.StatusByPurpose_PUSH", status,
+          SERVICE_WORKER_ERROR_MAX_VALUE);
+      break;
+    case EventType::GEOFENCING:
+      UMA_HISTOGRAM_ENUMERATION(
+          "ServiceWorker.StartWorker.StatusByPurpose_GEOFENCING", status,
+          SERVICE_WORKER_ERROR_MAX_VALUE);
+      break;
+    case EventType::MESSAGE:
+      UMA_HISTOGRAM_ENUMERATION(
+          "ServiceWorker.StartWorker.StatusByPurpose_MESSAGE", status,
+          SERVICE_WORKER_ERROR_MAX_VALUE);
+      break;
+    case EventType::NOTIFICATION_CLOSE:
+      UMA_HISTOGRAM_ENUMERATION(
+          "ServiceWorker.StartWorker.StatusByPurpose_NOTIFICATION_CLOSE",
+          status, SERVICE_WORKER_ERROR_MAX_VALUE);
+      break;
+    case EventType::FETCH_MAIN_FRAME:
+      UMA_HISTOGRAM_ENUMERATION(
+          "ServiceWorker.StartWorker.StatusByPurpose_FETCH_MAIN_FRAME", status,
+          SERVICE_WORKER_ERROR_MAX_VALUE);
+      break;
+    case EventType::FETCH_SUB_FRAME:
+      UMA_HISTOGRAM_ENUMERATION(
+          "ServiceWorker.StartWorker.StatusByPurpose_FETCH_SUB_FRAME", status,
+          SERVICE_WORKER_ERROR_MAX_VALUE);
+      break;
+    case EventType::FETCH_SHARED_WORKER:
+      UMA_HISTOGRAM_ENUMERATION(
+          "ServiceWorker.StartWorker.StatusByPurpose_FETCH_SHARED_WORKER",
+          status, SERVICE_WORKER_ERROR_MAX_VALUE);
+      break;
+    case EventType::FETCH_SUB_RESOURCE:
+      UMA_HISTOGRAM_ENUMERATION(
+          "ServiceWorker.StartWorker.StatusByPurpose_FETCH_SUB_RESOURCE",
+          status, SERVICE_WORKER_ERROR_MAX_VALUE);
+      break;
+    case EventType::UNKNOWN:
+      UMA_HISTOGRAM_ENUMERATION(
+          "ServiceWorker.StartWorker.StatusByPurpose_UNKNOWN", status,
+          SERVICE_WORKER_ERROR_MAX_VALUE);
+      break;
+    case EventType::FOREIGN_FETCH:
+      UMA_HISTOGRAM_ENUMERATION(
+          "ServiceWorker.StartWorker.StatusByPurpose_FOREIGN_FETCH", status,
+          SERVICE_WORKER_ERROR_MAX_VALUE);
+      break;
+    case EventType::NUM_TYPES:
+      NOTREACHED();
+      break;
+  }
+
+  UMA_HISTOGRAM_ENUMERATION("ServiceWorker.StartWorker.Purpose",
+                            static_cast<int>(purpose),
+                            static_cast<int>(EventType::NUM_TYPES));
+  if (status == SERVICE_WORKER_ERROR_TIMEOUT) {
+    UMA_HISTOGRAM_ENUMERATION("ServiceWorker.StartWorker.Timeout.StartPurpose",
                               static_cast<int>(purpose),
                               static_cast<int>(EventType::NUM_TYPES));
-    if (status == SERVICE_WORKER_ERROR_TIMEOUT) {
-      UMA_HISTOGRAM_ENUMERATION(
-          "ServiceWorker.StartWorker.Timeout.StartPurpose",
-          static_cast<int>(purpose), static_cast<int>(EventType::NUM_TYPES));
-    }
-  } else {
-    UMA_HISTOGRAM_ENUMERATION("ServiceWorker.StartNewWorker.Status", status,
-                              SERVICE_WORKER_ERROR_MAX_VALUE);
   }
 }
 
 void ServiceWorkerMetrics::RecordStartWorkerTime(
     base::TimeDelta time,
     bool is_installed,
     StartSituation start_situation) {
   if (is_installed) {
     std::string name = "ServiceWorker.StartWorker.Time";
     UMA_HISTOGRAM_MEDIUM_TIMES(name, time);
@@ skipping 111 matching lines @@
       break;
     case EventType::MESSAGE:
       UMA_HISTOGRAM_MEDIUM_TIMES("ServiceWorker.ExtendableMessageEvent.Time",
                                  time);
       break;
 
     // For now event duration for these events is not recorded.
     case EventType::GEOFENCING:
       break;
 
-    case EventType::DEPRECATED_FETCH:
     case EventType::UNKNOWN:
     case EventType::NUM_TYPES:
       NOTREACHED() << "Invalid event type";
       break;
   }
 }
 
 void ServiceWorkerMetrics::RecordFetchEventStatus(
     bool is_main_resource,
     ServiceWorkerStatusCode status) {
@@ skipping 150 matching lines @@
   } else if (failure_count == 2) {
     UMA_HISTOGRAM_ENUMERATION("ServiceWorker.StartWorker.AfterFailureStreak_2",
                               status, SERVICE_WORKER_ERROR_MAX_VALUE);
   } else if (failure_count == 3) {
     UMA_HISTOGRAM_ENUMERATION("ServiceWorker.StartWorker.AfterFailureStreak_3",
                               status, SERVICE_WORKER_ERROR_MAX_VALUE);
   }
 }
 
 }  // namespace content