Introduce NavigationSimulator to use in unit tests

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 "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"
+
+namespace content {
+
+namespace {
+
+class NavigationThrottleCallbackRunner : public NavigationThrottle {
+ public:
+  NavigationThrottleCallbackRunner(
+      NavigationHandle* handle,
+      const base::Closure& on_will_start_request,
+      const base::Closure& on_will_redirect_request,
+      const base::Closure& on_will_process_response)
+      : NavigationThrottle(handle),
+        on_will_start_request_(on_will_start_request),
+        on_will_redirect_request_(on_will_redirect_request),
+        on_will_process_response_(on_will_process_response) {}
+
+  NavigationThrottle::ThrottleCheckResult WillStartRequest() override {
+    on_will_start_request_.Run();
+    return NavigationThrottle::PROCEED;
+  }
+
+  NavigationThrottle::ThrottleCheckResult WillRedirectRequest() override {
+    on_will_redirect_request_.Run();
+    return NavigationThrottle::PROCEED;
+  }
+
+  NavigationThrottle::ThrottleCheckResult WillProcessResponse() override {
+    on_will_process_response_.Run();
+    return NavigationThrottle::PROCEED;
+  }
+
+ private:
+  base::Closure on_will_start_request_;
+  base::Closure on_will_redirect_request_;
+  base::Closure on_will_process_response_;
+};
+
+}  // namespace
+
+// static
+void NavigationSimulator::NavigateAndCommitFromDocument(
+    const GURL& original_url,
+    RenderFrameHost* render_frame_host) {
+  NavigationSimulator simulator(
+      original_url, static_cast<TestRenderFrameHost*>(render_frame_host));
+  simulator.Commit();
+}
+
+// static
+void NavigationSimulator::NavigateAndFailFromDocument(
+    const GURL& original_url,
+    int net_error_code,
+    RenderFrameHost* render_frame_host) {
+  NavigationSimulator simulator(
+      original_url, static_cast<TestRenderFrameHost*>(render_frame_host));
+  simulator.Fail(net_error_code);
+  if (net_error_code != net::ERR_ABORTED)
+    simulator.CommitErrorPage();
+}
+
+// static
+std::unique_ptr<NavigationSimulator>
+NavigationSimulator::CreateRendererInitiated(
+    const GURL& original_url,
+    RenderFrameHost* render_frame_host) {
+  return base::MakeUnique<NavigationSimulator>(
+      original_url, static_cast<TestRenderFrameHost*>(render_frame_host));
+}
+
+NavigationSimulator::NavigationSimulator(const GURL& original_url,
+                                         TestRenderFrameHost* render_frame_host)
+    : WebContentsObserver(WebContents::FromRenderFrameHost(render_frame_host)),
+      render_frame_host_(render_frame_host),
+      handle_(nullptr),
+      navigation_url_(original_url),
+      weak_factory_(this) {
+  if (render_frame_host->GetParent()) {
+    if (!render_frame_host->frame_tree_node()->has_committed_real_load())
+      transition_ = ui::PAGE_TRANSITION_AUTO_SUBFRAME;
+    else
+      transition_ = ui::PAGE_TRANSITION_MANUAL_SUBFRAME;
+  }
+}
+
+NavigationSimulator::~NavigationSimulator() {}
+
+void NavigationSimulator::Start() {
+  CHECK(state_ == INITIALIZATION)
+      << "NavigationSimulator::Start should only be called once.";
+  state_ = STARTED;
+
+  if (IsBrowserSideNavigationEnabled()) {
+    BeginNavigationParams begin_params(
+        std::string(), net::LOAD_NORMAL, true /* has_user_gesture */,
+        false /* skip_service_worker */, REQUEST_CONTEXT_TYPE_HYPERLINK,
+        blink::WebMixedContentContextType::Blockable, url::Origin());
+    CommonNavigationParams common_params;
+    common_params.url = navigation_url_;
+    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);
+    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();
+
+  CHECK_EQ(1, num_did_start_navigation_called_);
+  CHECK_EQ(1, num_will_start_request_called_);
+}
+
+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_;
+
+  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();
+  }
+
+  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();
+
+  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) {
+    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();
+  }
+
+  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() &&
+      new_render_frame_host != render_frame_host_) {
+    CHECK(handle_->is_transferring());
+    // Simulate the renderer transfer.
+    new_render_frame_host->OnMessageReceived(FrameHostMsg_DidStartLoading(
+        new_render_frame_host->GetRoutingID(), true));
+    new_render_frame_host->OnMessageReceived(
+        FrameHostMsg_DidStartProvisionalLoad(
+            new_render_frame_host->GetRoutingID(), navigation_url_,
+            std::vector<GURL>(), base::TimeTicks::Now()));
+    CHECK(!handle_->is_transferring());
+  }
+  render_frame_host_ = new_render_frame_host;
+
+  // Keep a pointer to the current RenderFrameHost that may be pending deletion
+  // after commit.
+  RenderFrameHostImpl* previous_rfh =
+      render_frame_host_->frame_tree_node()->current_frame_host();
+
+  FrameHostMsg_DidCommitProvisionalLoad_Params params;
+  params.nav_entry_id = 0;
+  params.url = navigation_url_;
+  params.origin = url::Origin(navigation_url_);
+  params.transition = transition_;
+  params.should_update_history = true;
+  params.did_create_new_entry =
+      !render_frame_host_->GetParent() ||
+      render_frame_host_->frame_tree_node()->has_committed_real_load();
+  params.gesture = NavigationGestureUser;
+  params.contents_mime_type = "text/html";
+  params.method = "GET";
+  params.http_status_code = 200;
+  params.socket_address.set_host("2001:db8::1");
+  params.socket_address.set_port(80);
+  params.history_list_was_cleared = false;
+  params.original_request_url = navigation_url_;
+  params.was_within_same_page = false;
+  params.page_state =
+      PageState::CreateForTesting(navigation_url_, false, nullptr, nullptr);
+
+  render_frame_host_->SendNavigateWithParams(&params);
+
+  // Simulate the UnloadACK in the old RenderFrameHost if it was swapped out at
+  // commit time.
+  if (previous_rfh != render_frame_host_) {
+    previous_rfh->OnMessageReceived(
+        FrameHostMsg_SwapOut_ACK(previous_rfh->GetRoutingID()));
+  }
+
+  state_ = FINISHED;
+
+  CHECK_EQ(1, num_did_finish_navigation_called_);
+}
+
+void NavigationSimulator::Fail(int error_code) {
+  CHECK_LE(state_, STARTED) << "NavigationSimulator::Fail can only be "
+                               "called.";
+  CHECK_EQ(0, num_did_finish_navigation_called_)
+      << "NavigationSimulator::Fail cannot be called after the "
+         "navigation has finished";
+
+  if (state_ == INITIALIZATION)
+    Start();
+
+  state_ = FAILED;
+
+  bool should_result_in_error_page = error_code != net::ERR_ABORTED;
+  if (IsBrowserSideNavigationEnabled()) {
+    NavigationRequest* request =
+        render_frame_host_->frame_tree_node()->navigation_request();
+    CHECK(request);
+    TestNavigationURLLoader* url_loader =
+        static_cast<TestNavigationURLLoader*>(request->loader_for_testing());
+    CHECK(url_loader);
+    url_loader->SimulateError(error_code);
+  } else {
+    FrameHostMsg_DidFailProvisionalLoadWithError_Params error_params;
+    error_params.error_code = error_code;
+    error_params.url = navigation_url_;
+    render_frame_host_->OnMessageReceived(
+        FrameHostMsg_DidFailProvisionalLoadWithError(
+            render_frame_host_->GetRoutingID(), error_params));
+    if (!should_result_in_error_page) {
+      render_frame_host_->OnMessageReceived(
+          FrameHostMsg_DidStopLoading(render_frame_host_->GetRoutingID()));
+    }
+  }
+
+  if (IsBrowserSideNavigationEnabled()) {
+    CHECK_EQ(1, num_ready_to_commit_called_);
+    if (should_result_in_error_page) {
+      // Update the RenderFrameHost now that we know which RenderFrameHost will
+      // commit the error page.
+      render_frame_host_ =
+          static_cast<TestRenderFrameHost*>(handle_->GetRenderFrameHost());
+    }
+  }
+
+  if (should_result_in_error_page)
+    CHECK_EQ(0, num_did_finish_navigation_called_);
+  else
+    CHECK_EQ(1, num_did_finish_navigation_called_);
+}
+
+void NavigationSimulator::CommitErrorPage() {
+  CHECK_EQ(FAILED, state_)
+      << "NavigationSimulator::CommitErrorPage can only be "
+         "called once, and should be called after Fail "
+         "has been called";
+  CHECK_EQ(0, num_did_finish_navigation_called_)
+      << "NavigationSimulator::CommitErrorPage cannot be called after the "
+         "navigation has finished";
+
+  // Keep a pointer to the current RenderFrameHost that may be pending deletion
+  // after commit.
+  RenderFrameHostImpl* previous_rfh =
+      render_frame_host_->frame_tree_node()->current_frame_host();
+
+  GURL error_url = GURL(kUnreachableWebDataURL);
+  render_frame_host_->OnMessageReceived(FrameHostMsg_DidStartProvisionalLoad(
+      render_frame_host_->GetRoutingID(), error_url, std::vector<GURL>(),
+      base::TimeTicks::Now()));
+  FrameHostMsg_DidCommitProvisionalLoad_Params params;
+  params.nav_entry_id = 0;
+  params.did_create_new_entry = true;
+  params.url = navigation_url_;
+  params.transition = transition_;
+  params.was_within_same_page = false;
+  params.url_is_unreachable = true;
+  params.page_state =
+      PageState::CreateForTesting(navigation_url_, false, nullptr, nullptr);
+  render_frame_host_->SendNavigateWithParams(&params);
+
+  // Simulate the UnloadACK in the old RenderFrameHost if it was swapped out at
+  // commit time.
+  if (previous_rfh != render_frame_host_) {
+    previous_rfh->OnMessageReceived(
+        FrameHostMsg_SwapOut_ACK(previous_rfh->GetRoutingID()));
+  }
+
+  state_ = FINISHED;
+
+  CHECK_EQ(1, num_did_finish_navigation_called_);
+}
+
+void NavigationSimulator::CommitSamePage() {
+  CHECK_EQ(INITIALIZATION, state_)
+      << "NavigationSimulator::CommitErrorPage should be the only "
+         "navigation event function called on the NavigationSimulator";
+
+  render_frame_host_->OnMessageReceived(
+      FrameHostMsg_DidStartLoading(render_frame_host_->GetRoutingID(), false));
+
+  FrameHostMsg_DidCommitProvisionalLoad_Params params;
+  params.nav_entry_id = 0;
+  params.url = navigation_url_;
+  params.origin = url::Origin(navigation_url_);
+  params.transition = transition_;
+  params.should_update_history = true;
+  params.did_create_new_entry = false;
+  params.gesture = NavigationGestureUser;
+  params.contents_mime_type = "text/html";
+  params.method = "GET";
+  params.http_status_code = 200;
+  params.socket_address.set_host("2001:db8::1");
+  params.socket_address.set_port(80);
+  params.history_list_was_cleared = false;
+  params.original_request_url = navigation_url_;
+  params.was_within_same_page = true;
+  params.page_state =
+      PageState::CreateForTesting(navigation_url_, false, nullptr, nullptr);
+
+  render_frame_host_->SendNavigateWithParams(&params);
+
+  render_frame_host_->OnMessageReceived(
+      FrameHostMsg_DidStopLoading(render_frame_host_->GetRoutingID()));
+
+  state_ = FINISHED;
+
+  CHECK_EQ(1, num_did_start_navigation_called_);
+  CHECK_EQ(0, num_will_start_request_called_);
+  CHECK_EQ(0, num_will_process_response_called_);
+  CHECK_EQ(0, num_ready_to_commit_called_);
+  CHECK_EQ(1, num_did_finish_navigation_called_);
+}
+
+void NavigationSimulator::SetTransition(ui::PageTransition transition) {
+  CHECK_EQ(INITIALIZATION, state_)
+      << "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;
+}
+
+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())));
+}
+
+void NavigationSimulator::DidRedirectNavigation(
+    NavigationHandle* navigation_handle) {
+  if (navigation_handle == handle_)
+    num_did_redirect_navigation_called_++;
+}
+
+void NavigationSimulator::ReadyToCommitNavigation(
+    NavigationHandle* navigation_handle) {
+  if (navigation_handle == handle_)
+    num_ready_to_commit_called_++;
+}
+
+void NavigationSimulator::DidFinishNavigation(
+    NavigationHandle* navigation_handle) {
+  if (navigation_handle == handle_)
+    num_did_finish_navigation_called_++;
+}
+
+void NavigationSimulator::OnWillStartRequest() {
+  num_will_start_request_called_++;
+}
+
+void NavigationSimulator::OnWillRedirectRequest() {
+  num_will_redirect_request_called_++;
+}
+
+void NavigationSimulator::OnWillProcessResponse() {
+  num_will_process_response_called_++;
+}
+
+}  // namespace content