ServiceWorker: Keep the worker alive until FetchEvent.waitUntil settles

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 88 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::FETCH_WAITUNTIL:
+      return "Fetch WaitUntil";
     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 135 matching lines @@
     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::FETCH_WAITUNTIL:
+      UMA_HISTOGRAM_ENUMERATION(
+          "ServiceWorker.StartWorker.StatusByPurpose_FETCH_WAITUNTIL", 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",
@@ skipping 90 matching lines @@
     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::FETCH_WAITUNTIL:
+      UMA_HISTOGRAM_MEDIUM_TIMES("ServiceWorker.FetchEvent.WaitUntil.Time",
+                                 time);
+      break;
     case EventType::FOREIGN_FETCH:
       if (was_handled) {
         UMA_HISTOGRAM_MEDIUM_TIMES(
             "ServiceWorker.ForeignFetchEvent.HasResponse.Time", time);
       } else {
         UMA_HISTOGRAM_MEDIUM_TIMES(
             "ServiceWorker.ForeignFetchEvent.Fallback.Time", time);
       }
       break;
     case EventType::SYNC:
@@ skipping 179 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