Add a histogram for delay between first paint and client side redirects.

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 28 matching lines @@
 const char kAbortChainSizeReload[] =
     "PageLoad.Internal.ProvisionalAbortChainSize.Reload";
 const char kAbortChainSizeForwardBack[] =
     "PageLoad.Internal.ProvisionalAbortChainSize.ForwardBack";
 const char kAbortChainSizeNewNavigation[] =
     "PageLoad.Internal.ProvisionalAbortChainSize.NewNavigation";
 const char kAbortChainSizeSameURL[] =
     "PageLoad.Internal.ProvisionalAbortChainSize.SameURL";
 const char kAbortChainSizeNoCommit[] =
     "PageLoad.Internal.ProvisionalAbortChainSize.NoCommit";
+const char kClientRedirectDelayAfterPaint[] =
+    "PageLoad.Internal.ClientRedirectDelayAfterPaint";
 
 }  // namespace internal
 
 namespace {
 
 // The url we see from the renderer side is not always the same as what
 // we see from the browser side (e.g. chrome://newtab). We want to be
 // sure here that we aren't logging UMA for internal pages.
 bool IsRelevantNavigation(content::NavigationHandle* navigation_handle,
                           const GURL& browser_url,
@@ skipping 319 matching lines @@
     observer->OnRedirect(navigation_handle);
   }
 }
 
 void PageLoadTracker::OnInputEvent(const blink::WebInputEvent& event) {
   for (const auto& observer : observers_) {
     observer->OnUserInput(event);
   }
 }
 
+void PageLoadTracker::NotifyClientRedirectTo(
+    const PageLoadTracker& destination) {
+  base::TimeDelta redirect_delay_after_paint;
+  if (!timing_.first_paint.is_zero()) {
+    base::TimeTicks first_paint_time = navigation_start() + timing_.first_paint;
+    if (destination.navigation_start() > first_paint_time)
+      redirect_delay_after_paint =
+          destination.navigation_start() - first_paint_time;
+  }
+  PAGE_LOAD_HISTOGRAM(internal::kClientRedirectDelayAfterPaint,
+                      redirect_delay_after_paint);
+}
+
 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.
@@ skipping 315 matching lines @@
       aborted_provisional_loads_.push_back(std::move(finished_nav));
     }
 
     return;
   }
 
   // Don't treat a same-page nav as a new page load.
   if (navigation_handle->IsSamePage())
     return;
 
+  if (!navigation_handle->HasUserGesture() &&
+      (navigation_handle->GetPageTransition() &
+       ui::PAGE_TRANSITION_CLIENT_REDIRECT) != 0 &&
+      committed_load_)
+    committed_load_->NotifyClientRedirectTo(*finished_nav);
+
   // Notify other loads that they may have been aborted by this committed load.
   // Note that by using the committed navigation start as the abort cause, we
   // lose data on provisional loads that were aborted by other provisional
   // loads. Those will either be listed as ABORT_OTHER or as being aborted by
   // this load.
   // is_certainly_browser_timestamp is set to false because NavigationStart()
   // could be set in either the renderer or browser process.
   NotifyAbortAllLoadsWithTimestamp(
       AbortTypeForPageTransition(navigation_handle->GetPageTransition()),
       navigation_handle->NavigationStart(), false);
@@ skipping 158 matching lines @@
 
   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