Don't rely on the pending NavigationEntry for location.replace.

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 <utility>
 #include <vector>
@@ skipping 3724 matching lines @@
                                WebString::fromUTF8(kDefaultAcceptHeader));
   }
 
   // Add an empty HTTP origin header for non GET methods if none is currently
   // present.
   request.addHTTPOriginIfNeeded(WebString());
 
   // Attach |should_replace_current_entry| state to requests so that, should
   // this navigation later require a request transfer, all state is preserved
   // when it is re-created in the new process.
-  bool should_replace_current_entry = false;
-  if (navigation_state->IsContentInitiated()) {
-    should_replace_current_entry = data_source->replacesCurrentHistoryItem();
-  } else {
-    // If the navigation is browser-initiated, the NavigationState contains the
-    // correct value instead of the WebDataSource.
-    //
-    // TODO(davidben): Avoid this awkward duplication of state. See comment on
-    // NavigationState::should_replace_current_entry().
-    should_replace_current_entry =
-        navigation_state->common_params().should_replace_current_entry;
-  }
+  bool should_replace_current_entry = data_source->replacesCurrentHistoryItem();
 
   int provider_id = kInvalidServiceWorkerProviderId;
   if (request.getFrameType() == blink::WebURLRequest::FrameTypeTopLevel ||
       request.getFrameType() == blink::WebURLRequest::FrameTypeNested) {
     // |provisionalDataSource| may be null in some content::ResourceFetcher
     // use cases, we don't hook those requests.
     if (frame->provisionalDataSource()) {
       ServiceWorkerNetworkProvider* provider =
           ServiceWorkerNetworkProvider::FromDocumentState(
               DocumentState::FromDataSource(frame->provisionalDataSource()));
@@ skipping 618 matching lines @@
   InternalDocumentStateData* internal_data =
       InternalDocumentStateData::FromDocumentState(document_state);
 
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   params.http_status_code = response.httpStatusCode();
   params.url_is_unreachable = ds->hasUnreachableURL();
   params.is_post = false;
   params.intended_as_new_entry =
       navigation_state->request_params().intended_as_new_entry;
   params.did_create_new_entry = commit_type == blink::WebStandardCommit;
+  params.should_replace_current_entry = ds->replacesCurrentHistoryItem();
   params.post_id = -1;
   params.page_id = render_view_->page_id_;
   params.nav_entry_id = navigation_state->request_params().nav_entry_id;
   // We need to track the RenderViewHost routing_id because of downstream
   // dependencies (crbug.com/392171 DownloadRequestHandle, SaveFileManager,
   // ResourceDispatcherHostImpl, MediaStreamUIProxy,
   // SpeechRecognitionDispatcherHost and possibly others). They look up the view
   // based on the ID stored in the resource requests. Once those dependencies
   // are unwound or moved to RenderFrameHost (crbug.com/304341) we can move the
   // client to be based on the routing_id of the RenderFrameHost.
@@ skipping 805 matching lines @@
                               bool should_replace_current_entry,
                               bool is_history_navigation_in_new_child) {
   FrameHostMsg_OpenURL_Params params;
   params.url = url;
   params.referrer = referrer;
   params.disposition = RenderViewImpl::NavigationPolicyToDisposition(policy);
 
   if (IsBrowserInitiated(pending_navigation_params_.get())) {
     // This is necessary to preserve the should_replace_current_entry value on
     // cross-process redirects, in the event it was set by a previous process.
-    //
-    // TODO(davidben): Avoid this awkward duplication of state. See comment on
-    // NavigationState::should_replace_current_entry().
-    params.should_replace_current_entry =
-        pending_navigation_params_->common_params.should_replace_current_entry;
+    WebDataSource* ds = frame_->provisionalDataSource();
+    DCHECK(ds);
+    params.should_replace_current_entry = ds->replacesCurrentHistoryItem();
   } else {
     params.should_replace_current_entry =
         should_replace_current_entry && render_view_->history_list_length_;
   }
   params.user_gesture = WebUserGestureIndicator::isProcessingUserGesture();
   if (GetContentClient()->renderer()->AllowPopup())
     params.user_gesture = true;
 
   if (policy == blink::WebNavigationPolicyNewBackgroundTab ||
       policy == blink::WebNavigationPolicyNewForegroundTab ||
@@ skipping 56 matching lines @@
       new NavigationParams(common_params, start_params, request_params));
 
   // Unless the load is a WebFrameLoadType::Standard, this should remain
   // uninitialized. It will be updated when the load type is determined to be
   // Standard, or after the previous document's unload handler has been
   // triggered. This occurs in UpdateNavigationState.
   // TODO(csharrison) See if we can always use the browser timestamp.
   pending_navigation_params_->common_params.navigation_start =
       base::TimeTicks();
 
-  // Create parameters for a standard navigation.
-  blink::WebFrameLoadType load_type = blink::WebFrameLoadType::Standard;
+  // Create parameters for a standard navigation, indicating whether it should
+  // replace the current NavigationEntry.
+  blink::WebFrameLoadType load_type =
+      common_params.should_replace_current_entry
+          ? blink::WebFrameLoadType::ReplaceCurrentItem
+          : blink::WebFrameLoadType::Standard;
   blink::WebHistoryLoadType history_load_type =
       blink::WebHistoryDifferentDocumentLoad;
   bool should_load_request = false;
   WebHistoryItem item_for_history_navigation;
   WebURLRequest request =
       CreateURLRequestForNavigation(common_params, std::move(stream_params),
                                     frame_->isViewSourceModeEnabled());
 
   // Used to determine whether this frame is actually loading a request as part
   // of a history navigation.
@@ skipping 110 matching lines @@
 
     should_load_request = true;
   }
 
   if (should_load_request) {
     // Sanitize navigation start now that we know the load_type.
     pending_navigation_params_->common_params.navigation_start =
         SanitizeNavigationTiming(load_type, common_params.navigation_start,
                                  renderer_navigation_start);
 
-    // PlzNavigate: Check if the load should replace the current item.
-    // TODO(clamy): Remove this when
-    // https://codereview.chromium.org/1250163002/ lands and makes it default
-    // for the current architecture.
-    if (browser_side_navigation && common_params.should_replace_current_entry) {
-      DCHECK(load_type == blink::WebFrameLoadType::Standard);
-      load_type = blink::WebFrameLoadType::ReplaceCurrentItem;
-    }
-
     // PlzNavigate: check if the navigation being committed originated as a
     // client redirect.
     bool is_client_redirect =
         browser_side_navigation
             ? !!(common_params.transition & ui::PAGE_TRANSITION_CLIENT_REDIRECT)
             : false;
 
     // Perform a navigation to a data url if needed.
     // Note: the base URL might be invalid, so also check the data URL string.
     if (!common_params.base_url_for_data_url.is_empty() ||
@@ skipping 633 matching lines @@
                                     int match_count,
                                     int ordinal,
                                     const WebRect& selection_rect,
                                     bool final_status_update) {
   Send(new FrameHostMsg_Find_Reply(routing_id_, request_id, match_count,
                                    selection_rect, ordinal,
                                    final_status_update));
 }
 
 }  // namespace content