Create NavigationHandle after beforeunload with PlzNavigate.

content/browser/frame_host/navigation_request.cc

 // Copyright 2014 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/browser/frame_host/navigation_request.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "content/browser/appcache/appcache_navigation_handle.h"
@@ skipping 239 matching lines @@
           controller->GetEntryCount()),
       browser_initiated,
       true,  // may_transfer
       &frame_entry, &entry));
   return navigation_request;
 }
 
 // static
 std::unique_ptr<NavigationRequest> NavigationRequest::CreateRendererInitiated(
     FrameTreeNode* frame_tree_node,
+    NavigationEntryImpl* entry,
     const CommonNavigationParams& common_params,
     const BeginNavigationParams& begin_params,
     int current_history_list_offset,
     int current_history_list_length) {
   // Only normal navigations to a different document or reloads are expected.
   // - Renderer-initiated fragment-navigations never take place in the browser,
   //   even with PlzNavigate.
   // - Restore-navigations are always browser-initiated.
   // - History-navigations use the browser-initiated path, event the ones that
   //   are initiated by a javascript script, please see the IPC message
@@ skipping 20 matching lines @@
       false,  // intended_as_new_entry
       -1,     // pending_history_list_offset
       current_history_list_offset, current_history_list_length,
       false,  // is_view_source
       false,  // should_clear_history_list
       begin_params.has_user_gesture);
   std::unique_ptr<NavigationRequest> navigation_request(new NavigationRequest(
       frame_tree_node, common_params, begin_params, request_params,
       false,  // browser_initiated
       false,  // may_transfer
-      nullptr, nullptr));
+      nullptr, entry));
   return navigation_request;
 }
 
 NavigationRequest::NavigationRequest(
     FrameTreeNode* frame_tree_node,
     const CommonNavigationParams& common_params,
     const BeginNavigationParams& begin_params,
     const RequestNavigationParams& request_params,
     bool browser_initiated,
     bool may_transfer,
@@ skipping 38 matching lines @@
         frame_tree_node->current_frame_host()->GetSiteInstance();
   }
 
   // Update the load flags with cache information.
   UpdateLoadFlagsWithCacheFlags(&begin_params_.load_flags,
                                 common_params_.navigation_type,
                                 common_params_.method == "POST");
 
   // Add necessary headers that may not be present in the BeginNavigationParams.
   std::string user_agent_override;
-  if (entry && entry->GetIsOverridingUserAgent()) {
-    user_agent_override =
-        frame_tree_node_->navigator()->GetDelegate()->GetUserAgentOverride();
+  if (entry) {
+    nav_entry_id_ = entry->GetUniqueID();
+    if (entry->GetIsOverridingUserAgent()) {
+      user_agent_override =
+          frame_tree_node_->navigator()->GetDelegate()->GetUserAgentOverride();
+    }
   }
 
   net::HttpRequestHeaders headers;
   headers.AddHeadersFromString(begin_params_.headers);
   AddAdditionalRequestHeaders(
       &headers, common_params_.url, common_params_.navigation_type,
       frame_tree_node_->navigator()->GetController()->GetBrowserContext(),
       common_params.method, user_agent_override, frame_tree_node);
   begin_params_.headers = headers.ToString();
 }
 
 NavigationRequest::~NavigationRequest() {
   TRACE_EVENT_ASYNC_END0("navigation", "NavigationRequest", this);
 }
 
 void NavigationRequest::BeginNavigation() {
   DCHECK(!loader_);
   DCHECK(state_ == NOT_STARTED || state_ == WAITING_FOR_RENDERER_RESPONSE);
   TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationRequest", this,
                                "BeginNavigation");
   state_ = STARTED;
+  CreateNavigationHandle();
+
+  if (nav_entry_id_) {
+    NavigationEntryImpl* nav_entry =
+        static_cast<NavigationControllerImpl*>(
+            frame_tree_node_->navigator()->GetController())
+            ->GetEntryWithUniqueID(nav_entry_id_);
+    if (nav_entry) {
+      navigation_handle_->set_base_url_for_data_url(
+          nav_entry->GetBaseURLForDataURL());
+    }
+  }
+
   RenderFrameDevToolsAgentHost::OnBeforeNavigation(navigation_handle_.get());
 
   if (ShouldMakeNetworkRequestForURL(common_params_.url) &&
       !navigation_handle_->IsSameDocument()) {
     // It's safe to use base::Unretained because this NavigationRequest owns
     // the NavigationHandle where the callback will be stored.
     // TODO(clamy): pass the method to the NavigationHandle instead of a
     // boolean.
     bool is_external_protocol =
         !GetContentClient()->browser()->IsHandledURL(common_params_.url);
@@ skipping 27 matching lines @@
   CommitNavigation();
 }
 
 void NavigationRequest::SetWaitingForRendererResponse() {
   TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationRequest", this,
                                "WaitingForRendererResponse");
   DCHECK(state_ == NOT_STARTED);
   state_ = WAITING_FOR_RENDERER_RESPONSE;
 }
 
-void NavigationRequest::CreateNavigationHandle(int pending_nav_entry_id) {
+void NavigationRequest::CreateNavigationHandle() {
   DCHECK_EQ(frame_tree_node_->navigation_request(), this);
   FrameTreeNode* frame_tree_node = frame_tree_node_;
 
   std::vector<GURL> redirect_chain;
   if (!begin_params_.client_side_redirect_url.is_empty())
     redirect_chain.push_back(begin_params_.client_side_redirect_url);
   redirect_chain.push_back(common_params_.url);
 
   std::unique_ptr<NavigationHandleImpl> navigation_handle =
       NavigationHandleImpl::Create(common_params_.url, redirect_chain,
                                    frame_tree_node_, !browser_initiated_,
                                    FrameMsg_Navigate_Type::IsSameDocument(
                                        common_params_.navigation_type),
                                    common_params_.navigation_start,
-                                   pending_nav_entry_id,
+                                   nav_entry_id_,
                                    false,  // started_in_context_menu
                                    common_params_.should_check_main_world_csp,
                                    begin_params_.is_form_submission);
 
   if (!frame_tree_node->navigation_request()) {
     // A callback could have cancelled this request synchronously in which case
     // |this| is deleted.
     return;
   }
 
@@ skipping 170 matching lines @@
   TRACE_EVENT_ASYNC_STEP_INTO1("navigation", "NavigationRequest", this,
                                "OnRequestFailed", "error", net_error);
   state_ = FAILED;
   navigation_handle_->set_net_error_code(static_cast<net::Error>(net_error));
 
   // With PlzNavigate, debug URLs will give a failed navigation because the
   // WebUI backend won't find a handler for them. They will be processed in the
   // renderer, however do not discard the pending entry so that the URL bar
   // shows them correctly.
   if (!IsRendererDebugURL(common_params_.url)) {
+    int expected_pending_entry_id =
+        navigation_handle_.get() ? navigation_handle_->pending_nav_entry_id()
+                                 : nav_entry_id_;
     frame_tree_node_->navigator()->DiscardPendingEntryIfNeeded(
-        navigation_handle_.get());
+        expected_pending_entry_id);
   }
 
   // If the request was canceled by the user do not show an error page.
   if (net_error == net::ERR_ABORTED) {
     frame_tree_node_->ResetNavigationRequest(false, true);
     return;
   }
 
   // Decide whether to leave the error page in the original process.
   // * If this was a renderer-initiated navigation, and the request is blocked
@@ skipping 230 matching lines @@
   DCHECK_EQ(request_params_.has_user_gesture, begin_params_.has_user_gesture);
 
   render_frame_host->CommitNavigation(response_.get(), std::move(body_),
                                       std::move(handle_), common_params_,
                                       request_params_, is_view_source_);
 
   frame_tree_node_->ResetNavigationRequest(true, true);
 }
 
 }  // namespace content