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/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);
+
+  // todo we don't want to erase if it's an aborted load (prev doc remains
+  // committed in that case)
+  child_frame_navigation_start_.erase(navigation_handle->GetFrameTreeNodeId());
+  if (navigation_handle->HasCommitted() &&

[jkarlin, 2017/05/05 19:19:25]

Note that error pages count as commits.

[Bryan McQuade, 2017/05/07 19:32:11]

good catch, thanks!. I decided that for tracking timing info we should use the
same policy as we have in the main frame.

+      !navigation_handle->IsSameDocument()) {
+    DCHECK_GE(navigation_handle->NavigationStart(), navigation_start_);
+    base::TimeDelta navigation_delta =
+        navigation_handle->NavigationStart() - navigation_start_;
+    child_frame_navigation_start_.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_.find(
+      render_frame_host->GetFrameTreeNodeId());
+  if (it == child_frame_navigation_start_.end()) {
+    // note that this can happen if a navigation starts but aborts and then the
+    // frame contents is updated via e.g. document.open/document.write from its
+    // parent. we probably want this to pass through to observers, but it's

[jkarlin, 2017/05/05 19:19:25]

This can also happen if a navigation aborts and falls back to the previous
navigation, which continues to do stuff.

[Bryan McQuade, 2017/05/07 19:32:10]

Yes - I fixed our tracking of loads in DidFinishSubFrameNavigation to continue
to support this case. Thanks!

+    // unclear what we should use for a nav start value (what is the nav start
+    // value in the render process? maybe we should be sending the nav start
+    // timeticks from the renderer?)
+    // todo log an error here to keep track of frequency of this case
+    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