Report page load timing information for 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>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
+#include "chrome/browser/page_load_metrics/browser_page_track_decider.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_embedder_interface.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_util.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/common/page_load_metrics/page_load_timing.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_handle.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "ui/base/page_transition_types.h"
 
 // This macro invokes the specified method on each observer, passing the
 // variable length arguments as the method's arguments, and removes the observer
 // from the list of observers if the given method returns STOP_OBSERVING.
 #define INVOKE_AND_PRUNE_OBSERVERS(observers, Method, ...)    \
   for (auto it = observers.begin(); it != observers.end();) { \
@@ skipping 473 matching lines @@
       navigation_handle->GetWebContents()->GetContentsMimeType());
 
   INVOKE_AND_PRUNE_OBSERVERS(observers_, OnCommit, navigation_handle);
   LogAbortChainHistograms(navigation_handle);
 }
 
 void PageLoadTracker::DidFinishSubFrameNavigation(
     content::NavigationHandle* navigation_handle) {
   INVOKE_AND_PRUNE_OBSERVERS(observers_, OnDidFinishSubFrameNavigation,
                              navigation_handle);
+
+  if (!navigation_handle->HasCommitted())
+    return;
+
+  // We have a new committed navigation, so discard information about the
+  // previously committed navigation.
+  child_frame_navigation_start_offset_.erase(
+      navigation_handle->GetFrameTreeNodeId());
+
+  BrowserPageTrackDecider decider(embedder_interface_,
+                                  navigation_handle->GetWebContents(),
+                                  navigation_handle);
+  if (decider.ShouldTrack()) {
+    DCHECK_GE(navigation_handle->NavigationStart(), navigation_start_);
+    base::TimeDelta navigation_delta =
+        navigation_handle->NavigationStart() - navigation_start_;
+    child_frame_navigation_start_offset_.insert(std::make_pair(
+        navigation_handle->GetFrameTreeNodeId(), navigation_delta));
+  }
 }
 
 void PageLoadTracker::FailedProvisionalLoad(
     content::NavigationHandle* navigation_handle,
     base::TimeTicks failed_load_time) {
   DCHECK(!failed_provisional_load_info_);
   failed_provisional_load_info_.reset(new FailedProvisionalLoadInfo(
       failed_load_time - navigation_handle->NavigationStart(),
       navigation_handle->GetNetErrorCode()));
 }
@@ skipping 30 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(
+void PageLoadTracker::UpdateSubFrameTiming(
+    content::RenderFrameHost* render_frame_host,
+    const PageLoadTiming& new_timing,
+    const PageLoadMetadata& new_metadata) {
+  UpdateSubFrameMetadata(new_metadata);
+  const auto it = child_frame_navigation_start_offset_.find(
+      render_frame_host->GetFrameTreeNodeId());
+  if (it == child_frame_navigation_start_offset_.end()) {
+    // We received timing information for an untracked load. Ignore it.
+    RecordInternalError(ERR_SUBFRAME_IPC_WITH_NO_RELEVANT_LOAD);
+    return;
+  }
+  const PageLoadExtraInfo info = ComputePageLoadExtraInfo();
+  for (const auto& observer : observers_) {
+    observer->OnSubFrameTimingUpdate(render_frame_host->GetFrameTreeNodeId(),
+                                     it->second, new_timing, new_metadata,
+                                     info);
+  }
+}
+
+void PageLoadTracker::UpdateSubFrameMetadata(
     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());
@@ skipping 237 matching lines @@
     observer->MediaStartedPlaying(video_type, is_in_main_frame);
 }
 
 void PageLoadTracker::OnNavigationDelayComplete(base::TimeDelta scheduled_delay,
                                                 base::TimeDelta actual_delay) {
   for (const auto& observer : observers_)
     observer->OnNavigationDelayComplete(scheduled_delay, actual_delay);
 }
 
 }  // namespace page_load_metrics