Keep ServiceWorkerMetrics::Site in ServiceWorkerVersion

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 126 matching lines @@
       base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram_pointer->Add(status);
 }
 
 void RecordURLMetricOnUI(const GURL& url) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   GetContentClient()->browser()->RecordURLMetric(
       "ServiceWorker.ControlledPageUrl", url);
 }
 
-ServiceWorkerMetrics::Site SiteFromURL(const GURL& gurl) {
-  // UIThreadSearchTermsData::GoogleBaseURLValue() returns the google base
-  // URL, but not available in content layer.
-  static const char google_like_scope_prefix[] = "https://www.google.";
-  static const char ntp_scope_path[] = "/_/chrome/";
-  if (base::StartsWith(gurl.spec(), google_like_scope_prefix,
-                       base::CompareCase::INSENSITIVE_ASCII) &&
-      base::StartsWith(gurl.path(), ntp_scope_path,
-                       base::CompareCase::SENSITIVE)) {
-    return ServiceWorkerMetrics::Site::NEW_TAB_PAGE;
-  }
-
-  return ServiceWorkerMetrics::Site::OTHER;
-}
-
 enum EventHandledRatioType {
   EVENT_HANDLED_NONE,
   EVENT_HANDLED_SOME,
   EVENT_HANDLED_ALL,
   NUM_EVENT_HANDLED_RATIO_TYPE,
 };
 
 }  // namespace
 
 const char* ServiceWorkerMetrics::EventTypeToString(EventType event_type) {
@@ skipping 34 matching lines @@
       return "Navigation Hint Link Tap Unconfirmed";
     case EventType::NAVIGATION_HINT_LINK_TAP_DOWN:
       return "Navigation Hint Link Tap Down";
     case EventType::NUM_TYPES:
       break;
   }
   NOTREACHED() << "Got unexpected event type: " << static_cast<int>(event_type);
   return "error";
 }
 
+ServiceWorkerMetrics::Site ServiceWorkerMetrics::SiteFromURL(
+    const GURL& url,
+    base::Optional<bool> has_fetch_handler) {
+  // UIThreadSearchTermsData::GoogleBaseURLValue() returns the google base
+  // URL, but not available in content layer.
+  static const char google_like_scope_prefix[] = "https://www.google.";
+  static const char ntp_scope_path[] = "/_/chrome/";
+  if (base::StartsWith(url.spec(), google_like_scope_prefix,
+                       base::CompareCase::INSENSITIVE_ASCII) &&
+      base::StartsWith(url.path(), ntp_scope_path,
+                       base::CompareCase::SENSITIVE)) {
+    return ServiceWorkerMetrics::Site::NEW_TAB_PAGE;
+  }
+
+  if (!has_fetch_handler)
+    return ServiceWorkerMetrics::Site::OTHER;
+  if (has_fetch_handler.value())
+    return ServiceWorkerMetrics::Site::WITH_FETCH_HANDLER;
+  return ServiceWorkerMetrics::Site::WITHOUT_FETCH_HANDLER;
+}
+
 bool ServiceWorkerMetrics::IsNavigationHintEvent(EventType event_type) {
   return event_type == EventType::NAVIGATION_HINT_LINK_MOUSE_DOWN ||
          event_type == EventType::NAVIGATION_HINT_LINK_TAP_UNCONFIRMED ||
          event_type == EventType::NAVIGATION_HINT_LINK_TAP_DOWN;
 }
 
 bool ServiceWorkerMetrics::ShouldExcludeSiteFromHistogram(Site site) {
   return site == ServiceWorkerMetrics::Site::NEW_TAB_PAGE;
 }
 
-bool ServiceWorkerMetrics::ShouldExcludeURLFromHistogram(const GURL& url) {
-  return ShouldExcludeSiteFromHistogram(SiteFromURL(url));
-}
-
 void ServiceWorkerMetrics::CountInitDiskCacheResult(bool result) {
   UMA_HISTOGRAM_BOOLEAN("ServiceWorker.DiskCache.InitResult", result);
 }
 
 void ServiceWorkerMetrics::CountReadResponseResult(
     ServiceWorkerMetrics::ReadResponseResult result) {
   UMA_HISTOGRAM_ENUMERATION("ServiceWorker.DiskCache.ReadResponseResult",
                             result, NUM_READ_RESPONSE_RESULT_TYPES);
 }
 
@@ skipping 31 matching lines @@
   UMA_HISTOGRAM_SPARSE_SLOWLY("ServiceWorker.Storage.PurgeResourceResult",
                               std::abs(net_error));
 }
 
 void ServiceWorkerMetrics::RecordDeleteAndStartOverResult(
     DeleteAndStartOverResult result) {
   UMA_HISTOGRAM_ENUMERATION("ServiceWorker.Storage.DeleteAndStartOverResult",
                             result, NUM_DELETE_AND_START_OVER_RESULT_TYPES);
 }
 
-void ServiceWorkerMetrics::CountControlledPageLoad(const GURL& url,
-                                                   bool has_fetch_handler,
+void ServiceWorkerMetrics::CountControlledPageLoad(Site site,
+                                                   const GURL& url,
                                                    bool is_main_frame_load) {
-  Site site = SiteFromURL(url);
-  if (site == Site::OTHER) {
-    site = (has_fetch_handler) ? Site::WITH_FETCH_HANDLER
-                               : Site::WITHOUT_FETCH_HANDLER;
-  }
+  DCHECK_NE(site, Site::OTHER);
   UMA_HISTOGRAM_ENUMERATION("ServiceWorker.PageLoad", static_cast<int>(site),
                             static_cast<int>(Site::NUM_TYPES));
   if (is_main_frame_load) {
     UMA_HISTOGRAM_ENUMERATION("ServiceWorker.MainFramePageLoad",
                               static_cast<int>(site),
                               static_cast<int>(Site::NUM_TYPES));
   }
 
   if (ShouldExcludeSiteFromHistogram(site))
     return;
@@ skipping 376 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