Plumb experiment flags through page_load_metrics and add a new observer

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 <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 315 matching lines @@
     observer->OnFailedProvisionalLoad(navigation_handle);
   }
 }
 
 void PageLoadTracker::Redirect(content::NavigationHandle* navigation_handle) {
   for (const auto& observer : observers_) {
     observer->OnRedirect(navigation_handle);
   }
 }
 
-bool PageLoadTracker::UpdateTiming(const PageLoadTiming& new_timing) {
+bool PageLoadTracker::UpdateTiming(const PageLoadTiming& new_timing,
+                                   const PageLoadMetadata& new_metadata) {
   // Throw away IPCs that are not relevant to the current navigation.
   // Two timing structures cannot refer to the same navigation if they indicate
   // that a navigation started at different times, so a new timing struct with a
   // different start time from an earlier struct is considered invalid.
   bool valid_timing_descendent =
       timing_.navigation_start.is_null() ||
       timing_.navigation_start == new_timing.navigation_start;
-  if (IsValidPageLoadTiming(new_timing) && valid_timing_descendent) {
+  // Ensure flags sent previously are still present in the new metadata fields.
+  bool valid_behavior_descendent =
+      (metadata_.behavior_flags & new_metadata.behavior_flags) ==
+      metadata_.behavior_flags;
+  if (IsValidPageLoadTiming(new_timing) && valid_timing_descendent &&
+      valid_behavior_descendent) {
     timing_ = new_timing;
+    metadata_ = new_metadata;
     return true;
   }
   return false;
 }
 
 bool PageLoadTracker::HasBackgrounded() {
   return !started_in_foreground_ || !background_time_.is_null();
 }
 
 void PageLoadTracker::set_renderer_tracked(bool renderer_tracked) {
@@ skipping 20 matching lines @@
   } else {
     DCHECK(abort_time_.is_null());
   }
 
   if (!commit_time_.is_null()) {
     DCHECK_GT(commit_time_, navigation_start_);
     time_to_commit = commit_time_ - navigation_start_;
   } else {
     DCHECK(commit_time_.is_null());
   }
-  return PageLoadExtraInfo(first_background_time, first_foreground_time,
-                           started_in_foreground_,
-                           commit_time_.is_null() ? GURL() : url_,
-                           time_to_commit, abort_type_, time_to_abort);
+  return PageLoadExtraInfo(
+      first_background_time, first_foreground_time, started_in_foreground_,
+      commit_time_.is_null() ? GURL() : url_, time_to_commit, abort_type_,
+      time_to_abort, metadata_);
 }
 
 void PageLoadTracker::NotifyAbort(UserAbortType abort_type,
                                   base::TimeTicks timestamp) {
   DCHECK_NE(abort_type, ABORT_NONE);
   // Use UpdateAbort to update an already notified PageLoadTracker.
   if (abort_type_ != ABORT_NONE)
     return;
 
   UpdateAbortInternal(abort_type, timestamp);
@@ skipping 281 matching lines @@
   base::TimeTicks timestamp = new_navigation->NavigationStart();
   if (last_aborted_load->IsLikelyProvisionalAbort(timestamp))
     last_aborted_load->UpdateAbort(ABORT_UNKNOWN_NAVIGATION, timestamp);
 
   aborted_provisional_loads_.clear();
   return last_aborted_load;
 }
 
 void MetricsWebContentsObserver::OnTimingUpdated(
     content::RenderFrameHost* render_frame_host,
-    const PageLoadTiming& timing) {
+    const PageLoadTiming& timing,
+    const PageLoadMetadata& metadata) {
   bool error = false;
   if (!committed_load_ || !committed_load_->renderer_tracked()) {
     RecordInternalError(ERR_IPC_WITH_NO_RELEVANT_LOAD);
     error = true;
   }
 
   // We may receive notifications from frames that have been navigated away
   // from. We simply ignore them.
   if (render_frame_host != web_contents()->GetMainFrame()) {
     RecordInternalError(ERR_IPC_FROM_WRONG_FRAME);
     error = true;
   }
 
   // For urls like chrome://newtab, the renderer and browser disagree,
   // so we have to double check that the renderer isn't sending data from a
   // bad url like https://www.google.com/_/chrome/newtab.
   if (!web_contents()->GetLastCommittedURL().SchemeIsHTTPOrHTTPS()) {
     RecordInternalError(ERR_IPC_FROM_BAD_URL_SCHEME);
     error = true;
   }
 
   if (error)
     return;
 
-  if (!committed_load_->UpdateTiming(timing)) {
+  if (!committed_load_->UpdateTiming(timing, metadata)) {
     // 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