service worker: Attribute purpose to start worker attempts for UMA

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 "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_util.h"
 #include "content/common/service_worker/service_worker_types.h"
@@ skipping 50 matching lines @@
     case EventType::NOTIFICATION_CLOSE:
       return "Notification Close";
     case EventType::PUSH:
       return "Push";
     case EventType::GEOFENCING:
       return "Geofencing";
     case EventType::SERVICE_PORT_CONNECT:
       return "Service Port Connect";
     case EventType::MESSAGE:
       return "Message";
+    case EventType::FETCH_MAIN_FRAME:
+      return "Fetch Main Frame";
+    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::NUM_TYPES:
       break;
   }
   NOTREACHED() << "Got unexpected event type: " << static_cast<int>(event_type);
-  return "Unknown";
+  return "error";
 }
 
 bool ServiceWorkerMetrics::ShouldExcludeSiteFromHistogram(Site site) {
   return site == ServiceWorkerMetrics::Site::NEW_TAB_PAGE;
 }
 
 bool ServiceWorkerMetrics::ShouldExcludeURLFromHistogram(const GURL& url) {
   return ShouldExcludeSiteFromHistogram(SiteFromURL(url));
 }
 
@@ skipping 54 matching lines @@
                             static_cast<int>(Site::NUM_TYPES));
 
   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,
                               SERVICE_WORKER_ERROR_MAX_VALUE);
+    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));
+    }
   } else {
     UMA_HISTOGRAM_ENUMERATION("ServiceWorker.StartNewWorker.Status", status,
                               SERVICE_WORKER_ERROR_MAX_VALUE);
   }
 }
 
 void ServiceWorkerMetrics::RecordStartWorkerTime(const base::TimeDelta& time,
                                                  bool is_installed) {
   if (is_installed)
     UMA_HISTOGRAM_MEDIUM_TIMES("ServiceWorker.StartWorker.Time", time);
@@ skipping 51 matching lines @@
                                                const base::TimeDelta& time,
                                                bool was_handled) {
   switch (event) {
     case EventType::ACTIVATE:
       UMA_HISTOGRAM_MEDIUM_TIMES("ServiceWorker.ActivateEvent.Time", time);
       break;
     case EventType::INSTALL:
       UMA_HISTOGRAM_MEDIUM_TIMES("ServiceWorker.InstallEvent.Time", time);
       break;
     case EventType::FETCH:
+    case EventType::FETCH_MAIN_FRAME:
+    case EventType::FETCH_SUB_FRAME:
+    case EventType::FETCH_SHARED_WORKER:
+    case EventType::FETCH_SUB_RESOURCE:
       if (was_handled) {
         UMA_HISTOGRAM_MEDIUM_TIMES("ServiceWorker.FetchEvent.HasResponse.Time",
                                    time);
       } else {
         UMA_HISTOGRAM_MEDIUM_TIMES("ServiceWorker.FetchEvent.Fallback.Time",
                                    time);
       }
       break;
     case EventType::SYNC:
       UMA_HISTOGRAM_MEDIUM_TIMES("ServiceWorker.BackgroundSyncEvent.Time",
@@ skipping 13 matching lines @@
     case EventType::MESSAGE:
       // TODO(nhiroki): Record event duration for Message event after
       // ExtendableMessageEvent is enabled by default (crbug.com/543198).
       break;
 
     // For now event duration for these events is not recorded.
     case EventType::GEOFENCING:
     case EventType::SERVICE_PORT_CONNECT:
       break;
 
+    case EventType::UNKNOWN:
     case EventType::NUM_TYPES:
       NOTREACHED() << "Invalid event type";
       break;
   }
 }
 
 void ServiceWorkerMetrics::RecordFetchEventStatus(
     bool is_main_resource,
     ServiceWorkerStatusCode status) {
   if (is_main_resource) {
@@ skipping 35 matching lines @@
   UMA_HISTOGRAM_ENUMERATION("ServiceWorker.URLRequestJob.FallbackedRequestMode",
                             mode, FETCH_REQUEST_MODE_LAST + 1);
 }
 
 void ServiceWorkerMetrics::RecordTimeBetweenEvents(
     const base::TimeDelta& time) {
   UMA_HISTOGRAM_MEDIUM_TIMES("ServiceWorker.TimeBetweenEvents", time);
 }
 
 }  // namespace content