Introduce ServiceWorker.ActivatedWorkerPreparationForMainFrame.Time 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 <limits>
 #include <string>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_util.h"
+#include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/content_client.h"
 
 namespace content {
 
 namespace {
 
 std::string StartSituationToSuffix(
@@ skipping 42 matching lines @@
     case ServiceWorkerMetrics::EventType::UNKNOWN:
       return "_UNKNOWN";
     case ServiceWorkerMetrics::EventType::FOREIGN_FETCH:
       return "_FOREIGN_FETCH";
     case ServiceWorkerMetrics::EventType::NUM_TYPES:
       NOTREACHED() << static_cast<int>(event_type);
   }
   return "_UNKNOWN";
 }
 
+std::string GetWorkerPreparationSuffix(
+    EmbeddedWorkerStatus initial_worker_status,
+    ServiceWorkerMetrics::StartSituation start_situation) {
+  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 EmbeddedWorkerStatus::STARTING:
+      return "_StartingWorker";
+    case EmbeddedWorkerStatus::RUNNING:
+      return "_RunningWorker";
+    case EmbeddedWorkerStatus::STOPPING:
+      return "_StoppingWorker";
+  }
+  NOTREACHED();
+  return "_UNKNOWN";
+}
+
 // Use this for histograms with dynamically generated names, which
 // otherwise can't use the UMA_HISTOGRAM macro without code duplication.
 void RecordSuffixedTimeHistogram(const std::string& name,
                                  const std::string& suffix,
                                  base::TimeDelta sample) {
   const std::string name_with_suffix = name + suffix;
   // This unrolls UMA_HISTOGRAM_MEDIUM_TIMES.
   base::HistogramBase* histogram_pointer = base::Histogram::FactoryTimeGet(
       name_with_suffix, base::TimeDelta::FromMilliseconds(10),
       base::TimeDelta::FromMinutes(3), 50,
@@ skipping 196 matching lines @@
                                 time);
     RecordSuffixedTimeHistogram(
         "ServiceWorker.StartWorker.Time",
         StartSituationToSuffix(start_situation) + EventTypeToSuffix(purpose),
         time);
   } else {
     UMA_HISTOGRAM_MEDIUM_TIMES("ServiceWorker.StartNewWorker.Time", time);
   }
 }
 
+void ServiceWorkerMetrics::RecordActivatedWorkerPreparationTimeForMainFrame(
+    base::TimeDelta time,
+    EmbeddedWorkerStatus initial_worker_status,
+    StartSituation start_situation) {
+  std::string name =
+      "ServiceWorker.ActivatedWorkerPreparationForMainFrame.Time";
+  UMA_HISTOGRAM_MEDIUM_TIMES(name, time);
+  RecordSuffixedTimeHistogram(
+      name, GetWorkerPreparationSuffix(initial_worker_status, start_situation),
+      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 268 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