page_load_metrics symbolic constants refactor

components/page_load_metrics/browser/metrics_web_contents_observer.cc

 // Copyright 2015 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 "components/page_load_metrics/browser/metrics_web_contents_observer.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "components/page_load_metrics/browser/page_load_metrics_macros.h"
@@ skipping 64 matching lines @@
 
   return true;
 }
 
 base::Time WallTimeFromTimeTicks(const base::TimeTicks& time) {
   return base::Time::FromDoubleT(
       (time - base::TimeTicks::UnixEpoch()).InSecondsF());
 }
 
 void RecordInternalError(InternalErrorLoadEvent event) {
-  UMA_HISTOGRAM_ENUMERATION(
-      "PageLoad.Events.InternalError", event, ERR_LAST_ENTRY);
+  UMA_HISTOGRAM_ENUMERATION(kErrorEvents, event, ERR_LAST_ENTRY);
 }
 
 base::TimeDelta GetFirstContentfulPaint(const PageLoadTiming& timing) {
   if (timing.first_text_paint.is_zero())
     return timing.first_image_paint;
   if (timing.first_image_paint.is_zero())
     return timing.first_text_paint;
   return std::min(timing.first_text_paint, timing.first_image_paint);
 }
 
@@ skipping 131 matching lines @@
   }
 
   PageLoadExtraInfo info = GetPageLoadMetricsInfo();
   FOR_EACH_OBSERVER(PageLoadMetricsObserver, *observers_,
                     OnComplete(timing_, info));
 
   base::TimeDelta background_delta = GetBackgroundDelta();
 
   if (!timing_.dom_content_loaded_event_start.is_zero()) {
     if (timing_.dom_content_loaded_event_start < background_delta) {
-      PAGE_LOAD_HISTOGRAM(
-          "PageLoad.Timing2.NavigationToDOMContentLoadedEventFired",
-          timing_.dom_content_loaded_event_start);
+      PAGE_LOAD_HISTOGRAM(kHistogramDomContentLoaded,
+                          timing_.dom_content_loaded_event_start);
     } else {
-      PAGE_LOAD_HISTOGRAM(
-          "PageLoad.Timing2.NavigationToDOMContentLoadedEventFired.Background",
-          timing_.dom_content_loaded_event_start);
+      PAGE_LOAD_HISTOGRAM(kBackgroundHistogramDomContentLoaded,
+                          timing_.dom_content_loaded_event_start);
     }
   }
   if (!timing_.load_event_start.is_zero()) {
     if (timing_.load_event_start < background_delta) {
-      PAGE_LOAD_HISTOGRAM("PageLoad.Timing2.NavigationToLoadEventFired",
-                          timing_.load_event_start);
+      PAGE_LOAD_HISTOGRAM(kHistogramLoad, timing_.load_event_start);
     } else {
-      PAGE_LOAD_HISTOGRAM(
-          "PageLoad.Timing2.NavigationToLoadEventFired.Background",
-          timing_.load_event_start);
+      PAGE_LOAD_HISTOGRAM(kBackgroundHistogramLoad, timing_.load_event_start);
     }
   }
   if (timing_.first_layout.is_zero()) {
     RecordCommittedEvent(COMMITTED_LOAD_FAILED_BEFORE_FIRST_LAYOUT,
                          HasBackgrounded());
   } else {
     if (timing_.first_layout < background_delta) {
-      PAGE_LOAD_HISTOGRAM("PageLoad.Timing2.NavigationToFirstLayout",
-                          timing_.first_layout);
+      PAGE_LOAD_HISTOGRAM(kHistogramFirstLayout, timing_.first_layout);
       RecordCommittedEvent(COMMITTED_LOAD_SUCCESSFUL_FIRST_LAYOUT, false);
     } else {
-      PAGE_LOAD_HISTOGRAM("PageLoad.Timing2.NavigationToFirstLayout.Background",
+      PAGE_LOAD_HISTOGRAM(kBackgroundHistogramFirstLayout,
                           timing_.first_layout);
       RecordCommittedEvent(COMMITTED_LOAD_SUCCESSFUL_FIRST_LAYOUT, true);
     }
   }
   if (!timing_.first_paint.is_zero()) {
     if (timing_.first_paint < background_delta) {
-      PAGE_LOAD_HISTOGRAM("PageLoad.Timing2.NavigationToFirstPaint",
-                          timing_.first_paint);
+      PAGE_LOAD_HISTOGRAM(kHistogramFirstPaint, timing_.first_paint);
     } else {
-      PAGE_LOAD_HISTOGRAM("PageLoad.Timing2.NavigationToFirstPaint.Background",
-                          timing_.first_paint);
+      PAGE_LOAD_HISTOGRAM(kBackgroundHistogramFirstPaint, timing_.first_paint);
     }
   }
   if (!timing_.first_text_paint.is_zero()) {
     if (timing_.first_text_paint < background_delta) {
-      PAGE_LOAD_HISTOGRAM("PageLoad.Timing2.NavigationToFirstTextPaint",
+      PAGE_LOAD_HISTOGRAM(kHistogramFirstTextPaint, timing_.first_text_paint);
+    } else {
+      PAGE_LOAD_HISTOGRAM(kBackgroundHistogramFirstTextPaint,
                           timing_.first_text_paint);
-    } else {
-      PAGE_LOAD_HISTOGRAM(
-          "PageLoad.Timing2.NavigationToFirstTextPaint.Background",
-          timing_.first_text_paint);
     }
   }
   if (!timing_.first_image_paint.is_zero()) {
     if (timing_.first_image_paint < background_delta) {
-      PAGE_LOAD_HISTOGRAM("PageLoad.Timing2.NavigationToFirstImagePaint",
+      PAGE_LOAD_HISTOGRAM(kHistogramFirstImagePaint, timing_.first_image_paint);
+    } else {
+      PAGE_LOAD_HISTOGRAM(kBackgroundHistogramFirstImagePaint,
                           timing_.first_image_paint);
-    } else {
-      PAGE_LOAD_HISTOGRAM(
-          "PageLoad.Timing2.NavigationToFirstImagePaint.Background",
-          timing_.first_image_paint);
     }
   }
   base::TimeDelta first_contentful_paint = GetFirstContentfulPaint(timing_);
   if (!first_contentful_paint.is_zero()) {
     if (first_contentful_paint < background_delta) {
-      PAGE_LOAD_HISTOGRAM("PageLoad.Timing2.NavigationToFirstContentfulPaint",
+      PAGE_LOAD_HISTOGRAM(kHistogramFirstContentfulPaint,
                           first_contentful_paint);
     } else {
-      PAGE_LOAD_HISTOGRAM(
-          "PageLoad.Timing2.NavigationToFirstContentfulPaint.Background",
-          first_contentful_paint);
+      PAGE_LOAD_HISTOGRAM(kBackgroundHistogramFirstContentfulPaint,
+                          first_contentful_paint);
     }
   }
 
   // Log time to first foreground / time to first background. Log counts that we
   // started a relevant page load in the foreground / background.
   if (!background_time_.is_null()) {
-    PAGE_LOAD_HISTOGRAM("PageLoad.Timing2.NavigationToFirstBackground",
-                        background_delta);
+    PAGE_LOAD_HISTOGRAM(kHistogramFirstBackground, background_delta);
   } else if (!foreground_time_.is_null()) {
     PAGE_LOAD_HISTOGRAM(
-        "PageLoad.Timing2.NavigationToFirstForeground",
+        kHistogramFirstForeground,
         WallTimeFromTimeTicks(foreground_time_) - timing_.navigation_start);
   }
 }
 
 void PageLoadTracker::RecordProvisionalEvent(ProvisionalLoadEvent event) {
   if (HasBackgrounded()) {
-    UMA_HISTOGRAM_ENUMERATION("PageLoad.Events.Provisional.Background", event,
+    UMA_HISTOGRAM_ENUMERATION(kBackgroundProvisionalEvents, event,
                               PROVISIONAL_LOAD_LAST_ENTRY);
   } else {
-    UMA_HISTOGRAM_ENUMERATION("PageLoad.Events.Provisional", event,
+    UMA_HISTOGRAM_ENUMERATION(kProvisionalEvents, event,
                               PROVISIONAL_LOAD_LAST_ENTRY);
   }
 }
 
 // RecordCommittedEvent needs a backgrounded input because we need to special
 // case a few events that need either precise timing measurements, or different
 // logic than simply "Did I background before logging this event?"
 void PageLoadTracker::RecordCommittedEvent(CommittedLoadEvent event,
                                            bool backgrounded) {
   if (backgrounded) {
-    UMA_HISTOGRAM_ENUMERATION("PageLoad.Events.Committed.Background", event,
+    UMA_HISTOGRAM_ENUMERATION(kBackgroundCommittedEvents, event,
                               COMMITTED_LOAD_LAST_ENTRY);
   } else {
-    UMA_HISTOGRAM_ENUMERATION("PageLoad.Events.Committed", event,
+    UMA_HISTOGRAM_ENUMERATION(kCommittedEvents, event,
                               COMMITTED_LOAD_LAST_ENTRY);
   }
 }
 
 void PageLoadTracker::RecordRappor() {
   DCHECK(!GetCommittedURL().is_empty());
   rappor::RapporService* rappor_service =
       embedder_interface_->GetRapporService();
   if (!rappor_service)
     return;
   base::TimeDelta first_contentful_paint = GetFirstContentfulPaint(timing_);
   // Log the eTLD+1 of sites that show poor loading performance.
   if (!first_contentful_paint.is_zero() &&
       first_contentful_paint < GetBackgroundDelta()) {
     scoped_ptr<rappor::Sample> sample =
         rappor_service->CreateSample(rappor::UMA_RAPPOR_TYPE);
     sample->SetStringField("Domain", rappor::GetDomainAndRegistrySampleFromGURL(
                                          GetCommittedURL()));
     uint64_t bucket_index = RapporHistogramBucketIndex(first_contentful_paint);
     sample->SetFlagsField("Bucket", uint64_t(1) << bucket_index,
                           kNumRapporHistogramBuckets);
     // The IsSlow flag is just a one bit boolean if the first layout was > 10s.
     sample->SetFlagsField("IsSlow", first_contentful_paint.InSecondsF() >= 10,
                           1);
-    rappor_service->RecordSampleObj(
-        "PageLoad.CoarseTiming.NavigationToFirstContentfulPaint",
-        sample.Pass());
+    rappor_service->RecordSampleObj(kRapporMetricsNameCoarseTiming,
+                                     sample.Pass());
   }
 }
 
 // static
 MetricsWebContentsObserver::MetricsWebContentsObserver(
     content::WebContents* web_contents,
     scoped_ptr<PageLoadMetricsEmbedderInterface> embedder_interface)
     : content::WebContentsObserver(web_contents),
       in_foreground_(false),
       embedder_interface_(embedder_interface.Pass()) {}
@@ skipping 161 matching lines @@
 
   if (!committed_load_->UpdateTiming(timing)) {
     // If the page load tracker cannot update its timing, something is wrong
     // with the IPC (it's from another load, or it's invalid in some other way).
     // We expect this to be a rare occurrence.
     RecordInternalError(ERR_BAD_TIMING_IPC);
   }
 }
 
 }  // namespace page_load_metrics