Add UMA for service worker navigation preload.

content/browser/service_worker/service_worker_metrics.cc

Index: content/browser/service_worker/service_worker_metrics.cc
diff --git a/content/browser/service_worker/service_worker_metrics.cc b/content/browser/service_worker/service_worker_metrics.cc
index af9dcb14a7c45042bdba48b00796bcb98ca8eabb..786a75758c706df1144da3d3a2b500ab29da0644 100644
--- a/content/browser/service_worker/service_worker_metrics.cc
+++ b/content/browser/service_worker/service_worker_metrics.cc
@@ -86,27 +86,54 @@ std::string EventTypeToSuffix(ServiceWorkerMetrics::EventType event_type) {
   return "_UNKNOWN";
 }
 
-std::string GetWorkerPreparationSuffix(
+ServiceWorkerMetrics::WorkerPreparationType GetWorkerPreparationType(
     EmbeddedWorkerStatus initial_worker_status,
     ServiceWorkerMetrics::StartSituation start_situation) {
+  using Situation = ServiceWorkerMetrics::StartSituation;
+  using Preparation = ServiceWorkerMetrics::WorkerPreparationType;
   switch (initial_worker_status) {
     case EmbeddedWorkerStatus::STOPPED: {
       switch (start_situation) {
-        case ServiceWorkerMetrics::StartSituation::DURING_STARTUP:
-          return "_StartWorkerDuringStartup";
-        case ServiceWorkerMetrics::StartSituation::NEW_PROCESS:
-          return "_StartWorkerNewProcess";
-        case ServiceWorkerMetrics::StartSituation::EXISTING_PROCESS:
-          return "_StartWorkerExistingProcess";
-        default:
-          NOTREACHED() << static_cast<int>(start_situation);
+        case Situation::DURING_STARTUP:
+          return Preparation::START_DURING_STARTUP;
+        case Situation::NEW_PROCESS:
+          return Preparation::START_IN_NEW_PROCESS;
+        case Situation::EXISTING_PROCESS:
+          return Preparation::START_IN_EXISTING_PROCESS;
+        case Situation::UNKNOWN:
+          break;
       }
+      break;
     }
     case EmbeddedWorkerStatus::STARTING:
-      return "_StartingWorker";
+      return Preparation::STARTING;
     case EmbeddedWorkerStatus::RUNNING:
-      return "_RunningWorker";
+      return Preparation::RUNNING;
     case EmbeddedWorkerStatus::STOPPING:
+      return Preparation::STOPPING;
+  }
+  NOTREACHED() << static_cast<int>(initial_worker_status);
+  return Preparation::UNKNOWN;
+}
+
+std::string GetWorkerPreparationSuffix(
+    ServiceWorkerMetrics::WorkerPreparationType status) {
+  using Preparation = ServiceWorkerMetrics::WorkerPreparationType;
+  switch (status) {
+    case Preparation::UNKNOWN:
+    case Preparation::NUM_TYPES:
+      break;
+    case Preparation::START_DURING_STARTUP:
+      return "_StartWorkerDuringStartup";
+    case Preparation::START_IN_NEW_PROCESS:
+      return "_StartWorkerNewProcess";
+    case Preparation::START_IN_EXISTING_PROCESS:
+      return "_StartWorkerExistingProcess";
+    case Preparation::STARTING:
+      return "_StartingWorker";
+    case Preparation::RUNNING:
+      return "_RunningWorker";
+    case Preparation::STOPPING:
       return "_StoppingWorker";
   }
   NOTREACHED();
@@ -382,30 +409,60 @@ void ServiceWorkerMetrics::RecordStartWorkerTime(base::TimeDelta time,
                                                  bool is_installed,
                                                  StartSituation start_situation,
                                                  EventType purpose) {
+  const std::string name = "ServiceWorker.StartWorker.Time";
   if (is_installed) {
-    std::string name = "ServiceWorker.StartWorker.Time";
     UMA_HISTOGRAM_MEDIUM_TIMES(name, time);
     RecordSuffixedMediumTimeHistogram(
         name, StartSituationToSuffix(start_situation), time);
     RecordSuffixedMediumTimeHistogram(
-        "ServiceWorker.StartWorker.Time",
+        name,
         StartSituationToSuffix(start_situation) + EventTypeToSuffix(purpose),
         time);
   } else {
-    UMA_HISTOGRAM_MEDIUM_TIMES("ServiceWorker.StartNewWorker.Time", time);
+    UMA_HISTOGRAM_MEDIUM_TIMES(name, time);

[falken, 2017/01/19 02:01:45]

Oh, this was wrong!

   }
 }
 
-void ServiceWorkerMetrics::RecordActivatedWorkerPreparationTimeForMainFrame(
+void ServiceWorkerMetrics::RecordActivatedWorkerPreparationForMainFrame(
     base::TimeDelta time,
     EmbeddedWorkerStatus initial_worker_status,
-    StartSituation start_situation) {
-  std::string name =
+    StartSituation start_situation,
+    bool did_navigation_preload) {
+  // Record the worker preparation type.
+  WorkerPreparationType preparation =
+      GetWorkerPreparationType(initial_worker_status, start_situation);
+  const std::string kTypeName =
+      "ServiceWorker.ActivatedWorkerPreparationForMainFrame.Type";
+  UMA_HISTOGRAM_ENUMERATION(kTypeName, static_cast<int>(preparation),
+                            static_cast<int>(WorkerPreparationType::NUM_TYPES));
+  if (did_navigation_preload) {
+    UMA_HISTOGRAM_ENUMERATION(
+        kTypeName + "_NavigationPreloadEnabled", static_cast<int>(preparation),

[rkaplow, 2017/01/19 01:37:53]

this isn't quite right, we don't allow the MACRO use with a non-const input.

You need to call the function that the macro uses. It's a bit ugly.
here's a example:
https://codesearch.chromium.org/chromium/src/ui/gl/angle_platform_impl.cc?q=L...

[falken, 2017/01/19 01:43:03]

Ah, I thought this was OK as long as the input is always the same, since the
macro caches the result after the first time. If that's not OK, could I just
change it to use const std::string kTypeNameForNavigationPreloadEnabled?

[rkaplow, 2017/01/19 01:52:10]

yeah - since you don't need it to be computed best to just inline it

[falken, 2017/01/19 02:01:45]

Done.

+        static_cast<int>(WorkerPreparationType::NUM_TYPES));
+  }
+
+  // Record the preparation time.
+  const std::string kTimeName =
       "ServiceWorker.ActivatedWorkerPreparationForMainFrame.Time";
-  UMA_HISTOGRAM_MEDIUM_TIMES(name, time);
+  UMA_HISTOGRAM_MEDIUM_TIMES(kTimeName, time);
+
+  // Record the preparation time using the worker preparation suffix.
   RecordSuffixedMediumTimeHistogram(
-      name, GetWorkerPreparationSuffix(initial_worker_status, start_situation),
-      time);
+      kTimeName, GetWorkerPreparationSuffix(preparation), time);
+
+  // Record the preparation time using the navigation preload suffix.
+  if (did_navigation_preload) {
+    UMA_HISTOGRAM_MEDIUM_TIMES(kTimeName + "_NavigationPreloadEnabled", time);
+    // We're mostly interested in when the worker needed to start up. To avoid
+    // using too much memory, just log the the common case of startup in an
+    // existing process.
+    if (preparation == WorkerPreparationType::START_IN_EXISTING_PROCESS) {
+      UMA_HISTOGRAM_MEDIUM_TIMES(kTimeName +
+                                     GetWorkerPreparationSuffix(preparation) +
+                                     "_NavigationPreloadEnabled",
+                                 time);
+    }
+  }
 }
 
 void ServiceWorkerMetrics::RecordWorkerStopped(StopStatus status) {