[Page Load Metrics] Add mojom file to page load metrics.

chrome/browser/page_load_metrics/observers/from_gws_page_load_metrics_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 "chrome/browser/page_load_metrics/observers/from_gws_page_load_metrics_observer.h"
 #include <string>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_util.h"
@@ skipping 209 matching lines @@
       PAGE_LOAD_HISTOGRAM(
           internal::kHistogramFromGWSAbortBackgroundBeforeCommit,
           abort_info.time_to_abort);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
-void LogForegroundDurations(const page_load_metrics::PageLoadTiming& timing,
-                            const page_load_metrics::PageLoadExtraInfo& info,
-                            base::TimeTicks app_background_time) {
+void LogForegroundDurations(
+    const page_load_metrics::mojom::PageLoadTiming& timing,
+    const page_load_metrics::PageLoadExtraInfo& info,
+    base::TimeTicks app_background_time) {
   base::Optional<base::TimeDelta> foreground_duration =
       GetInitialForegroundDuration(info, app_background_time);
   if (!foreground_duration)
     return;
 
   if (info.did_commit) {
     PAGE_LOAD_LONG_HISTOGRAM(internal::kHistogramFromGWSForegroundDuration,
                              foreground_duration.value());
-    if (timing.paint_timing.first_paint &&
-        timing.paint_timing.first_paint < foreground_duration) {
+    if (timing.paint_timing->first_paint &&
+        timing.paint_timing->first_paint < foreground_duration) {
       PAGE_LOAD_LONG_HISTOGRAM(
           internal::kHistogramFromGWSForegroundDurationAfterPaint,
           foreground_duration.value() -
-              timing.paint_timing.first_paint.value());
+              timing.paint_timing->first_paint.value());
       PAGE_LOAD_LONG_HISTOGRAM(
           internal::kHistogramFromGWSForegroundDurationWithPaint,
           foreground_duration.value());
     } else {
       PAGE_LOAD_LONG_HISTOGRAM(
           internal::kHistogramFromGWSForegroundDurationWithoutPaint,
           foreground_duration.value());
     }
   } else {
     PAGE_LOAD_LONG_HISTOGRAM(
@@ skipping 215 matching lines @@
                                    ui::PAGE_TRANSITION_LINK) &&
       ui::PageTransitionIsNewNavigation(
           navigation_handle->GetPageTransition()));
 
   logger_.SetNavigationStart(navigation_handle->NavigationStart());
   return CONTINUE_OBSERVING;
 }
 
 page_load_metrics::PageLoadMetricsObserver::ObservePolicy
 FromGWSPageLoadMetricsObserver::FlushMetricsOnAppEnterBackground(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   logger_.FlushMetricsOnAppEnterBackground(timing, extra_info);
   return STOP_OBSERVING;
 }
 
 void FromGWSPageLoadMetricsObserver::OnDomContentLoadedEventStart(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   logger_.OnDomContentLoadedEventStart(timing, extra_info);
 }
 
 void FromGWSPageLoadMetricsObserver::OnLoadEventStart(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   logger_.OnLoadEventStart(timing, extra_info);
 }
 
 void FromGWSPageLoadMetricsObserver::OnFirstPaintInPage(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   logger_.OnFirstPaintInPage(timing, extra_info);
 }
 
 void FromGWSPageLoadMetricsObserver::OnFirstTextPaintInPage(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   logger_.OnFirstTextPaintInPage(timing, extra_info);
 }
 
 void FromGWSPageLoadMetricsObserver::OnFirstImagePaintInPage(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   logger_.OnFirstImagePaintInPage(timing, extra_info);
 }
 
 void FromGWSPageLoadMetricsObserver::OnFirstContentfulPaintInPage(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   logger_.OnFirstContentfulPaintInPage(timing, extra_info);
 }
 
 void FromGWSPageLoadMetricsObserver::OnParseStart(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   logger_.OnParseStart(timing, extra_info);
 }
 
 void FromGWSPageLoadMetricsObserver::OnParseStop(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   logger_.OnParseStop(timing, extra_info);
 }
 
 void FromGWSPageLoadMetricsObserver::OnComplete(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   logger_.OnComplete(timing, extra_info);
 }
 
 void FromGWSPageLoadMetricsObserver::OnFailedProvisionalLoad(
     const page_load_metrics::FailedProvisionalLoadInfo& failed_load_info,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   logger_.OnFailedProvisionalLoad(failed_load_info, extra_info);
 }
 
 void FromGWSPageLoadMetricsObserver::OnUserInput(
     const blink::WebInputEvent& event) {
   logger_.OnUserInput(event);
 }
 
 void FromGWSPageLoadMetricsLogger::OnComplete(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   if (!ShouldLogPostCommitMetrics(extra_info.url))
     return;
 
   page_load_metrics::PageAbortInfo abort_info = GetPageAbortInfo(extra_info);
   if (!WasAbortedInForeground(extra_info, abort_info))
     return;
 
   // If we did not receive any timing IPCs from the render process, we can't
   // know for certain if the page was truly aborted before paint, or if the
   // abort happened before we received the IPC from the render process. Thus, we
   // do not log aborts for these page loads. Tracked page loads that receive no
   // timing IPCs are tracked via the ERR_NO_IPCS_RECEIVED error code in the
   // PageLoad.Events.InternalError histogram, so we can keep track of how often
   // this happens.
-  if (timing.IsEmpty())
+  if (page_load_metrics::IsEmpty(timing))
     return;
 
-  if (!timing.paint_timing.first_paint ||
-      timing.paint_timing.first_paint >= abort_info.time_to_abort) {
+  if (!timing.paint_timing->first_paint ||
+      timing.paint_timing->first_paint >= abort_info.time_to_abort) {
     LogCommittedAbortsBeforePaint(abort_info.reason, abort_info.time_to_abort);
   } else if (WasAbortedBeforeInteraction(abort_info,
                                          first_user_interaction_after_paint_)) {
     LogAbortsAfterPaintBeforeInteraction(abort_info);
   }
 
   LogForegroundDurations(timing, extra_info, base::TimeTicks());
 }
 
 void FromGWSPageLoadMetricsLogger::OnFailedProvisionalLoad(
     const page_load_metrics::FailedProvisionalLoadInfo& failed_load_info,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   if (!ShouldLogFailedProvisionalLoadMetrics())
     return;
 
   page_load_metrics::PageAbortInfo abort_info = GetPageAbortInfo(extra_info);
   if (!WasAbortedInForeground(extra_info, abort_info))
     return;
 
   LogProvisionalAborts(abort_info);
 
-  LogForegroundDurations(page_load_metrics::PageLoadTiming(), extra_info,
+  LogForegroundDurations(page_load_metrics::mojom::PageLoadTiming(), extra_info,
                          base::TimeTicks());
 }
 
 bool FromGWSPageLoadMetricsLogger::ShouldLogFailedProvisionalLoadMetrics() {
   // See comment in ShouldLogPostCommitMetrics above the call to
   // IsGoogleSearchHostname for more info on this if test.
   if (provisional_url_has_search_hostname_)
     return false;
 
   return previously_committed_url_is_search_results_ ||
@@ skipping 34 matching lines @@
 bool FromGWSPageLoadMetricsLogger::ShouldLogForegroundEventAfterCommit(
     const base::Optional<base::TimeDelta>& event,
     const page_load_metrics::PageLoadExtraInfo& info) {
   DCHECK(info.did_commit)
       << "ShouldLogForegroundEventAfterCommit called without committed URL.";
   return ShouldLogPostCommitMetrics(info.url) &&
          WasStartedInForegroundOptionalEventInForeground(event, info);
 }
 
 void FromGWSPageLoadMetricsLogger::OnDomContentLoadedEventStart(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   if (ShouldLogForegroundEventAfterCommit(
-          timing.document_timing.dom_content_loaded_event_start, extra_info)) {
+          timing.document_timing->dom_content_loaded_event_start, extra_info)) {
     PAGE_LOAD_HISTOGRAM(
         internal::kHistogramFromGWSDomContentLoaded,
-        timing.document_timing.dom_content_loaded_event_start.value());
+        timing.document_timing->dom_content_loaded_event_start.value());
   }
 }
 
 void FromGWSPageLoadMetricsLogger::OnLoadEventStart(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   if (ShouldLogForegroundEventAfterCommit(
-          timing.document_timing.load_event_start, extra_info)) {
+          timing.document_timing->load_event_start, extra_info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSLoad,
-                        timing.document_timing.load_event_start.value());
+                        timing.document_timing->load_event_start.value());
   }
 }
 
 void FromGWSPageLoadMetricsLogger::OnFirstPaintInPage(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
-  if (ShouldLogForegroundEventAfterCommit(timing.paint_timing.first_paint,
+  if (ShouldLogForegroundEventAfterCommit(timing.paint_timing->first_paint,
                                           extra_info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSFirstPaint,
-                        timing.paint_timing.first_paint.value());
+                        timing.paint_timing->first_paint.value());
   }
   first_paint_triggered_ = true;
 }
 
 void FromGWSPageLoadMetricsLogger::OnFirstTextPaintInPage(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
-  if (ShouldLogForegroundEventAfterCommit(timing.paint_timing.first_text_paint,
+  if (ShouldLogForegroundEventAfterCommit(timing.paint_timing->first_text_paint,
                                           extra_info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSFirstTextPaint,
-                        timing.paint_timing.first_text_paint.value());
+                        timing.paint_timing->first_text_paint.value());
   }
 }
 
 void FromGWSPageLoadMetricsLogger::OnFirstImagePaintInPage(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
-  if (ShouldLogForegroundEventAfterCommit(timing.paint_timing.first_image_paint,
-                                          extra_info)) {
+  if (ShouldLogForegroundEventAfterCommit(
+          timing.paint_timing->first_image_paint, extra_info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSFirstImagePaint,
-                        timing.paint_timing.first_image_paint.value());
+                        timing.paint_timing->first_image_paint.value());
   }
 }
 
 void FromGWSPageLoadMetricsLogger::OnFirstContentfulPaintInPage(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   if (ShouldLogForegroundEventAfterCommit(
-          timing.paint_timing.first_contentful_paint, extra_info)) {
+          timing.paint_timing->first_contentful_paint, extra_info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSFirstContentfulPaint,
-                        timing.paint_timing.first_contentful_paint.value());
+                        timing.paint_timing->first_contentful_paint.value());
 
     // If we have a foreground paint, we should have a foreground parse start,
     // since paints can't happen until after parsing starts.
     DCHECK(WasStartedInForegroundOptionalEventInForeground(
-        timing.parse_timing.parse_start, extra_info));
+        timing.parse_timing->parse_start, extra_info));
     PAGE_LOAD_HISTOGRAM(
         internal::kHistogramFromGWSParseStartToFirstContentfulPaint,
-        timing.paint_timing.first_contentful_paint.value() -
-            timing.parse_timing.parse_start.value());
+        timing.paint_timing->first_contentful_paint.value() -
+            timing.parse_timing->parse_start.value());
   }
 }
 
 void FromGWSPageLoadMetricsLogger::OnParseStart(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
-  if (ShouldLogForegroundEventAfterCommit(timing.parse_timing.parse_start,
+  if (ShouldLogForegroundEventAfterCommit(timing.parse_timing->parse_start,
                                           extra_info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSParseStart,
-                        timing.parse_timing.parse_start.value());
+                        timing.parse_timing->parse_start.value());
   }
 }
 
 void FromGWSPageLoadMetricsLogger::OnParseStop(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
-  if (ShouldLogForegroundEventAfterCommit(timing.parse_timing.parse_stop,
+  if (ShouldLogForegroundEventAfterCommit(timing.parse_timing->parse_stop,
                                           extra_info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSParseDuration,
-                        timing.parse_timing.parse_stop.value() -
-                            timing.parse_timing.parse_start.value());
+                        timing.parse_timing->parse_stop.value() -
+                            timing.parse_timing->parse_start.value());
   }
 }
 
 void FromGWSPageLoadMetricsLogger::OnUserInput(
     const blink::WebInputEvent& event) {
   if (first_paint_triggered_ && !first_user_interaction_after_paint_) {
     DCHECK(!navigation_start_.is_null());
     first_user_interaction_after_paint_ =
         base::TimeTicks::Now() - navigation_start_;
   }
 }
 
 void FromGWSPageLoadMetricsLogger::FlushMetricsOnAppEnterBackground(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   LogForegroundDurations(timing, extra_info, base::TimeTicks::Now());
 }