Add support for tracking loading behavior of child frames.

chrome/browser/page_load_metrics/page_load_tracker.cc

 // Copyright 2016 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/page_load_tracker.h"
 
 #include <algorithm>
 #include <ostream>
 #include <string>
 #include <utility>
@@ skipping 237 matching lines @@
 void RecordAppBackgroundPageLoadCompleted(bool completed_after_background) {
   UMA_HISTOGRAM_BOOLEAN(internal::kPageLoadCompletedAfterAppBackground,
                         completed_after_background);
 }
 
 void DispatchObserverTimingCallbacks(PageLoadMetricsObserver* observer,
                                      const PageLoadTiming& last_timing,
                                      const PageLoadTiming& new_timing,
                                      const PageLoadMetadata& last_metadata,
                                      const PageLoadExtraInfo& extra_info) {
-  if (extra_info.metadata.behavior_flags != last_metadata.behavior_flags)
+  if (extra_info.main_frame_metadata.behavior_flags !=
+      last_metadata.behavior_flags)
     observer->OnLoadingBehaviorObserved(extra_info);
   if (last_timing != new_timing)
     observer->OnTimingUpdate(new_timing, extra_info);
   if (new_timing.dom_content_loaded_event_start &&
       !last_timing.dom_content_loaded_event_start)
     observer->OnDomContentLoadedEventStart(new_timing, extra_info);
   if (new_timing.load_event_start && !last_timing.load_event_start)
     observer->OnLoadEventStart(new_timing, extra_info);
   if (new_timing.first_layout && !last_timing.first_layout)
     observer->OnFirstLayout(new_timing, extra_info);
@@ skipping 230 matching lines @@
     if (destination.navigation_start() > first_paint_time)
       first_paint_to_navigation =
           destination.navigation_start() - first_paint_time;
     PAGE_LOAD_HISTOGRAM(internal::kClientRedirectFirstPaintToNavigation,
                         first_paint_to_navigation);
   } else {
     UMA_HISTOGRAM_BOOLEAN(internal::kClientRedirectWithoutPaint, true);
   }
 }
 
+void PageLoadTracker::UpdateChildFrameMetadata(
+    const PageLoadMetadata& child_metadata) {
+  // Merge the child loading behavior flags with any we've already observed,
+  // possibly from other child frames.
+  const int last_child_loading_behavior_flags =
+      child_frame_metadata_.behavior_flags;
+  child_frame_metadata_.behavior_flags |= child_metadata.behavior_flags;
+  if (last_child_loading_behavior_flags == child_frame_metadata_.behavior_flags)
+    return;
+
+  PageLoadExtraInfo extra_info(ComputePageLoadExtraInfo());
+  for (const auto& observer : observers_) {
+    observer->OnLoadingBehaviorObserved(extra_info);
+  }
+}
+
 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;
   // 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;
+      (main_frame_metadata_.behavior_flags & new_metadata.behavior_flags) ==
+      main_frame_metadata_.behavior_flags;
   if (IsValidPageLoadTiming(new_timing) && valid_timing_descendent &&
       valid_behavior_descendent) {
     DCHECK(did_commit_);  // OnCommit() must be called first.
     // There are some subtle ordering constraints here. GetPageLoadMetricsInfo()
     // must be called before DispatchObserverTimingCallbacks, but its
-    // implementation depends on the state of metadata_, so we need to update
-    // metadata_ before calling GetPageLoadMetricsInfo. Thus, we make a copy of
-    // timing here, update timing_ and metadata_, and then proceed to dispatch
-    // the observer timing callbacks.
+    // implementation depends on the state of main_frame_metadata_, so we need
+    // to update main_frame_metadata_ before calling GetPageLoadMetricsInfo.
+    // Thus, we make a copy of timing here, update timing_ and
+    // main_frame_metadata_, and then proceed to dispatch the observer timing
+    // callbacks.
     const PageLoadTiming last_timing = timing_;
     timing_ = new_timing;
 
-    const PageLoadMetadata last_metadata = metadata_;
-    metadata_ = new_metadata;
+    const PageLoadMetadata last_metadata = main_frame_metadata_;
+    main_frame_metadata_ = new_metadata;
     const PageLoadExtraInfo info = ComputePageLoadExtraInfo();
     for (const auto& observer : observers_) {
       DispatchObserverTimingCallbacks(observer.get(), last_timing, new_timing,
                                       last_metadata, info);
     }
     return true;
   }
   return false;
 }
 
@@ skipping 62 matching lines @@
   } else {
     DCHECK(page_end_time_.is_null());
   }
 
   // page_end_reason_ == END_NONE implies page_end_user_initiated_info_ is not
   // user initiated.
   DCHECK(page_end_reason_ != END_NONE ||
          (!page_end_user_initiated_info_.browser_initiated &&
           !page_end_user_initiated_info_.user_gesture &&
           !page_end_user_initiated_info_.user_input_event));
-  return PageLoadExtraInfo(navigation_start_, first_background_time,
-                           first_foreground_time, started_in_foreground_,
-                           user_initiated_info_, url(), start_url_, did_commit_,
-                           page_end_reason_, page_end_user_initiated_info_,
-                           page_end_time, metadata_);
+  return PageLoadExtraInfo(
+      navigation_start_, first_background_time, first_foreground_time,
+      started_in_foreground_, user_initiated_info_, url(), start_url_,
+      did_commit_, page_end_reason_, page_end_user_initiated_info_,
+      page_end_time, main_frame_metadata_, child_frame_metadata_);
 }
 
 bool PageLoadTracker::HasMatchingNavigationRequestID(
     const content::GlobalRequestID& request_id) const {
   DCHECK(request_id != content::GlobalRequestID());
   return navigation_request_id_.has_value() &&
          navigation_request_id_.value() == request_id;
 }
 
 void PageLoadTracker::NotifyPageEnd(PageEndReason page_end_reason,
@@ skipping 75 matching lines @@
   // user initiated.
   if (page_end_reason != END_CLIENT_REDIRECT)
     page_end_user_initiated_info_ = user_initiated_info;
 
   if (is_certainly_browser_timestamp) {
     ClampBrowserTimestampIfInterProcessTimeTickSkew(&page_end_time_);
   }
 }
 
 }  // namespace page_load_metrics