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

chrome/browser/page_load_metrics/observers/core_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/core_page_load_metrics_observer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <memory>
 #include <utility>
@@ skipping 265 matching lines @@
   if (headers) {
     was_no_store_main_resource_ =
         headers->HasHeaderValue("cache-control", "no-store");
   }
   UMA_HISTOGRAM_COUNTS_100("PageLoad.Navigation.RedirectChainLength",
                            redirect_chain_size_);
   return CONTINUE_OBSERVING;
 }
 
 void CorePageLoadMetricsObserver::OnDomContentLoadedEventStart(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   if (WasStartedInForegroundOptionalEventInForeground(
-          timing.document_timing.dom_content_loaded_event_start, info)) {
+          timing.document_timing->dom_content_loaded_event_start, info)) {
     PAGE_LOAD_HISTOGRAM(
         internal::kHistogramDomContentLoaded,
-        timing.document_timing.dom_content_loaded_event_start.value());
+        timing.document_timing->dom_content_loaded_event_start.value());
   } else {
     PAGE_LOAD_HISTOGRAM(
         internal::kBackgroundHistogramDomContentLoaded,
-        timing.document_timing.dom_content_loaded_event_start.value());
+        timing.document_timing->dom_content_loaded_event_start.value());
   }
 }
 
 void CorePageLoadMetricsObserver::OnLoadEventStart(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   if (WasStartedInForegroundOptionalEventInForeground(
-          timing.document_timing.load_event_start, info)) {
+          timing.document_timing->load_event_start, info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramLoad,
-                        timing.document_timing.load_event_start.value());
+                        timing.document_timing->load_event_start.value());
   } else {
     PAGE_LOAD_HISTOGRAM(internal::kBackgroundHistogramLoad,
-                        timing.document_timing.load_event_start.value());
+                        timing.document_timing->load_event_start.value());
   }
 }
 
 void CorePageLoadMetricsObserver::OnFirstLayout(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   if (WasStartedInForegroundOptionalEventInForeground(
-          timing.document_timing.first_layout, info)) {
+          timing.document_timing->first_layout, info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramFirstLayout,
-                        timing.document_timing.first_layout.value());
+                        timing.document_timing->first_layout.value());
   } else {
     PAGE_LOAD_HISTOGRAM(internal::kBackgroundHistogramFirstLayout,
-                        timing.document_timing.first_layout.value());
+                        timing.document_timing->first_layout.value());
   }
 }
 
 void CorePageLoadMetricsObserver::OnFirstPaintInPage(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   first_paint_ =
-      info.navigation_start + timing.paint_timing.first_paint.value();
+      info.navigation_start + timing.paint_timing->first_paint.value();
   if (WasStartedInForegroundOptionalEventInForeground(
-          timing.paint_timing.first_paint, info)) {
+          timing.paint_timing->first_paint, info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramFirstPaint,
-                        timing.paint_timing.first_paint.value());
+                        timing.paint_timing->first_paint.value());
   } else {
     PAGE_LOAD_HISTOGRAM(internal::kBackgroundHistogramFirstPaint,
-                        timing.paint_timing.first_paint.value());
+                        timing.paint_timing->first_paint.value());
   }
 
   // Record the time to first paint for pages which were:
   // - Opened in the background.
   // - Moved to the foreground prior to the first paint.
   // - Not moved back to the background prior to the first paint.
   if (!info.started_in_foreground && info.first_foreground_time &&
       info.first_foreground_time.value() <=
-          timing.paint_timing.first_paint.value() &&
-      (!info.first_background_time || timing.paint_timing.first_paint.value() <=
-                                          info.first_background_time.value())) {
+          timing.paint_timing->first_paint.value() &&
+      (!info.first_background_time ||
+       timing.paint_timing->first_paint.value() <=
+           info.first_background_time.value())) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramForegroundToFirstPaint,
-                        timing.paint_timing.first_paint.value() -
+                        timing.paint_timing->first_paint.value() -
                             info.first_foreground_time.value());
   }
 }
 
 void CorePageLoadMetricsObserver::OnFirstTextPaintInPage(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   if (WasStartedInForegroundOptionalEventInForeground(
-          timing.paint_timing.first_text_paint, info)) {
+          timing.paint_timing->first_text_paint, info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramFirstTextPaint,
-                        timing.paint_timing.first_text_paint.value());
+                        timing.paint_timing->first_text_paint.value());
   } else {
     PAGE_LOAD_HISTOGRAM(internal::kBackgroundHistogramFirstTextPaint,
-                        timing.paint_timing.first_text_paint.value());
+                        timing.paint_timing->first_text_paint.value());
   }
 }
 
 void CorePageLoadMetricsObserver::OnFirstImagePaintInPage(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   if (WasStartedInForegroundOptionalEventInForeground(
-          timing.paint_timing.first_image_paint, info)) {
+          timing.paint_timing->first_image_paint, info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramFirstImagePaint,
-                        timing.paint_timing.first_image_paint.value());
+                        timing.paint_timing->first_image_paint.value());
   } else {
     PAGE_LOAD_HISTOGRAM(internal::kBackgroundHistogramFirstImagePaint,
-                        timing.paint_timing.first_image_paint.value());
+                        timing.paint_timing->first_image_paint.value());
   }
 }
 
 void CorePageLoadMetricsObserver::OnFirstContentfulPaintInPage(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   if (WasStartedInForegroundOptionalEventInForeground(
-          timing.paint_timing.first_contentful_paint, info)) {
+          timing.paint_timing->first_contentful_paint, info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramFirstContentfulPaint,
-                        timing.paint_timing.first_contentful_paint.value());
+                        timing.paint_timing->first_contentful_paint.value());
     PAGE_LOAD_HISTOGRAM(internal::kHistogramParseStartToFirstContentfulPaint,
-                        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());
 
     if (was_no_store_main_resource_) {
       PAGE_LOAD_HISTOGRAM(internal::kHistogramFirstContentfulPaintNoStore,
-                          timing.paint_timing.first_contentful_paint.value());
+                          timing.paint_timing->first_contentful_paint.value());
     }
 
     // TODO(bmcquade): consider adding a histogram that uses
     // UserInputInfo.user_input_event.
     if (info.user_initiated_info.browser_initiated ||
         info.user_initiated_info.user_gesture) {
       PAGE_LOAD_HISTOGRAM(internal::kHistogramFirstContentfulPaintUserInitiated,
-                          timing.paint_timing.first_contentful_paint.value());
+                          timing.paint_timing->first_contentful_paint.value());
     }
 
     if (timing.style_sheet_timing
-            .author_style_sheet_parse_duration_before_fcp) {
+            ->author_style_sheet_parse_duration_before_fcp) {
       PAGE_LOAD_HISTOGRAM(
           "PageLoad.CSSTiming.Parse.BeforeFirstContentfulPaint",
-          timing.style_sheet_timing.author_style_sheet_parse_duration_before_fcp
-              .value());
+          timing.style_sheet_timing
+              ->author_style_sheet_parse_duration_before_fcp.value());
     }
-    if (timing.style_sheet_timing.update_style_duration_before_fcp) {
+    if (timing.style_sheet_timing->update_style_duration_before_fcp) {
       PAGE_LOAD_HISTOGRAM(
           "PageLoad.CSSTiming.Update.BeforeFirstContentfulPaint",
-          timing.style_sheet_timing.update_style_duration_before_fcp.value());
+          timing.style_sheet_timing->update_style_duration_before_fcp.value());
     }
     if (timing.style_sheet_timing
-            .author_style_sheet_parse_duration_before_fcp ||
-        timing.style_sheet_timing.update_style_duration_before_fcp) {
+            ->author_style_sheet_parse_duration_before_fcp ||
+        timing.style_sheet_timing->update_style_duration_before_fcp) {
       PAGE_LOAD_HISTOGRAM(
           "PageLoad.CSSTiming.ParseAndUpdate.BeforeFirstContentfulPaint",
-          timing.style_sheet_timing.author_style_sheet_parse_duration_before_fcp
-                  .value_or(base::TimeDelta()) +
-              timing.style_sheet_timing.update_style_duration_before_fcp
+          timing.style_sheet_timing
+                  ->author_style_sheet_parse_duration_before_fcp.value_or(
+                      base::TimeDelta()) +
+              timing.style_sheet_timing->update_style_duration_before_fcp
                   .value_or(base::TimeDelta()));
     }
 
     switch (GetPageLoadType(transition_)) {
       case LOAD_TYPE_RELOAD:
         PAGE_LOAD_HISTOGRAM(
             internal::kHistogramLoadTypeFirstContentfulPaintReload,
-            timing.paint_timing.first_contentful_paint.value());
+            timing.paint_timing->first_contentful_paint.value());
         // TODO(bmcquade): consider adding a histogram that uses
         // UserInputInfo.user_input_event.
         if (info.user_initiated_info.browser_initiated ||
             info.user_initiated_info.user_gesture) {
           PAGE_LOAD_HISTOGRAM(
               internal::kHistogramLoadTypeFirstContentfulPaintReloadByGesture,
-              timing.paint_timing.first_contentful_paint.value());
+              timing.paint_timing->first_contentful_paint.value());
         }
         break;
       case LOAD_TYPE_FORWARD_BACK:
         PAGE_LOAD_HISTOGRAM(
             internal::kHistogramLoadTypeFirstContentfulPaintForwardBack,
-            timing.paint_timing.first_contentful_paint.value());
+            timing.paint_timing->first_contentful_paint.value());
         if (was_no_store_main_resource_) {
           PAGE_LOAD_HISTOGRAM(
               internal::
                   kHistogramLoadTypeFirstContentfulPaintForwardBackNoStore,
-              timing.paint_timing.first_contentful_paint.value());
+              timing.paint_timing->first_contentful_paint.value());
         }
         break;
       case LOAD_TYPE_NEW_NAVIGATION:
         PAGE_LOAD_HISTOGRAM(
             internal::kHistogramLoadTypeFirstContentfulPaintNewNavigation,
-            timing.paint_timing.first_contentful_paint.value());
+            timing.paint_timing->first_contentful_paint.value());
         break;
       case LOAD_TYPE_NONE:
         NOTREACHED();
         break;
     }
   } else {
     PAGE_LOAD_HISTOGRAM(internal::kBackgroundHistogramFirstContentfulPaint,
-                        timing.paint_timing.first_contentful_paint.value());
+                        timing.paint_timing->first_contentful_paint.value());
     PAGE_LOAD_HISTOGRAM(
         internal::kBackgroundHistogramParseStartToFirstContentfulPaint,
-        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 CorePageLoadMetricsObserver::OnFirstMeaningfulPaintInMainFrameDocument(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   base::TimeTicks paint = info.navigation_start +
-                          timing.paint_timing.first_meaningful_paint.value();
+                          timing.paint_timing->first_meaningful_paint.value();
   if (first_user_interaction_after_first_paint_.is_null() ||
       paint < first_user_interaction_after_first_paint_) {
     if (WasStartedInForegroundOptionalEventInForeground(
-            timing.paint_timing.first_meaningful_paint, info)) {
+            timing.paint_timing->first_meaningful_paint, info)) {
       PAGE_LOAD_HISTOGRAM(internal::kHistogramFirstMeaningfulPaint,
-                          timing.paint_timing.first_meaningful_paint.value());
+                          timing.paint_timing->first_meaningful_paint.value());
       PAGE_LOAD_HISTOGRAM(internal::kHistogramParseStartToFirstMeaningfulPaint,
-                          timing.paint_timing.first_meaningful_paint.value() -
-                              timing.parse_timing.parse_start.value());
+                          timing.paint_timing->first_meaningful_paint.value() -
+                              timing.parse_timing->parse_start.value());
       PAGE_LOAD_HISTOGRAM(
           internal::kHistogramFirstMeaningfulPaintToNetworkStable,
           base::TimeTicks::Now() - paint);
       RecordFirstMeaningfulPaintStatus(
           internal::FIRST_MEANINGFUL_PAINT_RECORDED);
     } else {
       RecordFirstMeaningfulPaintStatus(
           internal::FIRST_MEANINGFUL_PAINT_BACKGROUNDED);
     }
   } else {
     RecordFirstMeaningfulPaintStatus(
           internal::FIRST_MEANINGFUL_PAINT_USER_INTERACTION_BEFORE_FMP);
   }
 }
 
 void CorePageLoadMetricsObserver::OnParseStart(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   if (WasStartedInForegroundOptionalEventInForeground(
-          timing.parse_timing.parse_start, info)) {
+          timing.parse_timing->parse_start, info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramParseStart,
-                        timing.parse_timing.parse_start.value());
+                        timing.parse_timing->parse_start.value());
 
     switch (GetPageLoadType(transition_)) {
       case LOAD_TYPE_RELOAD:
         PAGE_LOAD_HISTOGRAM(internal::kHistogramLoadTypeParseStartReload,
-                            timing.parse_timing.parse_start.value());
+                            timing.parse_timing->parse_start.value());
         break;
       case LOAD_TYPE_FORWARD_BACK:
         PAGE_LOAD_HISTOGRAM(internal::kHistogramLoadTypeParseStartForwardBack,
-                            timing.parse_timing.parse_start.value());
+                            timing.parse_timing->parse_start.value());
         if (was_no_store_main_resource_) {
           PAGE_LOAD_HISTOGRAM(
               internal::kHistogramLoadTypeParseStartForwardBackNoStore,
-              timing.parse_timing.parse_start.value());
+              timing.parse_timing->parse_start.value());
         }
         break;
       case LOAD_TYPE_NEW_NAVIGATION:
         PAGE_LOAD_HISTOGRAM(internal::kHistogramLoadTypeParseStartNewNavigation,
-                            timing.parse_timing.parse_start.value());
+                            timing.parse_timing->parse_start.value());
         break;
       case LOAD_TYPE_NONE:
         NOTREACHED();
         break;
     }
   } else {
     PAGE_LOAD_HISTOGRAM(internal::kBackgroundHistogramParseStart,
-                        timing.parse_timing.parse_start.value());
+                        timing.parse_timing->parse_start.value());
   }
 }
 
 void CorePageLoadMetricsObserver::OnParseStop(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
-  base::TimeDelta parse_duration = timing.parse_timing.parse_stop.value() -
-                                   timing.parse_timing.parse_start.value();
+  base::TimeDelta parse_duration = timing.parse_timing->parse_stop.value() -
+                                   timing.parse_timing->parse_start.value();
   if (WasStartedInForegroundOptionalEventInForeground(
-          timing.parse_timing.parse_stop, info)) {
+          timing.parse_timing->parse_stop, info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramParseDuration, parse_duration);
     PAGE_LOAD_HISTOGRAM(
         internal::kHistogramParseBlockedOnScriptLoad,
-        timing.parse_timing.parse_blocked_on_script_load_duration.value());
+        timing.parse_timing->parse_blocked_on_script_load_duration.value());
     PAGE_LOAD_HISTOGRAM(
         internal::kHistogramParseBlockedOnScriptLoadDocumentWrite,
         timing.parse_timing
-            .parse_blocked_on_script_load_from_document_write_duration.value());
+            ->parse_blocked_on_script_load_from_document_write_duration
+            .value());
     PAGE_LOAD_HISTOGRAM(
         internal::kHistogramParseBlockedOnScriptExecution,
-        timing.parse_timing.parse_blocked_on_script_execution_duration.value());
+        timing.parse_timing->parse_blocked_on_script_execution_duration
+            .value());
     PAGE_LOAD_HISTOGRAM(
         internal::kHistogramParseBlockedOnScriptExecutionDocumentWrite,
         timing.parse_timing
-            .parse_blocked_on_script_execution_from_document_write_duration
+            ->parse_blocked_on_script_execution_from_document_write_duration
             .value());
 
     int total_resources = num_cache_resources_ + num_network_resources_;
     if (total_resources) {
       int percent_cached = (100 * num_cache_resources_) / total_resources;
       UMA_HISTOGRAM_PERCENTAGE(internal::kHistogramCacheRequestPercentParseStop,
                                percent_cached);
       UMA_HISTOGRAM_COUNTS(internal::kHistogramCacheTotalRequestsParseStop,
                            num_cache_resources_);
       UMA_HISTOGRAM_COUNTS(internal::kHistogramTotalRequestsParseStop,
                            num_cache_resources_ + num_network_resources_);
 
       // Separate out parse duration based on cache percent.
       if (percent_cached <= 50) {
         PAGE_LOAD_HISTOGRAM(
             "PageLoad.Experimental.ParseDuration.CachedPercent.0-50",
             parse_duration);
       } else {
         PAGE_LOAD_HISTOGRAM(
             "PageLoad.Experimental.ParseDuration.CachedPercent.51-100",
             parse_duration);
       }
     }
   } else {
     PAGE_LOAD_HISTOGRAM(internal::kBackgroundHistogramParseDuration,
                         parse_duration);
     PAGE_LOAD_HISTOGRAM(
         internal::kBackgroundHistogramParseBlockedOnScriptLoad,
-        timing.parse_timing.parse_blocked_on_script_load_duration.value());
+        timing.parse_timing->parse_blocked_on_script_load_duration.value());
     PAGE_LOAD_HISTOGRAM(
         internal::kBackgroundHistogramParseBlockedOnScriptLoadDocumentWrite,
         timing.parse_timing
-            .parse_blocked_on_script_load_from_document_write_duration.value());
+            ->parse_blocked_on_script_load_from_document_write_duration
+            .value());
   }
 }
 
 void CorePageLoadMetricsObserver::OnComplete(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   RecordTimingHistograms(timing, info);
   RecordByteAndResourceHistograms(timing, info);
   RecordRappor(timing, info);
   RecordForegroundDurationHistograms(timing, info, base::TimeTicks());
 }
 
 page_load_metrics::PageLoadMetricsObserver::ObservePolicy
 CorePageLoadMetricsObserver::FlushMetricsOnAppEnterBackground(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   // FlushMetricsOnAppEnterBackground is invoked on Android in cases where the
   // app is about to be backgrounded, as part of the Activity.onPause()
   // flow. After this method is invoked, Chrome may be killed without further
   // notification, so we record final metrics collected up to this point.
   if (info.did_commit) {
     RecordTimingHistograms(timing, info);
     RecordByteAndResourceHistograms(timing, info);
   }
   RecordForegroundDurationHistograms(timing, info, base::TimeTicks::Now());
   return STOP_OBSERVING;
 }
 
 void CorePageLoadMetricsObserver::OnFailedProvisionalLoad(
     const page_load_metrics::FailedProvisionalLoadInfo& failed_load_info,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   // Only handle actual failures; provisional loads that failed due to another
   // committed load or due to user action are recorded in
   // AbortsPageLoadMetricsObserver.
   if (failed_load_info.error != net::OK &&
       failed_load_info.error != net::ERR_ABORTED) {
     if (WasStartedInForegroundOptionalEventInForeground(
             failed_load_info.time_to_failed_provisional_load, extra_info)) {
       PAGE_LOAD_HISTOGRAM(internal::kHistogramFailedProvisionalLoad,
                           failed_load_info.time_to_failed_provisional_load);
     }
   }
   // Provide an empty PageLoadTiming, since we don't have any timing metrics
   // for failed provisional loads.
-  RecordForegroundDurationHistograms(page_load_metrics::PageLoadTiming(),
+  RecordForegroundDurationHistograms(page_load_metrics::mojom::PageLoadTiming(),
                                      extra_info, base::TimeTicks());
 }
 
 void CorePageLoadMetricsObserver::OnUserInput(
     const blink::WebInputEvent& event) {
   base::TimeTicks now;
   if (!first_paint_.is_null() &&
       first_user_interaction_after_first_paint_.is_null() &&
       event.GetType() != blink::WebInputEvent::kMouseMove) {
     if (now.is_null())
@@ skipping 31 matching lines @@
   if (extra_request_complete_info.was_cached) {
     ++num_cache_resources_;
     cache_bytes_ += extra_request_complete_info.raw_body_bytes;
   } else {
     ++num_network_resources_;
     network_bytes_ += extra_request_complete_info.raw_body_bytes;
   }
 }
 
 void CorePageLoadMetricsObserver::RecordTimingHistograms(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   // Log time to first foreground / time to first background. Log counts that we
   // started a relevant page load in the foreground / background.
   if (!info.started_in_foreground && info.first_foreground_time) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramFirstForeground,
                         info.first_foreground_time.value());
   }
 
-  if (timing.paint_timing.first_paint &&
-      !timing.paint_timing.first_meaningful_paint) {
+  if (timing.paint_timing->first_paint &&
+      !timing.paint_timing->first_meaningful_paint) {
     RecordFirstMeaningfulPaintStatus(
-        timing.paint_timing.first_contentful_paint
+        timing.paint_timing->first_contentful_paint
             ? internal::FIRST_MEANINGFUL_PAINT_DID_NOT_REACH_NETWORK_STABLE
             : internal::
                   FIRST_MEANINGFUL_PAINT_DID_NOT_REACH_FIRST_CONTENTFUL_PAINT);
   }
 
-  if (timing.paint_timing.first_paint) {
+  if (timing.paint_timing->first_paint) {
     enum FirstMeaningfulPaintSignalStatus {
       HAD_USER_INPUT = 1 << 0,
       NETWORK_STABLE = 1 << 1,
       FIRST_MEANINGFUL_PAINT_SIGNAL_STATUS_LAST_ENTRY = 1 << 2
     };
     int signal_status =
         (first_user_interaction_after_first_paint_.is_null() ? 0
                                                              : HAD_USER_INPUT) +
-        (timing.paint_timing.first_meaningful_paint ? NETWORK_STABLE : 0);
+        (timing.paint_timing->first_meaningful_paint ? NETWORK_STABLE : 0);
     UMA_HISTOGRAM_ENUMERATION(
         internal::kHistogramFirstMeaningfulPaintSignalStatus2,
         signal_status, FIRST_MEANINGFUL_PAINT_SIGNAL_STATUS_LAST_ENTRY);
   }
-  if (timing.paint_timing.first_meaningful_paint) {
+  if (timing.paint_timing->first_meaningful_paint) {
     if (first_user_interaction_after_first_paint_.is_null()) {
       PAGE_LOAD_HISTOGRAM(internal::kHistogramFirstMeaningfulPaintNoUserInput,
-                          timing.paint_timing.first_meaningful_paint.value());
+                          timing.paint_timing->first_meaningful_paint.value());
     } else {
       PAGE_LOAD_HISTOGRAM(internal::kHistogramFirstMeaningfulPaintHadUserInput,
-                          timing.paint_timing.first_meaningful_paint.value());
+                          timing.paint_timing->first_meaningful_paint.value());
     }
   }
 }
 
 void CorePageLoadMetricsObserver::RecordForegroundDurationHistograms(
-    const page_load_metrics::PageLoadTiming& timing,
+    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::kHistogramPageTimingForegroundDuration,
                              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::kHistogramPageTimingForegroundDurationAfterPaint,
           foreground_duration.value() -
-              timing.paint_timing.first_paint.value());
+              timing.paint_timing->first_paint.value());
       PAGE_LOAD_LONG_HISTOGRAM(
           internal::kHistogramPageTimingForegroundDurationWithPaint,
           foreground_duration.value());
     } else {
       PAGE_LOAD_LONG_HISTOGRAM(
           internal::kHistogramPageTimingForegroundDurationWithoutPaint,
           foreground_duration.value());
     }
   } else {
     PAGE_LOAD_LONG_HISTOGRAM(
         internal::kHistogramPageTimingForegroundDurationNoCommit,
         foreground_duration.value());
   }
 }
 
 void CorePageLoadMetricsObserver::RecordByteAndResourceHistograms(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   DCHECK_GE(network_bytes_, 0);
   DCHECK_GE(cache_bytes_, 0);
   int64_t total_bytes = network_bytes_ + cache_bytes_;
 
   PAGE_BYTES_HISTOGRAM(internal::kHistogramNetworkBytes, network_bytes_);
   PAGE_BYTES_HISTOGRAM(internal::kHistogramCacheBytes, cache_bytes_);
   PAGE_BYTES_HISTOGRAM(internal::kHistogramTotalBytes, total_bytes);
 
   switch (GetPageLoadType(transition_)) {
@@ skipping 29 matching lines @@
 
   PAGE_RESOURCE_COUNT_HISTOGRAM(internal::kHistogramNetworkCompletedResources,
                                 num_network_resources_);
   PAGE_RESOURCE_COUNT_HISTOGRAM(internal::kHistogramCacheCompletedResources,
                                 num_cache_resources_);
   PAGE_RESOURCE_COUNT_HISTOGRAM(internal::kHistogramTotalCompletedResources,
                                 num_cache_resources_ + num_network_resources_);
 }
 
 void CorePageLoadMetricsObserver::RecordRappor(
-    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   // During the browser process shutdown path, calling
   // BrowserProcess::rappor_service() can reinitialize multiple destroyed
   // objects. This alters shutdown ordering, so we avoid it by testing
   // IsShuttingDown() first.
   if (g_browser_process->IsShuttingDown())
     return;
   rappor::RapporServiceImpl* rappor_service =
       g_browser_process->rappor_service();
   if (!rappor_service)
     return;
   if (!info.did_commit)
     return;
 
   // Log the eTLD+1 of sites that show poor loading performance.
   if (WasStartedInForegroundOptionalEventInForeground(
-          timing.paint_timing.first_contentful_paint, info)) {
+          timing.paint_timing->first_contentful_paint, info)) {
     std::unique_ptr<rappor::Sample> sample =
         rappor_service->CreateSample(rappor::UMA_RAPPOR_TYPE);
     sample->SetStringField(
         "Domain", rappor::GetDomainAndRegistrySampleFromGURL(info.url));
     uint64_t bucket_index = RapporHistogramBucketIndex(
-        timing.paint_timing.first_contentful_paint.value());
+        timing.paint_timing->first_contentful_paint.value());
     sample->SetFlagsField("Bucket", uint64_t(1) << bucket_index,
                           kNumRapporHistogramBuckets);
     // The IsSlow flag is just a one bit boolean if the first contentful paint
     // was > 10s.
     sample->SetFlagsField(
         "IsSlow",
-        timing.paint_timing.first_contentful_paint.value().InSecondsF() >= 10,
+        timing.paint_timing->first_contentful_paint.value().InSecondsF() >= 10,
         1);
     rappor_service->RecordSample(internal::kRapporMetricsNameCoarseTiming,
                                  std::move(sample));
   }
 
   // Log the eTLD+1 of sites that did not report first meaningful paint.
-  if (timing.paint_timing.first_paint &&
-      !timing.paint_timing.first_meaningful_paint) {
+  if (timing.paint_timing->first_paint &&
+      !timing.paint_timing->first_meaningful_paint) {
     rappor::SampleDomainAndRegistryFromGURL(
         rappor_service,
         internal::kRapporMetricsNameFirstMeaningfulPaintNotRecorded, info.url);
   }
 }