PlzNavigate: support NavigationThrottle::WillProcessResponse

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 "content/browser/devtools/render_frame_devtools_agent_host.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/browser/frame_host/navigation_handle_impl.h"
 #include "content/browser/frame_host/navigation_request_info.h"
 #include "content/browser/frame_host/navigator.h"
+#include "content/browser/frame_host/navigator_impl.h"
 #include "content/browser/loader/navigation_url_loader.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_navigation_handle.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/common/resource_request_body.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/stream_handle.h"
 #include "content/public/common/content_client.h"
@@ skipping 191 matching lines @@
                                      common_params_.referrer),
         begin_params_.has_user_gesture, common_params_.transition, false,
         base::Bind(&NavigationRequest::OnStartChecksComplete,
                    base::Unretained(this)));
     return;
   }
 
   // There is no need to make a network request for this navigation, so commit
   // it immediately.
   state_ = RESPONSE_STARTED;
-  frame_tree_node_->navigator()->CommitNavigation(
-      this, nullptr, scoped_ptr<StreamHandle>());
+
+  // Select an appropriate RenderFrameHost.
+  RenderFrameHostImpl* render_frame_host =
+      frame_tree_node_->render_manager()->GetFrameHostForNavigation(*this);
+  NavigatorImpl::CheckWebUIRendererDoesNotDisplayNormalURL(render_frame_host,
+                                                           common_params_.url);
+
+  // Inform the NavigationHandle that the navigation will commit.
+  navigation_handle_->ReadyToCommitNavigation(render_frame_host);
+
+  CommitNavigation();
 }
 
 void NavigationRequest::CreateNavigationHandle(int pending_nav_entry_id) {
   // TODO(nasko): Update the NavigationHandle creation to ensure that the
   // proper values are specified for is_synchronous and is_srcdoc.
   navigation_handle_ = NavigationHandleImpl::Create(
       common_params_.url, frame_tree_node_,
       false,  // is_synchronous
       false,  // is_srcdoc
       common_params_.navigation_start, pending_nav_entry_id);
@@ skipping 23 matching lines @@
       base::Bind(&NavigationRequest::OnRedirectChecksComplete,
                  base::Unretained(this)));
 }
 
 void NavigationRequest::OnResponseStarted(
     const scoped_refptr<ResourceResponse>& response,
     scoped_ptr<StreamHandle> body) {
   DCHECK(state_ == STARTED);
   state_ = RESPONSE_STARTED;
 
+  // HTTP 204 (No Content) and HTTP 205 (Reset Content) responses should not
+  // commit; they leave the frame showing the previous page.
+  DCHECK(response);
+  if (response->head.headers.get() &&
+      (response->head.headers->response_code() == 204 ||
+       response->head.headers->response_code() == 205)) {
+    frame_tree_node_->ResetNavigationRequest(false);
+    return;
+  }
+
   // Update the service worker params of the request params.
   request_params_.should_create_service_worker =
       (frame_tree_node_->pending_sandbox_flags() &
        blink::WebSandboxFlags::Origin) != blink::WebSandboxFlags::Origin;
   if (navigation_handle_->service_worker_handle()) {
     request_params_.service_worker_provider_id =
         navigation_handle_->service_worker_handle()
             ->service_worker_provider_host_id();
   }
 
   // Update the lofi state of the request.
   if (response->head.is_using_lofi)
     common_params_.lofi_state = LOFI_ON;
   else
     common_params_.lofi_state = LOFI_OFF;
 
-  frame_tree_node_->navigator()->CommitNavigation(
-      this, response.get(), std::move(body));
+  // Select an appropriate renderer to commit the navigation.
+  RenderFrameHostImpl* render_frame_host =
+      frame_tree_node_->render_manager()->GetFrameHostForNavigation(*this);
+  NavigatorImpl::CheckWebUIRendererDoesNotDisplayNormalURL(render_frame_host,
+                                                           common_params_.url);
+
+  // Store the response and the StreamHandle until checks have been processed.
+  response_ = response;
+  body_ = std::move(body);
+
+  // Check if the navigation should be allowed to proceed.
+  navigation_handle_->WillProcessResponse(
+      render_frame_host, response->head.headers.get(),
+      base::Bind(&NavigationRequest::OnWillProcessResponseChecksComplete,
+                 base::Unretained(this)));
 }
 
 void NavigationRequest::OnRequestFailed(bool has_stale_copy_in_cache,
                                         int net_error) {
   DCHECK(state_ == STARTED);
   state_ = FAILED;
   navigation_handle_->set_net_error_code(static_cast<net::Error>(net_error));
   frame_tree_node_->navigator()->FailedNavigation(
       frame_tree_node_, has_stale_copy_in_cache, net_error);
 }
@@ skipping 35 matching lines @@
   if (result == NavigationThrottle::CANCEL_AND_IGNORE ||
       result == NavigationThrottle::CANCEL) {
     // TODO(clamy): distinguish between CANCEL and CANCEL_AND_IGNORE.
     frame_tree_node_->ResetNavigationRequest(false);
     return;
   }
 
   loader_->FollowRedirect();
 }
 
+void NavigationRequest::OnWillProcessResponseChecksComplete(
+    NavigationThrottle::ThrottleCheckResult result) {
+  CHECK(result != NavigationThrottle::DEFER);
+
+  // Abort the request if needed. This will destroy the NavigationRequest.
+  if (result == NavigationThrottle::CANCEL_AND_IGNORE ||
+      result == NavigationThrottle::CANCEL) {
+    // TODO(clamy): distinguish between CANCEL and CANCEL_AND_IGNORE.
+    frame_tree_node_->ResetNavigationRequest(false);
+    return;
+  }
+
+  // Have the processing of the response resume in the network stack.
+  loader_->ProceedWithResponse();
+
+  CommitNavigation();
+
+  // DO NOT ADD CODE after this. The previous call to CommitNavigation caused
+  // the destruction of the NavigationRequest.
+}
+
+void NavigationRequest::CommitNavigation() {
+  DCHECK(response_ || !ShouldMakeNetworkRequestForURL(common_params_.url));
+
+  // Retrieve the RenderFrameHost that needs to commit the navigation.
+  RenderFrameHostImpl* render_frame_host =
+      navigation_handle_->GetRenderFrameHost();
+  DCHECK(render_frame_host ==
+             frame_tree_node_->render_manager()->current_frame_host() ||
+         render_frame_host ==
+             frame_tree_node_->render_manager()->speculative_frame_host());
+
+  TransferNavigationHandleOwnership(render_frame_host);
+  render_frame_host->CommitNavigation(response_.get(), std::move(body_),
+                                      common_params_, request_params_,
+                                      is_view_source_);
+
+  // When navigating to a Javascript url, the NavigationRequest is not stored
+  // in the FrameTreeNode. Therefore do not reset it, as this could cancel an
+  // existing pending navigation.
+  if (!common_params_.url.SchemeIs(url::kJavaScriptScheme))
+    frame_tree_node_->ResetNavigationRequest(true);
+}
+
 void NavigationRequest::InitializeServiceWorkerHandleIfNeeded() {
   // Only initialize the ServiceWorkerNavigationHandle if it can be created for
   // this frame.
   bool can_create_service_worker =
       (frame_tree_node_->pending_sandbox_flags() &
        blink::WebSandboxFlags::Origin) != blink::WebSandboxFlags::Origin;
   if (!can_create_service_worker)
     return;
 
   // Use the SiteInstance of the navigating RenderFrameHost to get access to
@@ skipping 11 matching lines @@
       browser_context, navigating_frame_host->GetSiteInstance());
   DCHECK(partition);
 
   ServiceWorkerContextWrapper* service_worker_context =
       static_cast<ServiceWorkerContextWrapper*>(
           partition->GetServiceWorkerContext());
   navigation_handle_->InitServiceWorkerHandle(service_worker_context);
 }
 
 }  // namespace content