(DEPRECATED) Send navigation_start to browser process in DidStartProvisionalLoad

content/renderer/render_frame_impl.cc

 // Copyright 2013 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 "content/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 438 matching lines @@
   // passed back to the browser in the DidCommitProvisionalLoad and the
   // DocumentLoadComplete IPCs.
   base::TimeDelta ui_timestamp = common_params.ui_timestamp - base::TimeTicks();
   request.setUiStartTime(ui_timestamp.InSecondsF());
   request.setInputPerfMetricReportPolicy(
       static_cast<WebURLRequest::InputToLoadPerfMetricReportPolicy>(
           common_params.report_type));
   return request;
 }
 
-void UpdateFrameNavigationTiming(WebFrame* frame,
-                                 base::TimeTicks browser_navigation_start,
-                                 base::TimeTicks renderer_navigation_start) {
+base::TimeTicks SanitizeNavigationTiming(
+    base::TimeTicks browser_navigation_start) {
   // The browser provides the navigation_start time to bootstrap the
   // Navigation Timing information for the browser-initiated navigations. In
   // case of cross-process navigations, this carries over the time of
   // finishing the onbeforeunload handler of the previous page.
+  // |browser_navigation_start| is likely before this process existed, so we
+  // can't use InterProcessTimeTicksConverter. We need at least to ensure
+  // that the browser-side navigation start we set is not later than the one
+  // on the renderer side.
+  base::TimeTicks renderer_navigation_start = base::TimeTicks::Now();
   DCHECK(!browser_navigation_start.is_null());
-  if (frame->provisionalDataSource()) {
-    // |browser_navigation_start| is likely before this process existed, so we
-    // can't use InterProcessTimeTicksConverter. We need at least to ensure
-    // that the browser-side navigation start we set is not later than the one
-    // on the renderer side.
-    base::TimeTicks navigation_start = std::min(
-        browser_navigation_start, renderer_navigation_start);
+  base::TimeTicks navigation_start =
+      std::min(browser_navigation_start, renderer_navigation_start);
+  // TODO(csharrison) UMA log:
+  // |renderer_navigation_start - browser_navigation_start|
+  return navigation_start;
+}
+
+// Update the navigation start based on a better value recieved from the
+// browser. This can be null if the timestamp should not be updated.
+void UpdateFrameNavigationTiming(WebFrame* frame,
+                                 base::TimeTicks updated_navigation_start) {
+  if (frame->provisionalDataSource() && !updated_navigation_start.is_null()) {
     double navigation_start_seconds =
-        (navigation_start - base::TimeTicks()).InSecondsF();
+        (updated_navigation_start - base::TimeTicks()).InSecondsF();
     frame->provisionalDataSource()->setNavigationStartTime(
         navigation_start_seconds);
     // TODO(clamy): We need to provide additional timing values for the
     // Navigation Timing API to work with browser-side navigations.
   }
 }
 
+
 // PlzNavigate
 CommonNavigationParams MakeCommonNavigationParams(
     blink::WebURLRequest* request,
-    bool should_replace_current_entry) {
+    bool should_replace_current_entry,
+    const base::TimeTicks& navigation_start) {
   const RequestExtraData kEmptyData;
   const RequestExtraData* extra_data =
       static_cast<RequestExtraData*>(request->extraData());
   if (!extra_data)
     extra_data = &kEmptyData;
   Referrer referrer(
       GURL(request->httpHeaderField(WebString::fromUTF8("Referer")).latin1()),
       request->referrerPolicy());
 
   // Set the ui timestamp for this navigation. Currently the timestamp here is
   // only non empty when the navigation was triggered by an Android intent, or
   // by the user clicking on a link. The timestamp is converted from a double
   // version supported by blink. It will be passed back to the renderer in the
   // CommitNavigation IPC, and then back to the browser again in the
   // DidCommitProvisionalLoad and the DocumentLoadComplete IPCs.
   base::TimeTicks ui_timestamp =
       base::TimeTicks() + base::TimeDelta::FromSecondsD(request->uiStartTime());
   FrameMsg_UILoadMetricsReportType::Value report_type =
       static_cast<FrameMsg_UILoadMetricsReportType::Value>(
           request->inputPerfMetricReportPolicy());
   return CommonNavigationParams(
       request->url(), referrer, extra_data->transition_type(),
       FrameMsg_Navigate_Type::NORMAL, true, should_replace_current_entry,
-      ui_timestamp, report_type, GURL(), GURL(), LOFI_UNSPECIFIED);
+      ui_timestamp, report_type, GURL(), GURL(), LOFI_UNSPECIFIED,
+      navigation_start);
 }
 
 #if !defined(OS_ANDROID) || defined(ENABLE_MEDIA_PIPELINE_ON_ANDROID)
 media::Context3D GetSharedMainThreadContext3D() {
   cc::ContextProvider* provider =
       RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
   if (!provider)
     return media::Context3D();
   return media::Context3D(provider->ContextGL(), provider->GrContext());
 }
@@ skipping 2171 matching lines @@
         WebUserGestureIndicator::isProcessingUserGesture() ?
             NavigationGestureUser : NavigationGestureAuto);
   } else if (ds->replacesCurrentHistoryItem()) {
     // Subframe navigations that don't add session history items must be
     // marked with AUTO_SUBFRAME. See also didFailProvisionalLoad for how we
     // handle loading of error pages.
     static_cast<NavigationStateImpl*>(document_state->navigation_state())
         ->set_transition_type(ui::PAGE_TRANSITION_AUTO_SUBFRAME);
   }
 
+  // Get the renderer navigation start in TimeTicks format. This will be
+  // lossy because blink converts TimeTicks internal int64 representation to a
+  // double.
+  DCHECK(ds->getNavigationStartTime());
+  base::TimeTicks navigation_start = base::TimeTicks::FromInternalValue(
+      ds->getNavigationStartTime() * base::Time::kMicrosecondsPerSecond);
+  // See if we have a better timestamp from a browser initiated navigation.
+  // If so, override it. This will be propogated to blink after the request has
+  // been issued.
+  if (ds->request().extraData()) {
+    RequestExtraData* extra_data =
+        static_cast<RequestExtraData*>(ds->request().extraData());
+    if (!extra_data->browser_navigation_start().is_null())
+      navigation_start = extra_data->browser_navigation_start();
+  }
+
   FOR_EACH_OBSERVER(RenderViewObserver, render_view_->observers(),
                     DidStartProvisionalLoad(frame));
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, DidStartProvisionalLoad());
 
   Send(new FrameHostMsg_DidStartProvisionalLoadForFrame(
-       routing_id_, ds->request().url()));
+      routing_id_, ds->request().url(), navigation_start));
 }
 
 void RenderFrameImpl::didReceiveServerRedirectForProvisionalLoad(
     blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   render_view_->history_controller()->RemoveChildrenForRedirect(this);
 }
 
 void RenderFrameImpl::didFailProvisionalLoad(
     blink::WebLocalFrame* frame,
@@ skipping 627 matching lines @@
 
   // The request's extra data may indicate that we should set a custom user
   // agent. This needs to be done here, after WebKit is through with setting the
   // user agent on its own. Similarly, it may indicate that we should set an
   // X-Requested-With header. This must be done here to avoid breaking CORS
   // checks.
   // PlzNavigate: there may also be a stream url associated with the request.
   WebString custom_user_agent;
   WebString requested_with;
   scoped_ptr<StreamOverrideParameters> stream_override;
+  base::TimeTicks navigation_start;
   if (request.extraData()) {
     RequestExtraData* old_extra_data =
         static_cast<RequestExtraData*>(request.extraData());
 
+    navigation_start = old_extra_data->browser_navigation_start();
     custom_user_agent = old_extra_data->custom_user_agent();
     if (!custom_user_agent.isNull()) {
       if (custom_user_agent.isEmpty())
         request.clearHTTPHeaderField("User-Agent");
       else
         request.setHTTPHeaderField("User-Agent", custom_user_agent);
     }
 
     requested_with = old_extra_data->requested_with();
     if (!requested_with.isNull()) {
@@ skipping 74 matching lines @@
   extra_data->set_allow_download(
       navigation_state->common_params().allow_download);
   extra_data->set_transition_type(transition_type);
   extra_data->set_should_replace_current_entry(should_replace_current_entry);
   extra_data->set_transferred_request_child_id(
       navigation_state->start_params().transferred_request_child_id);
   extra_data->set_transferred_request_request_id(
       navigation_state->start_params().transferred_request_request_id);
   extra_data->set_service_worker_provider_id(provider_id);
   extra_data->set_stream_override(stream_override.Pass());
+  extra_data->set_browser_navigation_start(navigation_start);
   if (request.loFiState() != WebURLRequest::LoFiUnspecified)
     extra_data->set_lofi_state(static_cast<LoFiState>(request.loFiState()));
   else if (is_main_frame_ && !navigation_state->request_committed())
     extra_data->set_lofi_state(navigation_state->common_params().lofi_state);
   else
     extra_data->set_lofi_state(is_using_lofi_ ? LOFI_ON : LOFI_OFF);
   request.setExtraData(extra_data);
 
   // TODO(creis): Update prefetching to work with out-of-process iframes.
   WebFrame* top_frame = frame->top();
@@ skipping 834 matching lines @@
   WebURLRequest::CachePolicy cache_policy =
       WebURLRequest::UseProtocolCachePolicy;
   RenderFrameImpl::PrepareRenderViewForNavigation(
       common_params.url, request_params, &is_reload, &cache_policy);
 
   GetContentClient()->SetActiveURL(common_params.url);
 
   pending_navigation_params_.reset(new NavigationParams(
       common_params, StartNavigationParams(), request_params));
 
-  // Inform the browser of the start of the provisional load. This is needed so
-  // that the load is properly tracked by the WebNavigation API.
   Send(new FrameHostMsg_DidStartProvisionalLoadForFrame(
-      routing_id_, common_params.url));
+      routing_id_, common_params.url, common_params.navigation_start));
 
   // Send the provisional load failure.
   blink::WebURLError error =
       CreateWebURLError(common_params.url, has_stale_copy_in_cache, error_code);
   WebURLRequest failed_request = CreateURLRequestForNavigation(
       common_params, scoped_ptr<StreamOverrideParameters>(),
       frame_->isViewSourceModeEnabled());
   SendFailedProvisionalLoad(failed_request, error, frame_);
 
   if (!ShouldDisplayErrorPageForFailedLoad(error_code, common_params.url)) {
@@ skipping 321 matching lines @@
   }
 
   pending_navigation_params_.reset(
       new NavigationParams(common_params, start_params, request_params));
 
   // Create parameters for a standard navigation.
   blink::WebFrameLoadType load_type = blink::WebFrameLoadType::Standard;
   bool should_load_request = false;
   WebHistoryItem item_for_history_navigation;
   WebURLRequest request = CreateURLRequestForNavigation(
-      common_params, stream_params.Pass(), frame_->isViewSourceModeEnabled());
+      common_params, stream_params.Pass(),
+      frame_->isViewSourceModeEnabled());
 #if defined(OS_ANDROID)
   request.setHasUserGesture(start_params.has_user_gesture);
 #endif
 
   // PlzNavigate: Make sure that Blink's loader will not try to use browser side
   // navigation for this request (since it already went to the browser).
   if (browser_side_navigation)
     request.setCheckForBrowserSideNavigation(false);
 
   // If we are reloading, then use the history state of the current frame.
@@ skipping 104 matching lines @@
       request.setHTTPBody(http_body);
     }
 
     // A session history navigation should have been accompanied by state.
     CHECK_EQ(request_params.page_id, -1);
 
     should_load_request = true;
   }
 
   if (should_load_request) {
-    // Record this before starting the load. We need a lower bound of this
-    // time to sanitize the navigationStart override set below.
-    base::TimeTicks renderer_navigation_start = base::TimeTicks::Now();
+    base::TimeTicks updated_navigation_start;
+    if (load_type == blink::WebFrameLoadType::Standard) {
+      updated_navigation_start =
+          SanitizeNavigationTiming(common_params.navigation_start);
+      static_cast<RequestExtraData*>(request.extraData())
+          ->set_browser_navigation_start(updated_navigation_start);
+    }
 
     // Perform a navigation to a data url if needed.
     if (!common_params.base_url_for_data_url.is_empty() ||
         (browser_side_navigation &&
          common_params.url.SchemeIs(url::kDataScheme))) {
       LoadDataURL(common_params, frame_);
     } else {
       // Load the request.
       frame_->toWebLocalFrame()->load(request, load_type,
                                       item_for_history_navigation);
     }
-
-    if (load_type == blink::WebFrameLoadType::Standard) {
-      UpdateFrameNavigationTiming(frame_,
-                                  request_params.browser_navigation_start,
-                                  renderer_navigation_start);
-    }
+    // Update the navigationStart value after the request has been made.
+    UpdateFrameNavigationTiming(frame_, updated_navigation_start);
   }
 
   // In case LoadRequest failed before didCreateDataSource was called.
   pending_navigation_params_.reset();
 }
 
 void RenderFrameImpl::UpdateEncoding(WebFrame* frame,
                                      const std::string& encoding_name) {
   // Only update main frame's encoding_name.
   if (!frame->parent())
@@ skipping 170 matching lines @@
   // Note: At this stage, the goal is to apply all the modifications the
   // renderer wants to make to the request, and then send it to the browser, so
   // that the actual network request can be started. Ideally, all such
   // modifications should take place in willSendRequest, and in the
   // implementation of willSendRequest for the various InspectorAgents
   // (devtools).
   //
   // TODO(clamy): Apply devtools override.
   // TODO(clamy): Make sure that navigation requests are not modified somewhere
   // else in blink.
+
+  base::TimeTicks navigation_start = base::TimeTicks::Now();
+
   willSendRequest(frame_, 0, *request, blink::WebURLResponse());
 
   // TODO(clamy): Same-document navigations should not be sent back to the
   // browser.
   // TODO(clamy): Data urls should not be sent back to the browser either.
   bool should_replace_current_entry = false;
   WebDataSource* provisional_data_source = frame_->provisionalDataSource();
   WebDataSource* current_data_source = frame_->dataSource();
   WebDataSource* data_source =
       provisional_data_source ? provisional_data_source : current_data_source;
@@ skipping 13 matching lines @@
   DCHECK(GetFetchRedirectModeForWebURLRequest(*request) ==
          FetchRedirectMode::MANUAL_MODE);
   DCHECK(frame_->parent() ||
          GetRequestContextFrameTypeForWebURLRequest(*request) ==
              REQUEST_CONTEXT_FRAME_TYPE_TOP_LEVEL);
   DCHECK(!frame_->parent() ||
          GetRequestContextFrameTypeForWebURLRequest(*request) ==
              REQUEST_CONTEXT_FRAME_TYPE_NESTED);
 
   Send(new FrameHostMsg_BeginNavigation(
-      routing_id_,
-      MakeCommonNavigationParams(request, should_replace_current_entry),
+      routing_id_, MakeCommonNavigationParams(
+                       request, should_replace_current_entry, navigation_start),
       BeginNavigationParams(
           request->httpMethod().latin1(), GetWebURLRequestHeaders(*request),
           GetLoadFlagsForWebURLRequest(*request), request->hasUserGesture(),
           request->skipServiceWorker(),
           GetRequestContextTypeForWebURLRequest(*request)),
       GetRequestBodyForWebURLRequest(*request)));
 }
 
 void RenderFrameImpl::LoadDataURL(const CommonNavigationParams& params,
                                   WebFrame* frame) {
@@ skipping 252 matching lines @@
   mojo::ServiceProviderPtr service_provider;
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From(url);
   mojo_shell_->ConnectToApplication(request.Pass(), GetProxy(&service_provider),
                                     nullptr, nullptr,
                                     base::Bind(&OnGotContentHandlerID));
   return service_provider.Pass();
 }
 
 }  // namespace content