Add UMA for service worker navigation preload.

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 68 matching lines @@
     case ServiceWorkerMetrics::EventType::NAVIGATION_HINT_LINK_TAP_DOWN:
       return "_NAVIGATION_HINT_LINK_TAP_DOWN";
     case ServiceWorkerMetrics::EventType::EXTERNAL_REQUEST:
       return "_EXTERNAL_REQUEST";
     case ServiceWorkerMetrics::EventType::NUM_TYPES:
       NOTREACHED() << static_cast<int>(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 Preparation::STARTING;
+    case EmbeddedWorkerStatus::RUNNING:
+      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 EmbeddedWorkerStatus::RUNNING:
+    case Preparation::RUNNING:
       return "_RunningWorker";
-    case EmbeddedWorkerStatus::STOPPING:
+    case Preparation::STOPPING:
       return "_StoppingWorker";
   }
   NOTREACHED();
   return "_UNKNOWN";
 }
 
 std::string GetSiteSuffix(ServiceWorkerMetrics::Site site) {
   switch (site) {
     case ServiceWorkerMetrics::Site::OTHER:
     case ServiceWorkerMetrics::Site::WITH_FETCH_HANDLER:
@@ skipping 255 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("ServiceWorker.StartWorker.Timeout.StartPurpose",
                               static_cast<int>(purpose),
                               static_cast<int>(EventType::NUM_TYPES));
   }
 }
 
 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) {
   UMA_HISTOGRAM_ENUMERATION("ServiceWorker.WorkerStopped",
                             static_cast<int>(status),
                             static_cast<int>(StopStatus::NUM_TYPES));
 }
 
 void ServiceWorkerMetrics::RecordStopWorkerTime(base::TimeDelta time) {
   UMA_HISTOGRAM_MEDIUM_TIMES("ServiceWorker.StopWorker.Time", time);
@@ skipping 375 matching lines @@
     } else {
       UMA_HISTOGRAM_ENUMERATION(
           "ServiceWorker.ContextRequestHandlerStatus.NewWorker."
           "ImportedScript",
           value, max);
     }
   }
 }
 
 }  // namespace content