Allow asynchronous deferral in NavigationSimulator

content/public/test/navigation_simulator.cc

 // Copyright 2017 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/public/test/navigation_simulator.h"
 
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+#include "base/run_loop.h"
 #include "content/browser/frame_host/navigation_handle_impl.h"
 #include "content/browser/frame_host/navigation_request.h"
 #include "content/common/frame_messages.h"
 #include "content/public/browser/navigation_throttle.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/test/test_navigation_url_loader.h"
 #include "content/test/test_render_frame_host.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/redirect_info.h"
@@ skipping 99 matching lines @@
     common_params.referrer = referrer_;
     common_params.transition = transition_;
     common_params.navigation_type =
         PageTransitionCoreTypeIs(transition_, ui::PAGE_TRANSITION_RELOAD)
             ? FrameMsg_Navigate_Type::RELOAD
             : FrameMsg_Navigate_Type::DIFFERENT_DOCUMENT;
     render_frame_host_->OnMessageReceived(FrameHostMsg_BeginNavigation(
         render_frame_host_->GetRoutingID(), common_params, begin_params));
     NavigationRequest* request =
         render_frame_host_->frame_tree_node()->navigation_request();
-    DCHECK(request);
+
+    // The request failed synchronously.
+    if (!request)
+      return;
     DCHECK_EQ(handle_, request->navigation_handle());
   } else {
     render_frame_host_->OnMessageReceived(
         FrameHostMsg_DidStartLoading(render_frame_host_->GetRoutingID(), true));
     render_frame_host_->OnMessageReceived(FrameHostMsg_DidStartProvisionalLoad(
         render_frame_host_->GetRoutingID(), navigation_url_,
         std::vector<GURL>(), base::TimeTicks::Now()));
     DCHECK_EQ(handle_, render_frame_host_->navigation_handle());
     handle_->WillStartRequest(
         "GET", scoped_refptr<content::ResourceRequestBodyImpl>(), referrer_,
         true /* user_gesture */, transition_, false /* is_external_protocol */,
         REQUEST_CONTEXT_TYPE_LOCATION,
         blink::WebMixedContentContextType::NotMixedContent,
         base::Callback<void(NavigationThrottle::ThrottleCheckResult)>());
   }
 
   CHECK(handle_);
-
-  // Make sure all NavigationThrottles have run.
-  // TODO(clamy): provide a non auto-advance mode if needed.
-  while (handle_->state_for_testing() == NavigationHandleImpl::DEFERRING_START)
-    handle_->Resume();
+  WaitForThrottleChecksComplete();
 
   CHECK_EQ(1, num_did_start_navigation_called_);
-  CHECK_EQ(1, num_will_start_request_called_);
+  if (GetLastThrottleCheckResult() == NavigationThrottle::PROCEED) {
+    CHECK_EQ(1, num_will_start_request_called_);
+  } else {
+    // TODO(clamy): Add error handling code based on the
+    // NavigationThrottleCheckResult here and in other methods.
+    state_ = FAILED;
+  }
 }
 
 void NavigationSimulator::Redirect(const GURL& new_url) {
   CHECK(state_ <= STARTED) << "NavigationSimulator::Redirect should be "
                               "called before Fail or Commit";
   CHECK_EQ(0, num_did_finish_navigation_called_)
       << "NavigationSimulator::Redirect cannot be called after the "
          "navigation has finished";
 
   if (state_ == INITIALIZATION)
     Start();
 
   navigation_url_ = new_url;
 
   int previous_num_will_redirect_request_called =
       num_will_redirect_request_called_;
   int previous_did_redirect_navigation_called =
       num_did_redirect_navigation_called_;
 
+  PrepareCompleteCallbackOnHandle();
   if (IsBrowserSideNavigationEnabled()) {
     NavigationRequest* request =
         render_frame_host_->frame_tree_node()->navigation_request();
     TestNavigationURLLoader* url_loader =
         static_cast<TestNavigationURLLoader*>(request->loader_for_testing());
     CHECK(url_loader);
 
     net::RedirectInfo redirect_info;
     redirect_info.status_code = 302;
     redirect_info.new_method = "GET";
     redirect_info.new_url = new_url;
     redirect_info.new_first_party_for_cookies = new_url;
     redirect_info.new_referrer = referrer_.url.spec();
     redirect_info.new_referrer_policy =
         Referrer::ReferrerPolicyForUrlRequest(referrer_);
 
     url_loader->CallOnRequestRedirected(
         redirect_info, scoped_refptr<ResourceResponse>(new ResourceResponse));
   } else {
     handle_->WillRedirectRequest(
         new_url, "GET", referrer_.url, false /* is_external_protocol */,
         scoped_refptr<net::HttpResponseHeaders>(),
         net::HttpResponseInfo::ConnectionInfo(),
         base::Callback<void(NavigationThrottle::ThrottleCheckResult)>());
   }
 
-  // Make sure all NavigationThrottles have run.
-  // TODO(clamy): provide a non auto-advance mode if needed.
-  while (handle_->state_for_testing() ==
-         NavigationHandleImpl::DEFERRING_REDIRECT) {
-    handle_->Resume();
+  WaitForThrottleChecksComplete();
+
+  if (GetLastThrottleCheckResult() == NavigationThrottle::PROCEED) {
+    CHECK_EQ(previous_num_will_redirect_request_called + 1,
+             num_will_redirect_request_called_);
+    CHECK_EQ(previous_did_redirect_navigation_called + 1,
+             num_did_redirect_navigation_called_);
+  } else {
+    state_ = FAILED;
   }
-
-  CHECK_EQ(previous_num_will_redirect_request_called + 1,
-           num_will_redirect_request_called_);
-  CHECK_EQ(previous_did_redirect_navigation_called + 1,
-           num_did_redirect_navigation_called_);
 }
 
 void NavigationSimulator::Commit() {
   CHECK_LE(state_, STARTED) << "NavigationSimulator::Commit can only be "
                                "called once, and cannot be called after "
                                "NavigationSimulator::Fail";
   CHECK_EQ(0, num_did_finish_navigation_called_)
       << "NavigationSimulator::Commit cannot be called after the "
          "navigation has finished";
 
   if (state_ == INITIALIZATION)
     Start();
 
+  PrepareCompleteCallbackOnHandle();
   if (IsBrowserSideNavigationEnabled() &&
       render_frame_host_->frame_tree_node()->navigation_request()) {
     render_frame_host_->PrepareForCommit();
   }
 
   // Call NavigationHandle::WillProcessResponse if needed.
-  if (handle_->state_for_testing() <
-      NavigationHandleImpl::WILL_PROCESS_RESPONSE) {
+  // Note that the handle's state can be CANCELING if a throttle cancelled it
+  // synchronously in PrepareForCommit.
+  if (handle_->state_for_testing() < NavigationHandleImpl::CANCELING) {
     handle_->WillProcessResponse(
         render_frame_host_, scoped_refptr<net::HttpResponseHeaders>(),
         net::HttpResponseInfo::ConnectionInfo(), SSLStatus(), GlobalRequestID(),
         false /* should_replace_current_entry */, false /* is_download */,
         false /* is_stream */, base::Closure(),
         base::Callback<void(NavigationThrottle::ThrottleCheckResult)>());
   }
 
-  // Make sure all NavigationThrottles have run.
-  // TODO(clamy): provide a non auto-advance mode if needed.
-  while (handle_->state_for_testing() ==
-         NavigationHandleImpl::DEFERRING_RESPONSE) {
-    handle_->Resume();
+  WaitForThrottleChecksComplete();
+
+  if (GetLastThrottleCheckResult() != NavigationThrottle::PROCEED) {
+    state_ = FAILED;
+    return;
   }
 
   CHECK_EQ(1, num_will_process_response_called_);
   CHECK_EQ(1, num_ready_to_commit_called_);
 
   // Update the RenderFrameHost now that we know which RenderFrameHost will
   // commit the navigation.
   TestRenderFrameHost* new_render_frame_host =
       static_cast<TestRenderFrameHost*>(handle_->GetRenderFrameHost());
   if (!IsBrowserSideNavigationEnabled() &&
@@ skipping 187 matching lines @@
       << "The transition cannot be set after the navigation has started";
   transition_ = transition;
 }
 
 void NavigationSimulator::SetReferrer(const Referrer& referrer) {
   CHECK_LE(state_, STARTED) << "The referrer cannot be set after the "
                                "navigation has committed or has failed";
   referrer_ = referrer;
 }
 
+NavigationThrottle::ThrottleCheckResult
+NavigationSimulator::GetLastThrottleCheckResult() {
+  return last_throttle_check_result_.value();
+}
+
 void NavigationSimulator::DidStartNavigation(
     NavigationHandle* navigation_handle) {
   // Check if this navigation is the one we're simulating.
   if (handle_)
     return;
 
   if (navigation_handle->GetURL() != navigation_url_)
     return;
 
   NavigationHandleImpl* handle =
       static_cast<NavigationHandleImpl*>(navigation_handle);
 
   if (handle->frame_tree_node() != render_frame_host_->frame_tree_node())
     return;
 
   handle_ = handle;
 
   num_did_start_navigation_called_++;
 
   // Add a throttle to count NavigationThrottle calls count.
   handle->RegisterThrottleForTesting(
       base::MakeUnique<NavigationThrottleCallbackRunner>(
           handle,
           base::Bind(&NavigationSimulator::OnWillStartRequest,
                      weak_factory_.GetWeakPtr()),
           base::Bind(&NavigationSimulator::OnWillRedirectRequest,
                      weak_factory_.GetWeakPtr()),
           base::Bind(&NavigationSimulator::OnWillProcessResponse,
                      weak_factory_.GetWeakPtr())));
+
+  PrepareCompleteCallbackOnHandle();
 }
 
 void NavigationSimulator::DidRedirectNavigation(
     NavigationHandle* navigation_handle) {
   if (navigation_handle == handle_)
     num_did_redirect_navigation_called_++;
 }
 
 void NavigationSimulator::ReadyToCommitNavigation(
     NavigationHandle* navigation_handle) {
@@ skipping 12 matching lines @@
 }
 
 void NavigationSimulator::OnWillRedirectRequest() {
   num_will_redirect_request_called_++;
 }
 
 void NavigationSimulator::OnWillProcessResponse() {
   num_will_process_response_called_++;
 }
 
+void NavigationSimulator::WaitForThrottleChecksComplete() {
+  // If last_throttle_check_result_ is set, then throttle checks completed
+  // synchronously.
+  if (last_throttle_check_result_)
+    return;
+
+  base::RunLoop run_loop;
+  throttle_checks_wait_closure_ = run_loop.QuitClosure();
+  run_loop.Run();
+  throttle_checks_wait_closure_.Reset();
+}
+
+void NavigationSimulator::OnThrottleChecksComplete(
+    NavigationThrottle::ThrottleCheckResult result) {
+  DCHECK(!last_throttle_check_result_);
+  last_throttle_check_result_ = result;
+  if (throttle_checks_wait_closure_)
+    throttle_checks_wait_closure_.Run();
+}
+
+void NavigationSimulator::PrepareCompleteCallbackOnHandle() {
+  last_throttle_check_result_.reset();
+  handle_->set_complete_callback_for_testing(
+      base::Bind(&NavigationSimulator::OnThrottleChecksComplete,
+                 weak_factory_.GetWeakPtr()));
+}
+
 }  // namespace content