[page_load_metrics] Get navigation_start from NavigationHandle

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 "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "components/page_load_metrics/browser/page_load_metrics_macros.h"
@@ skipping 58 matching lines @@
   if (!timing.load_event_start.is_zero() &&
       (timing.dom_content_loaded_event_start.is_zero() ||
        timing.response_start > timing.load_event_start ||
        timing.dom_content_loaded_event_start > timing.load_event_start)) {
     return false;
   }
 
   return true;
 }
 
-base::Time WallTimeFromTimeTicks(const base::TimeTicks& time) {
-  return base::Time::FromDoubleT(
-      (time - base::TimeTicks::UnixEpoch()).InSecondsF());
-}
-
 void RecordInternalError(InternalErrorLoadEvent event) {
   UMA_HISTOGRAM_ENUMERATION(kErrorEvents, event, ERR_LAST_ENTRY);
 }
 
 base::TimeDelta GetFirstContentfulPaint(const PageLoadTiming& timing) {
   if (timing.first_text_paint.is_zero())
     return timing.first_image_paint;
   if (timing.first_image_paint.is_zero())
     return timing.first_text_paint;
   return std::min(timing.first_text_paint, timing.first_image_paint);
@@ skipping 20 matching lines @@
   if (seconds < 32)
     return 4;
   return 5;
 }
 
 }  // namespace
 
 PageLoadTracker::PageLoadTracker(
     bool in_foreground,
     PageLoadMetricsEmbedderInterface* embedder_interface,
+    content::NavigationHandle* navigation_handle,
     base::ObserverList<PageLoadMetricsObserver, true>* observers)
     : has_commit_(false),
+      navigation_start_(navigation_handle->NavigationStart()),
       started_in_foreground_(in_foreground),
       embedder_interface_(embedder_interface),
       observers_(observers) {}
 
 PageLoadTracker::~PageLoadTracker() {
   if (has_commit_) {
     RecordTimingHistograms();
     RecordRappor();
   }
 }
@@ skipping 38 matching lines @@
   return false;
 }
 
 bool PageLoadTracker::HasBackgrounded() {
   return !started_in_foreground_ || !background_time_.is_null();
 }
 
 PageLoadExtraInfo PageLoadTracker::GetPageLoadMetricsInfo() {
   base::TimeDelta first_background_time;
   base::TimeDelta first_foreground_time;
-  if (!background_time_.is_null() && started_in_foreground_) {
-    first_background_time =
-        WallTimeFromTimeTicks(background_time_) - timing_.navigation_start;
-  }
-  if (!foreground_time_.is_null() && !started_in_foreground_) {
-    first_foreground_time =
-        WallTimeFromTimeTicks(foreground_time_) - timing_.navigation_start;
-  }
+  if (!background_time_.is_null() && started_in_foreground_)
+    first_background_time = background_time_ - navigation_start_;
+  if (!foreground_time_.is_null() && !started_in_foreground_)
+    first_foreground_time = foreground_time_ - navigation_start_;
   return PageLoadExtraInfo(first_background_time, first_foreground_time,
                            started_in_foreground_);
 }
 
 const GURL& PageLoadTracker::GetCommittedURL() {
   DCHECK(has_commit_);
   return url_;
 }
 
 // Blink calculates navigation start using TimeTicks, but converts to epoch time
 // in its public API. Thus, to compare time values to navigation start, we
 // calculate the current time since the epoch using TimeTicks, and convert to
 // Time. This method is similar to how blink converts TimeTicks to epoch time.
 // There may be slight inaccuracies due to inter-process timestamps, but
 // this solution is the best we have right now.
 //
 // returns a TimeDelta which is
 //  - Infinity if we were never backgrounded
 //  - null (TimeDelta()) if we started backgrounded
 //  - elapsed time to first background if we started in the foreground and
 //    backgrounded.
 base::TimeDelta PageLoadTracker::GetBackgroundDelta() {
   if (started_in_foreground_) {
-    if (background_time_.is_null())
-      return base::TimeDelta::Max();
-    return WallTimeFromTimeTicks(background_time_) - timing_.navigation_start;
+    return background_time_.is_null() ? base::TimeDelta::Max()
+                                      : background_time_ - navigation_start_;
   }
   return base::TimeDelta();
 }
 
 void PageLoadTracker::RecordTimingHistograms() {
   DCHECK(has_commit_);
   if (timing_.IsEmpty()) {
     RecordInternalError(ERR_NO_IPCS_RECEIVED);
     return;
   }
@@ skipping 65 matching lines @@
       PAGE_LOAD_HISTOGRAM(kBackgroundHistogramFirstContentfulPaint,
                           first_contentful_paint);
     }
   }
 
   // Log time to first foreground / time to first background. Log counts that we
   // started a relevant page load in the foreground / background.
   if (!background_time_.is_null()) {
     PAGE_LOAD_HISTOGRAM(kHistogramFirstBackground, background_delta);
   } else if (!foreground_time_.is_null()) {
-    PAGE_LOAD_HISTOGRAM(
-        kHistogramFirstForeground,
-        WallTimeFromTimeTicks(foreground_time_) - timing_.navigation_start);
+    PAGE_LOAD_HISTOGRAM(kHistogramFirstForeground,
+                        foreground_time_ - navigation_start_);
   }
 }
 
 void PageLoadTracker::RecordProvisionalEvent(ProvisionalLoadEvent event) {
   if (HasBackgrounded()) {
     UMA_HISTOGRAM_ENUMERATION(kBackgroundProvisionalEvents, event,
                               PROVISIONAL_LOAD_LAST_ENTRY);
   } else {
     UMA_HISTOGRAM_ENUMERATION(kProvisionalEvents, event,
                               PROVISIONAL_LOAD_LAST_ENTRY);
@@ skipping 98 matching lines @@
     return;
   if (embedder_interface_->IsPrerendering(web_contents()))
     return;
   // We can have two provisional loads in some cases. E.g. a same-site
   // navigation can have a concurrent cross-process navigation started
   // from the omnibox.
   DCHECK_GT(2ul, provisional_loads_.size());
   // Passing raw pointers to observers_ and embedder_interface_ is safe because
   // the MetricsWebContentsObserver owns them both list and they are torn down
   // after the PageLoadTracker.
-  provisional_loads_.insert(
-      navigation_handle,
-      make_scoped_ptr(new PageLoadTracker(
-          in_foreground_, embedder_interface_.get(), &observers_)));
+  provisional_loads_.insert(navigation_handle,
+                            make_scoped_ptr(new PageLoadTracker(
+                                in_foreground_, embedder_interface_.get(),
+                                navigation_handle, &observers_)));
 }
 
 void MetricsWebContentsObserver::DidFinishNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame())
     return;
 
   scoped_ptr<PageLoadTracker> finished_nav(
       provisional_loads_.take_and_erase(navigation_handle));
   // There's a chance a navigation could have started before we were added to a
@@ skipping 88 matching lines @@
 
   if (!committed_load_->UpdateTiming(timing)) {
     // 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