PlzNavigate: support for should_replace_current_entry

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 441 matching lines @@
     double navigation_start_seconds =
         (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) {
+CommonNavigationParams MakeCommonNavigationParams(blink::WebURLRequest* request,
+                                                  bool lock_history_list) {
   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,
-                                ui_timestamp, report_type, GURL(), GURL());
+  return CommonNavigationParams(
+      request->url(), referrer, extra_data->transition_type(),
+      FrameMsg_Navigate_Type::NORMAL, true, ui_timestamp, report_type, GURL(),
+      GURL(), lock_history_list);
 }
 
 #if !defined(OS_ANDROID)
 media::Context3D GetSharedMainThreadContext3D() {
   cc::ContextProvider* provider =
       RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
   if (!provider)
     return media::Context3D();
   return media::Context3D(provider->ContextGL(), provider->GrContext());
 }
@@ skipping 3784 matching lines @@
   if (is_fork) {
     // Open the URL via the browser, not via WebKit.
     OpenURL(info.frame, url, Referrer(), info.defaultPolicy);
     return blink::WebNavigationPolicyIgnore;
   }
 
   // PlzNavigate: send the request to the browser if needed.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableBrowserSideNavigation) &&
       info.urlRequest.checkForBrowserSideNavigation()) {
-    BeginNavigation(&info.urlRequest);
+    BeginNavigation(&info.urlRequest, info.isBackForwardListLocked);
     return blink::WebNavigationPolicyIgnore;
   }
 
   return info.defaultPolicy;
 }
 
 void RenderFrameImpl::OpenURL(WebFrame* frame,
                               const GURL& url,
                               const Referrer& referrer,
                               WebNavigationPolicy policy) {
@@ skipping 75 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());
+  bool is_client_redirect =
+      browser_side_navigation
+          ? common_params.transition & ui::PAGE_TRANSITION_CLIENT_REDIRECT
+          : false;
 
   // 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.
   // Otherwise, if we have history state, then we need to navigate to it, which
   // corresponds to a back/forward navigation event. Update the parameters
   // depending on the navigation type.
@@ skipping 82 matching lines @@
     if (!common_params.base_url_for_data_url.is_empty() ||
         (browser_side_navigation &&
          common_params.url.SchemeIs(url::kDataScheme))) {
       LoadDataURL(common_params, frame_);
     } else {
       // 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();
 
       // Load the request.
-      frame_->toWebLocalFrame()->load(request, load_type,
-                                      item_for_history_navigation);
+      frame_->toWebLocalFrame()->load(
+          request, load_type, item_for_history_navigation,
+          blink::WebHistoryDifferentDocumentLoad, is_client_redirect,
+          common_params.lock_history_list);
 
       if (load_type == blink::WebFrameLoadType::Standard) {
         UpdateFrameNavigationTiming(frame_,
                                     request_params.browser_navigation_start,
                                     renderer_navigation_start);
       }
     }
   }
 
   // In case LoadRequest failed before didCreateDataSource was called.
@@ skipping 166 matching lines @@
   // We refresh timezone when a view is swapped in since timezone
   // can get out of sync when the system timezone is updated while
   // the view is swapped out.
   RenderThreadImpl::NotifyTimezoneChange();
 
   render_view_->SetSwappedOut(false);
   is_swapped_out_ = false;
   return true;
 }
 
-void RenderFrameImpl::BeginNavigation(blink::WebURLRequest* request) {
+void RenderFrameImpl::BeginNavigation(blink::WebURLRequest* request,
+                                      bool lock_history_list) {
   CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation));
   DCHECK(request);
   // TODO(clamy): Execute the beforeunload event.
 
   // 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.
   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.
   Send(new FrameHostMsg_DidStartLoading(routing_id_, true));
   Send(new FrameHostMsg_BeginNavigation(
-        routing_id_, MakeCommonNavigationParams(request),
-        BeginNavigationParams(request->httpMethod().latin1(),
-                              GetWebURLRequestHeaders(*request),
-                              GetLoadFlagsForWebURLRequest(*request),
-                              request->hasUserGesture()),
-        GetRequestBodyForWebURLRequest(*request)));
+      routing_id_, MakeCommonNavigationParams(request, lock_history_list),
+      BeginNavigationParams(
+          request->httpMethod().latin1(), GetWebURLRequestHeaders(*request),
+          GetLoadFlagsForWebURLRequest(*request), request->hasUserGesture()),
+      GetRequestBodyForWebURLRequest(*request)));
 }
 
 void RenderFrameImpl::LoadDataURL(const CommonNavigationParams& params,
                                   WebFrame* frame) {
   // A loadData request with a specified base URL.
   std::string mime_type, charset, data;
   if (net::DataURL::Parse(params.url, &mime_type, &charset, &data)) {
     const GURL base_url = params.base_url_for_data_url.is_empty() ?
         params.url : params.base_url_for_data_url;
     frame->loadData(
@@ skipping 207 matching lines @@
 #elif defined(ENABLE_BROWSER_CDMS)
         cdm_manager_,
 #endif
         this);
   }
 
   return cdm_factory_;
 }
 
 }  // namespace content