Avoid canceling a pending navigation if the old RVH commits right away.

content/browser/tab_contents/navigation_controller_unittest.cc

 // Copyright (c) 2011 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/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 135 matching lines @@
   EXPECT_EQ(controller().entry_count(), 1);
   EXPECT_EQ(controller().last_committed_entry_index(), 0);
   EXPECT_EQ(controller().pending_entry_index(), -1);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_TRUE(controller().pending_entry());
   // TODO(darin): maybe this should really be true?
   EXPECT_FALSE(controller().CanGoBack());
   EXPECT_FALSE(controller().CanGoForward());
   EXPECT_EQ(contents()->GetMaxPageID(), 0);
 
-  rvh()->SendNavigate(1, url2);
+  // Simulate the beforeunload ack for the cross-site transition, and then the
+  // commit.
+  rvh()->SendShouldCloseACK(true);
+  contents()->pending_rvh()->SendNavigate(1, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
       NotificationType::NAV_ENTRY_COMMITTED));
 
   // The load should now be committed.
   EXPECT_EQ(controller().entry_count(), 2);
   EXPECT_EQ(controller().last_committed_entry_index(), 1);
   EXPECT_EQ(controller().pending_entry_index(), -1);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_FALSE(controller().pending_entry());
   EXPECT_TRUE(controller().CanGoBack());
@@ skipping 103 matching lines @@
   rvh()->SendNavigate(0, kExistingURL1);
   EXPECT_TRUE(notifications.Check1AndReset(
       NotificationType::NAV_ENTRY_COMMITTED));
 
   // Make a pending entry to somewhere new.
   const GURL kExistingURL2("http://bee");
   controller().LoadURL(kExistingURL2, GURL(),
                                   PageTransition::TYPED);
   EXPECT_EQ(0U, notifications.size());
 
-  // Before that commits, do a new navigation.
+  // After the beforeunload but before it commits, do a new navigation.
+  rvh()->SendShouldCloseACK(true);
   const GURL kNewURL("http://see");
-  rvh()->SendNavigate(3, kNewURL);
+  contents()->pending_rvh()->SendNavigate(3, kNewURL);
 
   // There should no longer be any pending entry, and the third navigation we
   // just made should be committed.
   EXPECT_TRUE(notifications.Check1AndReset(
       NotificationType::NAV_ENTRY_COMMITTED));
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_EQ(1, controller().last_committed_entry_index());
   EXPECT_EQ(kNewURL, controller().GetActiveEntry()->url());
 }
 
 // Tests navigating to a new URL when there is a pending back/forward
 // navigation. This will happen if the user hits back, but before that commits,
 // they navigate somewhere new.
 TEST_F(NavigationControllerTest, LoadURL_ExistingPending) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   // First make some history.
-  const GURL kExistingURL1("http://eh");
+  const GURL kExistingURL1("http://foo/eh");
   controller().LoadURL(kExistingURL1, GURL(),
                                   PageTransition::TYPED);
   rvh()->SendNavigate(0, kExistingURL1);
   EXPECT_TRUE(notifications.Check1AndReset(
       NotificationType::NAV_ENTRY_COMMITTED));
 
-  const GURL kExistingURL2("http://bee");
+  const GURL kExistingURL2("http://foo/bee");
   controller().LoadURL(kExistingURL2, GURL(),
                                   PageTransition::TYPED);
   rvh()->SendNavigate(1, kExistingURL2);
   EXPECT_TRUE(notifications.Check1AndReset(
       NotificationType::NAV_ENTRY_COMMITTED));
 
   // Now make a pending back/forward navigation. The zeroth entry should be
   // pending.
   controller().GoBack();
   EXPECT_EQ(0U, notifications.size());
   EXPECT_EQ(0, controller().pending_entry_index());
   EXPECT_EQ(1, controller().last_committed_entry_index());
 
   // Before that commits, do a new navigation.
-  const GURL kNewURL("http://see");
+  const GURL kNewURL("http://foo/see");
   content::LoadCommittedDetails details;
   rvh()->SendNavigate(3, kNewURL);
 
   // There should no longer be any pending entry, and the third navigation we
   // just made should be committed.
   EXPECT_TRUE(notifications.Check1AndReset(
       NotificationType::NAV_ENTRY_COMMITTED));
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_EQ(2, controller().last_committed_entry_index());
   EXPECT_EQ(kNewURL, controller().GetActiveEntry()->url());
 }
 
 // Tests navigating to an existing URL when there is a pending new navigation.
 // This will happen if the user enters a URL, but before that commits, the
 // current page fires history.back().
 TEST_F(NavigationControllerTest, LoadURL_BackPreemptsPending) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   // First make some history.
-  const GURL kExistingURL1("http://eh");
+  const GURL kExistingURL1("http://foo/eh");
   controller().LoadURL(kExistingURL1, GURL(), PageTransition::TYPED);
   rvh()->SendNavigate(0, kExistingURL1);
   EXPECT_TRUE(notifications.Check1AndReset(
       NotificationType::NAV_ENTRY_COMMITTED));
 
-  const GURL kExistingURL2("http://bee");
+  const GURL kExistingURL2("http://foo/bee");
   controller().LoadURL(kExistingURL2, GURL(), PageTransition::TYPED);
   rvh()->SendNavigate(1, kExistingURL2);
   EXPECT_TRUE(notifications.Check1AndReset(
       NotificationType::NAV_ENTRY_COMMITTED));
 
   // Now make a pending new navigation.
-  const GURL kNewURL("http://see");
+  const GURL kNewURL("http://foo/see");
   controller().LoadURL(kNewURL, GURL(), PageTransition::TYPED);
   EXPECT_EQ(0U, notifications.size());
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_EQ(1, controller().last_committed_entry_index());
 
   // Before that commits, a back navigation from the renderer commits.
   rvh()->SendNavigate(0, kExistingURL1);
 
   // There should no longer be any pending entry, and the back navigation we
   // just made should be committed.
@@ skipping 149 matching lines @@
   EXPECT_FALSE(controller().pending_entry());
   EXPECT_FALSE(controller().CanGoBack());
   EXPECT_TRUE(controller().CanGoForward());
 }
 
 // Tests what happens when a back navigation produces a new page.
 TEST_F(NavigationControllerTest, Back_GeneratesNewPage) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
-  const GURL url1("http://foo1");
-  const GURL url2("http://foo2");
-  const GURL url3("http://foo3");
+  const GURL url1("http://foo/1");
+  const GURL url2("http://foo/2");
+  const GURL url3("http://foo/3");
 
   controller().LoadURL(url1, GURL(), PageTransition::TYPED);
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
       NotificationType::NAV_ENTRY_COMMITTED));
 
   controller().LoadURL(url2, GURL(), PageTransition::TYPED);
   rvh()->SendNavigate(1, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
       NotificationType::NAV_ENTRY_COMMITTED));
@@ skipping 870 matching lines @@
   // At this point the interstitial will be displayed and the load will still
   // be pending. If the user continues, the load will commit.
   rvh()->SendNavigate(1, url2);
 
   // The page should be a normal page again.
   EXPECT_EQ(url2, controller().GetLastCommittedEntry()->url());
   EXPECT_EQ(NORMAL_PAGE, controller().GetLastCommittedEntry()->page_type());
 }
 
 TEST_F(NavigationControllerTest, RemoveEntry) {
-  const GURL url1("http://foo1");
-  const GURL url2("http://foo2");
-  const GURL url3("http://foo3");
-  const GURL url4("http://foo4");
-  const GURL url5("http://foo5");
-  const GURL pending_url("http://pending");
-  const GURL default_url("http://default");
+  const GURL url1("http://foo/1");
+  const GURL url2("http://foo/2");
+  const GURL url3("http://foo/3");
+  const GURL url4("http://foo/4");
+  const GURL url5("http://foo/5");
+  const GURL pending_url("http://foo/pending");
+  const GURL default_url("http://foo/default");
 
   controller().LoadURL(url1, GURL(), PageTransition::TYPED);
   rvh()->SendNavigate(0, url1);
   controller().LoadURL(url2, GURL(), PageTransition::TYPED);
   rvh()->SendNavigate(1, url2);
   controller().LoadURL(url3, GURL(), PageTransition::TYPED);
   rvh()->SendNavigate(2, url3);
   controller().LoadURL(url4, GURL(), PageTransition::TYPED);
   rvh()->SendNavigate(3, url4);
   controller().LoadURL(url5, GURL(), PageTransition::TYPED);
@@ skipping 36 matching lines @@
   EXPECT_EQ(-1, controller().last_committed_entry_index());
   pending_entry = controller().pending_entry();
   EXPECT_TRUE(pending_entry && pending_entry->url() == default_url);
 }
 
 // Tests the transient entry, making sure it goes away with all navigations.
 TEST_F(NavigationControllerTest, TransientEntry) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
-  const GURL url0("http://foo0");
-  const GURL url1("http://foo1");
-  const GURL url2("http://foo2");
-  const GURL url3("http://foo3");
-  const GURL url4("http://foo4");
-  const GURL transient_url("http://transient");
+  const GURL url0("http://foo/0");
+  const GURL url1("http://foo/1");
+  const GURL url2("http://foo/2");
+  const GURL url3("http://foo/3");
+  const GURL url4("http://foo/4");
+  const GURL transient_url("http://foo/transient");
 
   controller().LoadURL(url0, GURL(), PageTransition::TYPED);
   rvh()->SendNavigate(0, url0);
   controller().LoadURL(url1, GURL(), PageTransition::TYPED);
   rvh()->SendNavigate(1, url1);
 
   notifications.Reset();
 
   // Adding a transient with no pending entry.
   NavigationEntry* transient_entry = new NavigationEntry;
@@ skipping 433 matching lines @@
   EXPECT_EQ(url3, other_controller.pending_entry()->url());
 
   // Make sure session ids didn't change.
   EXPECT_EQ(id.id(), controller().session_id().id());
   EXPECT_EQ(other_id.id(), other_controller.session_id().id());
 }
 
 // Tests that navigations initiated from the page (with the history object)
 // work as expected without navigation entries.
 TEST_F(NavigationControllerTest, HistoryNavigate) {
-  const GURL url1("http://foo1");
-  const GURL url2("http://foo2");
-  const GURL url3("http://foo3");
+  const GURL url1("http://foo/1");
+  const GURL url2("http://foo/2");
+  const GURL url3("http://foo/3");
 
   NavigateAndCommit(url1);
   NavigateAndCommit(url2);
   NavigateAndCommit(url3);
   controller().GoBack();
   contents()->CommitPendingNavigation();
 
   // Simulate the page calling history.back(), it should not create a pending
   // entry.
   contents()->OnGoToEntryAtOffset(-1);
@@ skipping 34 matching lines @@
   const GURL url1("http://foo1");
   NavigateAndCommit(url1);
   controller().PruneAllButActive();
 
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_EQ(controller().GetEntryAtIndex(0)->url(), url1);
 }
 
 // Test call to PruneAllButActive for last entry.
 TEST_F(NavigationControllerTest, PruneAllButActiveForLast) {
-  const GURL url1("http://foo1");
-  const GURL url2("http://foo2");
-  const GURL url3("http://foo3");
+  const GURL url1("http://foo/1");
+  const GURL url2("http://foo/2");
+  const GURL url3("http://foo/3");
 
   NavigateAndCommit(url1);
   NavigateAndCommit(url2);
   NavigateAndCommit(url3);
   controller().GoBack();
   controller().GoBack();
   contents()->CommitPendingNavigation();
 
   controller().PruneAllButActive();
 
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_EQ(controller().GetEntryAtIndex(0)->url(), url1);
 }
 
 // Test call to PruneAllButActive for intermediate entry.
 TEST_F(NavigationControllerTest, PruneAllButActiveForIntermediate) {
-  const GURL url1("http://foo1");
-  const GURL url2("http://foo2");
-  const GURL url3("http://foo3");
+  const GURL url1("http://foo/1");
+  const GURL url2("http://foo/2");
+  const GURL url3("http://foo/3");
 
   NavigateAndCommit(url1);
   NavigateAndCommit(url2);
   NavigateAndCommit(url3);
   controller().GoBack();
   contents()->CommitPendingNavigation();
 
   controller().PruneAllButActive();
 
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_EQ(controller().GetEntryAtIndex(0)->url(), url2);
 }
 
 // Test call to PruneAllButActive for intermediate entry.
 TEST_F(NavigationControllerTest, PruneAllButActiveForPending) {
-  const GURL url1("http://foo1");
-  const GURL url2("http://foo2");
-  const GURL url3("http://foo3");
+  const GURL url1("http://foo/1");
+  const GURL url2("http://foo/2");
+  const GURL url3("http://foo/3");
 
   NavigateAndCommit(url1);
   NavigateAndCommit(url2);
   NavigateAndCommit(url3);
   controller().GoBack();
 
   controller().PruneAllButActive();
 
   EXPECT_EQ(0, controller().pending_entry_index());
 }
 
 // Test call to PruneAllButActive for transient entry.
 TEST_F(NavigationControllerTest, PruneAllButActiveForTransient) {
-  const GURL url0("http://foo0");
-  const GURL url1("http://foo1");
-  const GURL transient_url("http://transient");
+  const GURL url0("http://foo/0");
+  const GURL url1("http://foo/1");
+  const GURL transient_url("http://foo/transient");
 
   controller().LoadURL(url0, GURL(), PageTransition::TYPED);
   rvh()->SendNavigate(0, url0);
   controller().LoadURL(url1, GURL(), PageTransition::TYPED);
   rvh()->SendNavigate(1, url1);
 
   // Adding a transient with no pending entry.
   NavigationEntry* transient_entry = new NavigationEntry;
   transient_entry->set_url(transient_url);
   controller().AddTransientEntry(transient_entry);
@@ skipping 172 matching lines @@
   TabNavigation nav(0, url0, GURL(), string16(),
                     webkit_glue::CreateHistoryStateForURL(url0),
                     PageTransition::LINK);
   session_helper_.AssertNavigationEquals(nav,
                                          windows_[0]->tabs[0]->navigations[0]);
   nav.set_url(url2);
   session_helper_.AssertNavigationEquals(nav,
                                          windows_[0]->tabs[0]->navigations[1]);
 }
 */