PlzNavigate: update Navigator tests post-removal of the RequestNavigation IPC

content/browser/frame_host/navigator_impl_unittest.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 "base/command_line.h"
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/frame_host/navigation_request.h"
@@ skipping 82 matching lines @@
         static_cast<MockRenderProcessHost*>(rfh->GetProcess());
     const FrameMsg_CommitNavigation* commit_message =
         static_cast<const FrameMsg_CommitNavigation*>(
             rph->sink().GetUniqueMessageMatching(
                 FrameMsg_CommitNavigation::ID));
     return commit_message &&
            rfh->GetRoutingID() == commit_message->routing_id();
   }
 };
 
-// PlzNavigate: Test final state after a complete navigation (to avoid repeating
-// these checks in other tests).
-TEST_F(NavigatorTestWithBrowserSideNavigation, NavigationFinishedState) {
+// PlzNavigate: Test final state after a complete browser-initiated navigation
+// (to avoid repeating these checks in other tests).
+TEST_F(NavigatorTestWithBrowserSideNavigation,
+       BrowserInitiatedNavigateAndCommit) {
   const GURL kUrl("http://chromium.org/");
+
+  EXPECT_FALSE(main_test_rfh()->IsRenderFrameLive());
+
   contents()->NavigateAndCommit(kUrl);
+  FrameTreeNode* node = main_test_rfh()->frame_tree_node();
   ASSERT_TRUE(main_test_rfh());
   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, main_test_rfh()->rfh_state());
   EXPECT_EQ(SiteInstanceImpl::GetSiteForURL(browser_context(), kUrl),
             main_test_rfh()->GetSiteInstance()->GetSiteURL());
   EXPECT_EQ(kUrl, contents()->GetLastCommittedURL());
+  EXPECT_FALSE(GetNavigationRequestForFrameTreeNode(node));
 
   // After a navigation is finished no speculative RenderFrameHost should
   // exist.
-  FrameTreeNode* node = main_test_rfh()->frame_tree_node();
   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
-

[clamy, 2015/02/10 15:41:22]

nit: do not remove the empty line here.

[carlosk, 2015/02/10 18:27:09]

Done.

   // With PlzNavigate enabled a pending RenderFrameHost should never exist.
   EXPECT_FALSE(node->render_manager()->pending_frame_host());
 }
 
+// PlzNavigate: Test a simple renderer initiated navigation starting with a

[clamy, 2015/02/10 15:41:22]

nit: renderer-initiated.

[carlosk, 2015/02/10 18:27:09]

Done.

+// non-live renderer.
+TEST_F(NavigatorTestWithBrowserSideNavigation,
+       SimpleRendererInitiatedNavigation) {

[clamy, 2015/02/10 15:41:22]

nit: I would rename the test RendererInitiatedNavigateAndCommit to match the
other test. It would also be good to match the descriptions between the two
tests.

[carlosk, 2015/02/10 18:27:09]

Done. As discussed offline I'm expanding the previous test to be a simple but
complete browser-initiated navigation test.

+  const GURL kUrl("http://chromium.org/");
+
+  EXPECT_FALSE(main_test_rfh()->IsRenderFrameLive());
+
+  main_test_rfh()->SendBeginNavigationWithURL(kUrl);

[clamy, 2015/02/10 15:41:22]

nit: Maybe a "// Start a renderer-initiated navigation." could be useful here?

[carlosk, 2015/02/10 18:27:09]

Done.

+  FrameTreeNode* node = main_test_rfh()->frame_tree_node();
+  NavigationRequest* request = GetNavigationRequestForFrameTreeNode(node);
+  ASSERT_TRUE(request);
+  EXPECT_EQ(kUrl, request->common_params().url);
+  EXPECT_FALSE(request->browser_initiated());
+  EXPECT_EQ(NavigationRequest::STARTED, request->state());
+  EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
+
+  // Request the RenderFrameHost to commit.

[clamy, 2015/02/10 15:41:22]

I would rephrase that as: Have the current RenderFrameHost commit the
navigation.

[carlosk, 2015/02/10 18:27:09]

Done.

+  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  GetLoaderForNavigationRequest(request)
+      ->CallOnResponseStarted(response, MakeEmptyStream());
+  EXPECT_TRUE(DidRenderFrameHostRequestCommit(main_test_rfh()));
+  EXPECT_EQ(NavigationRequest::RESPONSE_STARTED, request->state());
+
+  // And commit provisional load.

[clamy, 2015/02/10 15:41:22]

nit: maybe rephrase as The navigation commits. ?

[carlosk, 2015/02/10 18:27:09]

Done.

+  main_test_rfh()->SendNavigate(0, kUrl);
+  EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, main_test_rfh()->rfh_state());
+  EXPECT_EQ(SiteInstanceImpl::GetSiteForURL(browser_context(), kUrl),
+            main_test_rfh()->GetSiteInstance()->GetSiteURL());
+  EXPECT_EQ(kUrl, contents()->GetLastCommittedURL());
+  EXPECT_FALSE(GetNavigationRequestForFrameTreeNode(node));
+
+  // After a navigation is finished no speculative RenderFrameHost should
+  // exist.
+  EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
+  // With PlzNavigate enabled a pending RenderFrameHost should never exist.

[clamy, 2015/02/10 15:41:22]

nit: add an empty line above the comment.

[carlosk, 2015/02/10 18:27:09]

Done. In fact moved the comments to the previous test and removed them from
here.

+  EXPECT_FALSE(node->render_manager()->pending_frame_host());
+}
+
+// PlzNavigate: Test that the renderer can cancel a navigation with a proper
+// BeforeUnloadACK.

[clamy, 2015/02/10 15:41:22]

I would rephrase as: Test that a beforeUnload denial cancels the navigation.

[carlosk, 2015/02/10 18:27:09]

Done.

+TEST_F(NavigatorTestWithBrowserSideNavigation,
+       BeforeUnloadCancelledNavigation) {

[clamy, 2015/02/10 15:41:22]

nit: maybe rename the test to BeforeUnloadDenialCancelNavigation.

[carlosk, 2015/02/10 18:27:09]

Done.

+  const GURL kUrl1("http://www.google.com/");
+  const GURL kUrl2("http://www.chromium.org/");
+
+  contents()->NavigateAndCommit(kUrl1);
+
+  // Start a new navigation

[clamy, 2015/02/10 15:41:22]

nit: add a . at the end of the comment.

[carlosk, 2015/02/10 18:27:09]

Done.

+  FrameTreeNode* node = main_test_rfh()->frame_tree_node();
+  SendRequestNavigation(node, kUrl2);
+  NavigationRequest* request = GetNavigationRequestForFrameTreeNode(node);
+  ASSERT_TRUE(request);
+  EXPECT_TRUE(request->browser_initiated());
+  EXPECT_EQ(NavigationRequest::WAITING_FOR_RENDERER_RESPONSE, request->state());
+  EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
+
+  // Simulate a BeforeUnloadACK IPC with a signal to NOT proceed.

[clamy, 2015/02/10 15:41:22]

nit: Simulate a beforeUnload denial.

[carlosk, 2015/02/10 18:27:09]

Done.

+  main_test_rfh()->SendBeforeUnloadACK(false);
+  EXPECT_FALSE(GetNavigationRequestForFrameTreeNode(node));
+  EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
+}
+
 // PlzNavigate: Test that a proper NavigationRequest is created by
-// BeginNavigation.
-// Note that all PlzNavigate methods on the browser side require the use of the
-// flag kEnableBrowserSideNavigation.
+// RequestNavigation.
 TEST_F(NavigatorTestWithBrowserSideNavigation, BeginNavigation) {
   const GURL kUrl1("http://www.google.com/");
   const GURL kUrl2("http://www.chromium.org/");
   const GURL kUrl3("http://www.gmail.com/");
 
   contents()->NavigateAndCommit(kUrl1);
 
   // Add a subframe.
   FrameTreeNode* root_node = contents()->GetFrameTree()->root();
   TestRenderFrameHost* subframe_rfh = main_test_rfh()->AppendChild("Child");
   ASSERT_TRUE(subframe_rfh);
 
+  // Start a navigation at the subframe

[clamy, 2015/02/10 15:41:22]

nit: add . at the end of the comment.

[carlosk, 2015/02/10 18:27:09]

Done.

   FrameTreeNode* subframe_node = subframe_rfh->frame_tree_node();
   SendRequestNavigation(subframe_node, kUrl2);
-  // There is no previous renderer in the subframe, so BeginNavigation is
-  // handled already.
   NavigationRequest* subframe_request =
       GetNavigationRequestForFrameTreeNode(subframe_node);
   TestNavigationURLLoader* subframe_loader =
       GetLoaderForNavigationRequest(subframe_request);
   ASSERT_TRUE(subframe_request);
   EXPECT_EQ(kUrl2, subframe_request->common_params().url);
   EXPECT_EQ(kUrl2, subframe_loader->request_info()->common_params.url);
   // First party for cookies url should be that of the main frame.
   EXPECT_EQ(kUrl1, subframe_loader->request_info()->first_party_for_cookies);
   EXPECT_FALSE(subframe_loader->request_info()->is_main_frame);
   EXPECT_TRUE(subframe_loader->request_info()->parent_is_main_frame);
+  EXPECT_TRUE(subframe_request->browser_initiated());
+  // Subframe navigations should start right away as they don't have to request
+  // beforeUnload to run at the renderer.

[clamy, 2015/02/10 15:41:22]

Please move this comment to where the previous removed comment was and add an
empty line before it.

[carlosk, 2015/02/10 18:27:09]

Done. But I moved a bit more things around so that the following line sticks
together with the comment as they are closely related.

+  EXPECT_EQ(NavigationRequest::STARTED, subframe_request->state());

[clamy, 2015/02/10 15:41:22]

Please move this expect below the call creating the subframe request (and I
think that the assert can also go there).

[carlosk, 2015/02/10 18:27:09]

Yes, precisely. :)

   EXPECT_FALSE(GetSpeculativeRenderFrameHost(root_node));
 
   // Subframe navigations should never create a speculative RenderFrameHost,
   // unless site-per-process is enabled. In that case, as the subframe
   // navigation is to a different site and is still ongoing, it should have one.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSitePerProcess)) {
     EXPECT_TRUE(GetSpeculativeRenderFrameHost(subframe_node));
   } else {
     EXPECT_FALSE(GetSpeculativeRenderFrameHost(subframe_node));
   }
 
+  // Now start a navigation at the root node.
   SendRequestNavigation(root_node, kUrl3);
-  // Simulate a BeginNavigation IPC on the main frame.
-  main_test_rfh()->SendBeginNavigationWithURL(kUrl3);
   NavigationRequest* main_request =
       GetNavigationRequestForFrameTreeNode(root_node);
+  EXPECT_EQ(NavigationRequest::WAITING_FOR_RENDERER_RESPONSE,
+            main_request->state());
+  EXPECT_FALSE(GetSpeculativeRenderFrameHost(root_node));
+
+  // Simulate a BeforeUnloadACK IPC on the main frame.
+  main_test_rfh()->SendBeforeUnloadACK(true);
   TestNavigationURLLoader* main_loader =
       GetLoaderForNavigationRequest(main_request);
   ASSERT_TRUE(main_request);
   EXPECT_EQ(kUrl3, main_request->common_params().url);
   EXPECT_EQ(kUrl3, main_loader->request_info()->common_params.url);
   EXPECT_EQ(kUrl3, main_loader->request_info()->first_party_for_cookies);
   EXPECT_TRUE(main_loader->request_info()->is_main_frame);
   EXPECT_FALSE(main_loader->request_info()->parent_is_main_frame);
+  EXPECT_TRUE(main_request->browser_initiated());
+  // BeforeUnloadACK was received form the renderer so the navigation should

[clamy, 2015/02/10 15:41:22]

nit: s/form/from

[carlosk, 2015/02/10 18:27:09]

Done.

+  // have started.
+  EXPECT_EQ(NavigationRequest::STARTED, main_request->state());
 
   // Main frame navigation to a different site should use a speculative
   // RenderFrameHost.
   EXPECT_TRUE(GetSpeculativeRenderFrameHost(root_node));
 
   // As the main frame hasn't yet committed the subframe still exists. Thus, the
   // above situation regarding subframe navigations is valid here.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSitePerProcess)) {
     EXPECT_TRUE(GetSpeculativeRenderFrameHost(subframe_node));
   } else {
     EXPECT_FALSE(GetSpeculativeRenderFrameHost(subframe_node));
   }
 }
 
 // PlzNavigate: Test that RequestNavigation creates a NavigationRequest and that
 // RenderFrameHost is not modified when the navigation commits.
 TEST_F(NavigatorTestWithBrowserSideNavigation, NoLiveRenderer) {
   const GURL kUrl("http://www.google.com/");
 
   EXPECT_FALSE(main_test_rfh()->render_view_host()->IsRenderViewLive());
   RenderFrameHostImpl* rfh = main_test_rfh();
   FrameTreeNode* node = rfh->frame_tree_node();
   SendRequestNavigation(node, kUrl);
 
   // A NavigationRequest should have been generated.
   NavigationRequest* main_request = GetNavigationRequestForFrameTreeNode(node);
   EXPECT_TRUE(main_request != NULL);
+  // As there's not live renderer the navigation should not wait for a response

[clamy, 2015/02/10 15:41:22]

nit: s/not/no
nit: s/response/beforeUnload ACK

[carlosk, 2015/02/10 18:27:09]

Done but mind that this whole test moved into the newly added test -- simple
browser-initiated -- that starts from a non-live renderer and tests the same
things.

+  // from the renderer and start right away.
+  EXPECT_EQ(NavigationRequest::STARTED, main_request->state());
 
   // Since we're re-using the current RenderFrameHost, no speculative one should
   // be created.
   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 
   // Now return the response without any redirects. This will cause the
   // navigation to commit at the same URL.
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   GetLoaderForNavigationRequest(main_request)->CallOnResponseStarted(
       response, MakeEmptyStream());
-  main_request = GetNavigationRequestForFrameTreeNode(node);
+  EXPECT_EQ(NavigationRequest::RESPONSE_STARTED, main_request->state());
 
   // The main RFH should not have been changed, and the renderer should have
   // been initialized.
   EXPECT_EQ(rfh, main_test_rfh());
   EXPECT_TRUE(main_test_rfh()->IsRenderFrameLive());
   EXPECT_TRUE(main_test_rfh()->render_view_host()->IsRenderViewLive());
 }
 
 // PlzNavigate: Test that committing an HTTP 204 or HTTP 205 response cancels
 // the navigation.
 TEST_F(NavigatorTestWithBrowserSideNavigation, NoContent) {
   const GURL kUrl1("http://www.chromium.org/");
   const GURL kUrl2("http://www.google.com/");
 
   // Load a URL.
   contents()->NavigateAndCommit(kUrl1);
   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 
   // Navigate to a different site.
   process()->sink().ClearMessages();
   SendRequestNavigation(node, kUrl2);
-  main_test_rfh()->SendBeginNavigationWithURL(kUrl2);
+  main_test_rfh()->SendBeforeUnloadACK(true);
 
   NavigationRequest* main_request = GetNavigationRequestForFrameTreeNode(node);
   ASSERT_TRUE(main_request);
 
   // Navigations to a different site do create a speculative RenderFrameHost.
   EXPECT_TRUE(GetSpeculativeRenderFrameHost(node));
 
   // Commit an HTTP 204 response.
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   const char kNoContentHeaders[] = "HTTP/1.1 204 No Content\0\0";
   response->head.headers = new net::HttpResponseHeaders(
       std::string(kNoContentHeaders, arraysize(kNoContentHeaders)));
   GetLoaderForNavigationRequest(main_request)->CallOnResponseStarted(
       response, MakeEmptyStream());
 
   // There should be no pending nor speculative RenderFrameHost; the navigation
   // was aborted.
   EXPECT_FALSE(DidRenderFrameHostRequestCommit(main_test_rfh()));
   EXPECT_FALSE(GetNavigationRequestForFrameTreeNode(node));
   EXPECT_FALSE(node->render_manager()->pending_frame_host());
   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 
   // Now, repeat the test with 205 Reset Content.
 
   // Navigate to a different site again.
   process()->sink().ClearMessages();
   SendRequestNavigation(node, kUrl2);
-  main_test_rfh()->SendBeginNavigationWithURL(kUrl2);
+  main_test_rfh()->SendBeforeUnloadACK(true);
 
   main_request = GetNavigationRequestForFrameTreeNode(node);
   ASSERT_TRUE(main_request);
   EXPECT_TRUE(GetSpeculativeRenderFrameHost(node));
 
   // Commit an HTTP 205 response.
   response = new ResourceResponse;
   const char kResetContentHeaders[] = "HTTP/1.1 205 Reset Content\0\0";
   response->head.headers = new net::HttpResponseHeaders(
       std::string(kResetContentHeaders, arraysize(kResetContentHeaders)));
@@ skipping 14 matching lines @@
   const GURL kUrl1("http://www.chromium.org/");
   const GURL kUrl2("http://www.google.com/");
 
   contents()->NavigateAndCommit(kUrl1);
   RenderFrameHostImpl* initial_rfh = main_test_rfh();
   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 
   // Navigate to a different site.
   process()->sink().ClearMessages();
   SendRequestNavigation(node, kUrl2);
-  main_test_rfh()->SendBeginNavigationWithURL(kUrl2);
+  main_test_rfh()->SendBeforeUnloadACK(true);
   NavigationRequest* main_request = GetNavigationRequestForFrameTreeNode(node);
   ASSERT_TRUE(main_request);
   EXPECT_TRUE(GetSpeculativeRenderFrameHost(node));
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   GetLoaderForNavigationRequest(main_request)->CallOnResponseStarted(
       response, MakeEmptyStream());
   TestRenderFrameHost* speculative_rfh = GetSpeculativeRenderFrameHost(node);
   ASSERT_TRUE(speculative_rfh);
   EXPECT_TRUE(DidRenderFrameHostRequestCommit(speculative_rfh));
@@ skipping 15 matching lines @@
   const GURL kUrl1("http://www.chromium.org/");
   const GURL kUrl2("http://www.google.com/");
 
   contents()->NavigateAndCommit(kUrl1);
   RenderFrameHostImpl* rfh = main_test_rfh();
   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 
   // Navigate to a URL on the same site.
   process()->sink().ClearMessages();
   SendRequestNavigation(node, kUrl1);
-  main_test_rfh()->SendBeginNavigationWithURL(kUrl1);
+  main_test_rfh()->SendBeforeUnloadACK(true);
   NavigationRequest* main_request = GetNavigationRequestForFrameTreeNode(node);
   ASSERT_TRUE(main_request);
   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 
   // It then redirects to another site.
   net::RedirectInfo redirect_info;
   redirect_info.status_code = 302;
   redirect_info.new_method = "GET";
   redirect_info.new_url = kUrl2;
   redirect_info.new_first_party_for_cookies = kUrl2;
@@ skipping 18 matching lines @@
   final_speculative_rfh->SendNavigate(0, kUrl2);
   RenderFrameHostImpl* final_rfh = main_test_rfh();
   ASSERT_TRUE(final_rfh);
   EXPECT_NE(rfh, final_rfh);
   EXPECT_EQ(final_speculative_rfh, final_rfh);
   EXPECT_TRUE(final_rfh->IsRenderFrameLive());
   EXPECT_TRUE(final_rfh->render_view_host()->IsRenderViewLive());
   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 }
 
-// PlzNavigate: Test that a navigation is canceled if another request has been
-// issued in the meantime. Also confirms that the speculative RenderFrameHost is
-// correctly updated in the process.
-TEST_F(NavigatorTestWithBrowserSideNavigation, ReplacePendingNavigation) {
+// PlzNavigate: Test that a navigation is canceled if another browser-initiated
+// request has been issued in the meantime. Also confirms that the speculative
+// RenderFrameHost is correctly updated in the process.
+TEST_F(NavigatorTestWithBrowserSideNavigation,
+       BrowserInitiatedNavigationCancel) {
   const GURL kUrl0("http://www.wikipedia.org/");
   const GURL kUrl1("http://www.chromium.org/");
   const GURL kUrl1_site = SiteInstance::GetSiteForURL(browser_context(), kUrl1);
   const GURL kUrl2("http://www.google.com/");
   const GURL kUrl2_site = SiteInstance::GetSiteForURL(browser_context(), kUrl2);
 
   // Initialization.
   contents()->NavigateAndCommit(kUrl0);
   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 
   // Request navigation to the 1st URL.
   process()->sink().ClearMessages();
   SendRequestNavigation(node, kUrl1);
-  main_test_rfh()->SendBeginNavigationWithURL(kUrl1);
+  main_test_rfh()->SendBeforeUnloadACK(true);
   NavigationRequest* request1 = GetNavigationRequestForFrameTreeNode(node);
   ASSERT_TRUE(request1);
   EXPECT_EQ(kUrl1, request1->common_params().url);
+  EXPECT_TRUE(request1->browser_initiated());
   base::WeakPtr<TestNavigationURLLoader> loader1 =
       GetLoaderForNavigationRequest(request1)->AsWeakPtr();
 
   // Confirm a speculative RFH was created.
   TestRenderFrameHost* speculative_rfh = GetSpeculativeRenderFrameHost(node);
   ASSERT_TRUE(speculative_rfh);
   int32 site_instance_id_1 = speculative_rfh->GetSiteInstance()->GetId();
   EXPECT_EQ(kUrl1_site, speculative_rfh->GetSiteInstance()->GetSiteURL());
 
   // Request navigation to the 2nd URL; the NavigationRequest must have been
   // replaced by a new one with a different URL.
   SendRequestNavigation(node, kUrl2);
-  main_test_rfh()->SendBeginNavigationWithURL(kUrl2);
+  main_test_rfh()->SendBeforeUnloadACK(true);
   NavigationRequest* request2 = GetNavigationRequestForFrameTreeNode(node);
   ASSERT_TRUE(request2);
   EXPECT_EQ(kUrl2, request2->common_params().url);
+  EXPECT_TRUE(request2->browser_initiated());
 
   // Confirm that the first loader got destroyed.
   EXPECT_FALSE(loader1);
 
   // Confirm that a new speculative RFH was created.
   speculative_rfh = GetSpeculativeRenderFrameHost(node);
   ASSERT_TRUE(speculative_rfh);
   int32 site_instance_id_2 = speculative_rfh->GetSiteInstance()->GetId();
   EXPECT_NE(site_instance_id_1, site_instance_id_2);
 
@@ skipping 58 matching lines @@
        SpeculativeRendererWorksBaseCase) {
   // Navigate to an initial site.
   const GURL kUrlInit("http://wikipedia.org/");
   contents()->NavigateAndCommit(kUrlInit);
   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 
   // Begin navigating to another site.
   const GURL kUrl("http://google.com/");
   process()->sink().ClearMessages();
   SendRequestNavigation(node, kUrl);
-  main_test_rfh()->SendBeginNavigationWithURL(kUrl);
+  main_test_rfh()->SendBeforeUnloadACK(true);
   TestRenderFrameHost* speculative_rfh = GetSpeculativeRenderFrameHost(node);
   ASSERT_TRUE(speculative_rfh);
   EXPECT_NE(speculative_rfh, main_test_rfh());
   EXPECT_EQ(SiteInstanceImpl::GetSiteForURL(browser_context(), kUrl),
             speculative_rfh->GetSiteInstance()->GetSiteURL());
   EXPECT_FALSE(node->render_manager()->pending_frame_host());
   int32 site_instance_id = speculative_rfh->GetSiteInstance()->GetId();
 
   // Ask Navigator to commit the navigation by simulating a call to
   // OnResponseStarted.
@@ skipping 20 matching lines @@
   // Navigate to an initial site.
   const GURL kUrlInit("http://wikipedia.org/");
   contents()->NavigateAndCommit(kUrlInit);
   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
   int32 init_site_instance_id = main_test_rfh()->GetSiteInstance()->GetId();
 
   // Begin navigating to another site.
   const GURL kUrl("http://google.com/");
   process()->sink().ClearMessages();
   SendRequestNavigation(node, kUrl);
-  main_test_rfh()->SendBeginNavigationWithURL(kUrl);
+  main_test_rfh()->SendBeforeUnloadACK(true);
   TestRenderFrameHost* speculative_rfh = GetSpeculativeRenderFrameHost(node);
   int32 site_instance_id = speculative_rfh->GetSiteInstance()->GetId();
   EXPECT_NE(init_site_instance_id, site_instance_id);
   EXPECT_EQ(init_site_instance_id, main_test_rfh()->GetSiteInstance()->GetId());
   ASSERT_TRUE(speculative_rfh);
   EXPECT_NE(speculative_rfh, main_test_rfh());
   EXPECT_EQ(SiteInstanceImpl::GetSiteForURL(browser_context(), kUrl),
             speculative_rfh->GetSiteInstance()->GetSiteURL());
 
   // It then redirects to yet another site.
@@ skipping 69 matching lines @@
   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, main_test_rfh()->rfh_state());
   EXPECT_TRUE(rfhm->IsOnSwappedOutList(rfh1));
 
   // Now go back to the initial site so that the swapped out RenderFrameHost
   // should be reused.
   process()->sink().ClearMessages();
   static_cast<MockRenderProcessHost*>(rfh1->GetProcess())
       ->sink()
       .ClearMessages();
   SendRequestNavigation(node, kUrl1);
-  main_test_rfh()->SendBeginNavigationWithURL(kUrl1);
+  main_test_rfh()->SendBeforeUnloadACK(true);
   EXPECT_EQ(rfh1, GetSpeculativeRenderFrameHost(node));
   EXPECT_NE(RenderFrameHostImpl::STATE_DEFAULT,
             GetSpeculativeRenderFrameHost(node)->rfh_state());
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   GetLoaderForNavigationRequest(GetNavigationRequestForFrameTreeNode(node))
       ->CallOnResponseStarted(response, MakeEmptyStream());
   EXPECT_EQ(rfh1, GetSpeculativeRenderFrameHost(node));
   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT,
             GetSpeculativeRenderFrameHost(node)->rfh_state());
   EXPECT_TRUE(DidRenderFrameHostRequestCommit(rfh1));
   EXPECT_FALSE(DidRenderFrameHostRequestCommit(main_test_rfh()));
 
   rfh1->SendNavigate(1, kUrl1);
   EXPECT_EQ(rfh1, main_test_rfh());
   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, rfh1->rfh_state());
   EXPECT_FALSE(rfhm->IsOnSwappedOutList(rfh1));
 }
 
 }  // namespace content