Various page_load_metrics cleanups and improvements

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/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
@@ skipping 22 matching lines @@
 const char kAbortChainSizeSameURL[] =
     "PageLoad.Internal.ProvisionalAbortChainSize.SameURL";
 const char kAbortChainSizeNoCommit[] =
     "PageLoad.Internal.ProvisionalAbortChainSize.NoCommit";
 const char kClientRedirectFirstPaintToNavigation[] =
     "PageLoad.Internal.ClientRedirect.FirstPaintToNavigation";
 const char kClientRedirectWithoutPaint[] =
     "PageLoad.Internal.ClientRedirect.NavigationWithoutPaint";
 const char kPageLoadCompletedAfterAppBackground[] =
     "PageLoad.Internal.PageLoadCompleted.AfterAppBackground";
+const char kPageLoadStartedInForeground[] =
+    "PageLoad.Internal.NavigationStartedInForeground";
+const char kPageLoadPrerender[] = "PageLoad.Internal.Prerender";
 
 }  // namespace internal
 
 void RecordInternalError(InternalErrorLoadEvent event) {
   UMA_HISTOGRAM_ENUMERATION(internal::kErrorEvents, event, ERR_LAST_ENTRY);
 }
 
 // TODO(csharrison): Add a case for client side redirects, which is what JS
 // initiated window.location / window.history navigations get set to.
 PageEndReason EndReasonForPageTransition(ui::PageTransition transition) {
@@ skipping 59 matching lines @@
 
   // If we have a non-empty timing, it should always have a navigation start.
   if (timing.navigation_start.is_null()) {
     NOTREACHED() << "Received null navigation_start.";
     return false;
   }
 
   // Verify proper ordering between the various timings.
 
   if (!EventsInOrder(timing.response_start, timing.parse_start)) {
-    // We sometimes get a zero response_start with a non-zero parse start. See
-    // crbug.com/590212.
-    DLOG(ERROR) << "Invalid response_start " << timing.response_start
-                << " for parse_start " << timing.parse_start;
+    NOTREACHED() << "Invalid response_start " << timing.response_start
+                 << " for parse_start " << timing.parse_start;
     return false;
   }
 
   if (!EventsInOrder(timing.parse_start, timing.parse_stop)) {
     NOTREACHED() << "Invalid parse_start " << timing.parse_start
                  << " for parse_stop " << timing.parse_stop;
     return false;
   }
 
   if (timing.parse_stop) {
@@ skipping 152 matching lines @@
       started_in_foreground_(in_foreground),
       page_transition_(navigation_handle->GetPageTransition()),
       user_initiated_info_(user_initiated_info),
       aborted_chain_size_(aborted_chain_size),
       aborted_chain_size_same_url_(aborted_chain_size_same_url),
       embedder_interface_(embedder_interface) {
   DCHECK(!navigation_handle->HasCommitted());
   embedder_interface_->RegisterObservers(this);
   INVOKE_AND_PRUNE_OBSERVERS(observers_, OnStart, navigation_handle,
                              currently_committed_url, started_in_foreground_);
+
+  UMA_HISTOGRAM_BOOLEAN(internal::kPageLoadStartedInForeground,
+                        started_in_foreground_);
+  const bool is_prerender = prerender::PrerenderContents::FromWebContents(
+                                navigation_handle->GetWebContents()) != nullptr;
+  if (is_prerender) {
+    UMA_HISTOGRAM_BOOLEAN(internal::kPageLoadPrerender, true);
+  }
 }
 
 PageLoadTracker::~PageLoadTracker() {
   if (app_entered_background_) {
     RecordAppBackgroundPageLoadCompleted(true);
   }
 
   if (did_stop_tracking_)
     return;
 
@@ skipping 196 matching lines @@
   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,
+void 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 =
+  const bool valid_timing_descendent =
       timing_.navigation_start.is_null() ||
       timing_.navigation_start == new_timing.navigation_start;
+  if (!valid_timing_descendent) {
+    RecordInternalError(ERR_BAD_TIMING_IPC_INVALID_TIMING_DESCENDENT);
+    return;
+  }
+
   // Ensure flags sent previously are still present in the new metadata fields.
-  bool valid_behavior_descendent =
+  const bool valid_behavior_descendent =
       (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 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;
+  if (!valid_behavior_descendent) {
+    RecordInternalError(ERR_BAD_TIMING_IPC_INVALID_BEHAVIOR_DESCENDENT);
+    return;
+  }
+  if (!IsValidPageLoadTiming(new_timing)) {
+    RecordInternalError(ERR_BAD_TIMING_IPC_INVALID_TIMING);
+    return;
+  }
 
-    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;
+  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 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 = 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 false;
 }
 
 void PageLoadTracker::OnLoadedResource(
     const ExtraRequestInfo& extra_request_info) {
   for (const auto& observer : observers_) {
     observer->OnLoadedResource(extra_request_info);
   }
 }
 
 void PageLoadTracker::StopTracking() {
@@ skipping 161 matching lines @@
 }
 
 void PageLoadTracker::MediaStartedPlaying(
     const content::WebContentsObserver::MediaPlayerInfo& video_type,
     bool is_in_main_frame) {
   for (const auto& observer : observers_)
     observer->MediaStartedPlaying(video_type, is_in_main_frame);
 }
 
 }  // namespace page_load_metrics