Skip BeforeUnload on cross-site navigations when there are no handlers

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 175 matching lines @@
   main_test_rfh()->SendNavigate(0, kUrl2);
   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, main_test_rfh()->rfh_state());
   EXPECT_EQ(SiteInstanceImpl::GetSiteForURL(browser_context(), kUrl2),
             main_test_rfh()->GetSiteInstance()->GetSiteURL());
   EXPECT_EQ(kUrl2, contents()->GetLastCommittedURL());
   EXPECT_FALSE(GetNavigationRequestForFrameTreeNode(node));
   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
   EXPECT_FALSE(node->render_manager()->pending_frame_host());
 }
 
+// PlzNavigate: Test that the navigator waits for a beforeUnload ack before
+// starting the navigation when beforeUnload handlers are present in the frame.
+TEST_F(NavigatorTestWithBrowserSideNavigation, BeforeUnloadACK) {
+  const GURL kUrl1("http://www.google.com/");
+  const GURL kUrl2("http://www.chromium.org/");
+
+  contents()->NavigateAndCommit(kUrl1);
+  main_test_rfh()->SendBeforeUnloadHandlersPresent(true);
+
+  // Start a new navigation.
+  FrameTreeNode* node = main_test_rfh()->frame_tree_node();
+  RequestNavigation(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));
+  EXPECT_FALSE(request->loader_for_testing());
+
+  // Simulate a beforeUnload ACK.
+  main_test_rfh()->SendBeforeUnloadACK(true);
+  EXPECT_TRUE(GetNavigationRequestForFrameTreeNode(node));
+  EXPECT_TRUE(GetSpeculativeRenderFrameHost(node));
+  EXPECT_EQ(NavigationRequest::STARTED, request->state());
+  EXPECT_TRUE(request->loader_for_testing());
+}
+
 // PlzNavigate: Test that a beforeUnload denial cancels the navigation.
 TEST_F(NavigatorTestWithBrowserSideNavigation,
        BeforeUnloadDenialCancelNavigation) {
   const GURL kUrl1("http://www.google.com/");
   const GURL kUrl2("http://www.chromium.org/");
 
   contents()->NavigateAndCommit(kUrl1);
+  main_test_rfh()->SendBeforeUnloadHandlersPresent(true);
 
   // Start a new navigation.
   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
   RequestNavigation(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));
 
@@ skipping 47 matching lines @@
     EXPECT_TRUE(GetSpeculativeRenderFrameHost(subframe_node));
   } else {
     EXPECT_FALSE(GetSpeculativeRenderFrameHost(subframe_node));
   }
 
   // Now start a navigation at the root node.
   RequestNavigation(root_node, kUrl3);
   NavigationRequest* main_request =
       GetNavigationRequestForFrameTreeNode(root_node);
   ASSERT_TRUE(main_request);
-  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);
+  EXPECT_EQ(NavigationRequest::STARTED, main_request->state());
   TestNavigationURLLoader* main_loader =
       GetLoaderForNavigationRequest(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 from the renderer so the navigation should
-  // 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));
@@ skipping 394 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();
   RequestNavigation(node, 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