Classify navigations without page id in parallel to the existing classifier.

content/browser/web_contents/web_contents_impl_unittest.cc

 // Copyright (c) 2012 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/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/frame_host/cross_site_transferring_request.h"
 #include "content/browser/frame_host/interstitial_page_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
@@ skipping 141 matching lines @@
 
   int command_received_count() const {
     return command_received_count_;
   }
 
   void TestDomOperationResponse(const std::string& json_string) {
     if (enabled())
       CommandReceived();
   }
 
-  void TestDidNavigate(int page_id, const GURL& url) {
+  void TestDidNavigate(int page_id,
+                       int nav_entry_id,
+                       bool did_create_new_entry,
+                       const GURL& url) {
     FrameHostMsg_DidCommitProvisionalLoad_Params params;
-    InitNavigateParams(&params, page_id, url, ui::PAGE_TRANSITION_TYPED);
+    InitNavigateParams(&params, page_id, nav_entry_id, did_create_new_entry,
+                       url, ui::PAGE_TRANSITION_TYPED);
     DidNavigate(GetMainFrame()->GetRenderViewHost(), params);
   }
 
   void TestRenderViewTerminated(base::TerminationStatus status,
                                 int error_code) {
     RenderViewTerminated(GetMainFrame()->GetRenderViewHost(), status,
                          error_code);
   }
 
   bool is_showing() const {
@@ skipping 169 matching lines @@
 };
 
 }  // namespace
 
 // Test to make sure that title updates get stripped of whitespace.
 TEST_F(WebContentsImplTest, UpdateTitle) {
   NavigationControllerImpl& cont =
       static_cast<NavigationControllerImpl&>(controller());
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   InitNavigateParams(
-      &params, 0, GURL(url::kAboutBlankURL), ui::PAGE_TRANSITION_TYPED);
+      &params, 0, 0, true, GURL(url::kAboutBlankURL),
+      ui::PAGE_TRANSITION_TYPED);
 
   LoadCommittedDetails details;
   cont.RendererDidNavigate(contents()->GetMainFrame(), params, &details);
 
   contents()->UpdateTitle(contents()->GetMainFrame(), 0,
                           base::ASCIIToUTF16("    Lots O' Whitespace\n"),
                           base::i18n::LEFT_TO_RIGHT);
   EXPECT_EQ(base::ASCIIToUTF16("Lots O' Whitespace"), contents()->GetTitle());
 }
 
@@ skipping 21 matching lines @@
 TEST_F(WebContentsImplTest, NTPViewSource) {
   NavigationControllerImpl& cont =
       static_cast<NavigationControllerImpl&>(controller());
   const char kUrl[] = "view-source:chrome://blah";
   const GURL kGURL(kUrl);
 
   process()->sink().ClearMessages();
 
   cont.LoadURL(
       kGURL, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = cont.GetPendingEntry();
   rvh()->GetDelegate()->RenderViewCreated(rvh());
   // Did we get the expected message?
   EXPECT_TRUE(process()->sink().GetFirstMessageMatching(
       ViewMsg_EnableViewSourceMode::ID));
 
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
-  InitNavigateParams(&params, 0, kGURL, ui::PAGE_TRANSITION_TYPED);
+  InitNavigateParams(&params, 0, entry->GetUniqueID(), true, kGURL,
+                     ui::PAGE_TRANSITION_TYPED);
   LoadCommittedDetails details;
   cont.RendererDidNavigate(contents()->GetMainFrame(), params, &details);
   // Also check title and url.
   EXPECT_EQ(base::ASCIIToUTF16(kUrl), contents()->GetTitle());
 }
 
 // Test to ensure UpdateMaxPageID is working properly.
 TEST_F(WebContentsImplTest, UpdateMaxPageID) {
   SiteInstance* instance1 = contents()->GetSiteInstance();
   scoped_refptr<SiteInstance> instance2(SiteInstance::Create(NULL));
@@ skipping 13 matching lines @@
   contents()->UpdateMaxPageIDForSiteInstance(instance2.get(), 7);
   EXPECT_EQ(3, contents()->GetMaxPageID());
   EXPECT_EQ(3, contents()->GetMaxPageIDForSiteInstance(instance1));
   EXPECT_EQ(7, contents()->GetMaxPageIDForSiteInstance(instance2.get()));
 }
 
 // Test simple same-SiteInstance navigation.
 TEST_F(WebContentsImplTest, SimpleNavigation) {
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
   SiteInstance* instance1 = contents()->GetSiteInstance();
-  EXPECT_TRUE(contents()->GetPendingMainFrame() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetPendingMainFrame());
 
   // Navigate to URL
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(instance1, orig_rfh->GetSiteInstance());
   // Controller's pending entry will have a NULL site instance until we assign
   // it in DidNavigate.
-  EXPECT_TRUE(
+  EXPECT_EQ(
+      nullptr,
       NavigationEntryImpl::FromNavigationEntry(controller().GetVisibleEntry())->
-          site_instance() == NULL);
+          site_instance());
 
   // DidNavigate from the page
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
   EXPECT_EQ(instance1, orig_rfh->GetSiteInstance());
   // Controller's entry should now have the SiteInstance, or else we won't be
   // able to find it later.
   EXPECT_EQ(
       instance1,
       NavigationEntryImpl::FromNavigationEntry(controller().GetVisibleEntry())->
           site_instance());
 }
 
 // Test that we reject NavigateToEntry if the url is over kMaxURLChars.
 TEST_F(WebContentsImplTest, NavigateToExcessivelyLongURL) {
   // Construct a URL that's kMaxURLChars + 1 long of all 'a's.
   const GURL url(std::string("http://example.org/").append(
       GetMaxURLChars() + 1, 'a'));
 
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_GENERATED, std::string());
-  EXPECT_TRUE(controller().GetVisibleEntry() == NULL);
+  EXPECT_EQ(nullptr, controller().GetVisibleEntry());
 }
 
 // Test that navigating across a site boundary creates a new RenderViewHost
 // with a new SiteInstance.  Going back should do the same.
 TEST_F(WebContentsImplTest, CrossSiteBoundaries) {
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
   int orig_rvh_delete_count = 0;
   orig_rfh->GetRenderViewHost()->set_delete_counter(&orig_rvh_delete_count);
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.  First URL should use first RenderViewHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   orig_rfh->PrepareForCommit();
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
 
   // Keep the number of active frames in orig_rfh's SiteInstance non-zero so
   // that orig_rfh doesn't get deleted when it gets swapped out.
   orig_rfh->GetSiteInstance()->increment_active_frame_count();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rfh->GetRenderViewHost(), contents()->GetRenderViewHost());
   EXPECT_EQ(url, contents()->GetLastCommittedURL());
   EXPECT_EQ(url, contents()->GetVisibleURL());
 
   // Navigate to new site
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  entry = controller().GetPendingEntry();
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation)) {
     orig_rfh->PrepareForCommit();
   }
   EXPECT_TRUE(contents()->cross_navigation_pending());
   EXPECT_EQ(url, contents()->GetLastCommittedURL());
   EXPECT_EQ(url2, contents()->GetVisibleURL());
   TestRenderFrameHost* pending_rfh = contents()->GetPendingMainFrame();
   int pending_rvh_delete_count = 0;
   pending_rfh->GetRenderViewHost()->set_delete_counter(
       &pending_rvh_delete_count);
 
   // Navigations should be suspended in pending_rfh until BeforeUnloadACK.
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation)) {
     EXPECT_TRUE(pending_rfh->are_navigations_suspended());
     orig_rfh->SendBeforeUnloadACK(true);
     EXPECT_FALSE(pending_rfh->are_navigations_suspended());
   }
 
   // DidNavigate from the pending page
-  contents()->TestDidNavigate(
-      pending_rfh, 1, url2, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(pending_rfh, 1, entry->GetUniqueID(), true, url2,
+                              ui::PAGE_TRANSITION_TYPED);
   SiteInstance* instance2 = contents()->GetSiteInstance();
 
   // Keep the number of active frames in pending_rfh's SiteInstance
   // non-zero so that orig_rfh doesn't get deleted when it gets
   // swapped out.
   pending_rfh->GetSiteInstance()->increment_active_frame_count();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(pending_rfh, contents()->GetMainFrame());
   EXPECT_EQ(url2, contents()->GetLastCommittedURL());
   EXPECT_EQ(url2, contents()->GetVisibleURL());
   EXPECT_NE(instance1, instance2);
-  EXPECT_TRUE(contents()->GetPendingMainFrame() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetPendingMainFrame());
   // We keep the original RFH around, swapped out.
   EXPECT_TRUE(contents()->GetRenderManagerForTesting()->IsOnSwappedOutList(
       orig_rfh));
   EXPECT_EQ(orig_rvh_delete_count, 0);
 
   // Going back should switch SiteInstances again.  The first SiteInstance is
   // stored in the NavigationEntry, so it should be the same as at the start.
   // We should use the same RFH as before, swapping it back in.
   controller().GoBack();
+  entry = controller().GetPendingEntry();
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation)) {
     contents()->GetMainFrame()->PrepareForCommit();
   }
   TestRenderFrameHost* goback_rfh = contents()->GetPendingMainFrame();
   EXPECT_EQ(orig_rfh, goback_rfh);
   EXPECT_TRUE(contents()->cross_navigation_pending());
 
   // Navigations should be suspended in goback_rfh until BeforeUnloadACK.
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation)) {
     EXPECT_TRUE(goback_rfh->are_navigations_suspended());
     pending_rfh->SendBeforeUnloadACK(true);
     EXPECT_FALSE(goback_rfh->are_navigations_suspended());
   }
 
   // DidNavigate from the back action
-  contents()->TestDidNavigate(goback_rfh, 1, url2, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(goback_rfh, 1, entry->GetUniqueID(), false, url2,
+                              ui::PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(goback_rfh, contents()->GetMainFrame());
   EXPECT_EQ(instance1, contents()->GetSiteInstance());
   // The pending RFH should now be swapped out, not deleted.
   EXPECT_TRUE(contents()->GetRenderManagerForTesting()->
       IsOnSwappedOutList(pending_rfh));
   EXPECT_EQ(pending_rvh_delete_count, 0);
   pending_rfh->OnSwappedOut();
 
   // Close contents and ensure RVHs are deleted.
   DeleteContents();
   EXPECT_EQ(orig_rvh_delete_count, 1);
   EXPECT_EQ(pending_rvh_delete_count, 1);
 }
 
 // Test that navigating across a site boundary after a crash creates a new
 // RFH without requiring a cross-site transition (i.e., PENDING state).
 TEST_F(WebContentsImplTest, CrossSiteBoundariesAfterCrash) {
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
 
   int orig_rvh_delete_count = 0;
   orig_rfh->GetRenderViewHost()->set_delete_counter(&orig_rvh_delete_count);
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.  First URL should use first RenderViewHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   contents()->GetMainFrame()->PrepareForCommit();
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rfh->GetRenderViewHost(), contents()->GetRenderViewHost());
 
   // Simulate a renderer crash.
   orig_rfh->GetRenderViewHost()->set_render_view_created(false);
   orig_rfh->SetRenderFrameCreated(false);
 
   // Navigate to new site.  We should not go into PENDING.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  entry = controller().GetPendingEntry();
   contents()->GetMainFrame()->PrepareForCommit();
   TestRenderFrameHost* new_rfh = contents()->GetMainFrame();
   EXPECT_FALSE(contents()->cross_navigation_pending());
-  EXPECT_TRUE(contents()->GetPendingMainFrame() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetPendingMainFrame());
   EXPECT_NE(orig_rfh, new_rfh);
   EXPECT_EQ(orig_rvh_delete_count, 1);
 
   // DidNavigate from the new page
-  contents()->TestDidNavigate(new_rfh, 1, url2, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(new_rfh, 1, entry->GetUniqueID(), true, url2,
+                              ui::PAGE_TRANSITION_TYPED);
   SiteInstance* instance2 = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(new_rfh, main_rfh());
   EXPECT_NE(instance1, instance2);
-  EXPECT_TRUE(contents()->GetPendingMainFrame() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetPendingMainFrame());
 
   // Close contents and ensure RVHs are deleted.
   DeleteContents();
   EXPECT_EQ(orig_rvh_delete_count, 1);
 }
 
 // Test that opening a new contents in the same SiteInstance and then navigating
 // both contentses to a new site will place both contentses in a single
 // SiteInstance.
 TEST_F(WebContentsImplTest, NavigateTwoTabsCrossSite) {
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.  First URL should use first RenderViewHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   contents()->GetMainFrame()->PrepareForCommit();
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
 
   // Open a new contents with the same SiteInstance, navigated to the same site.
   scoped_ptr<TestWebContents> contents2(
       TestWebContents::Create(browser_context(), instance1));
   contents2->GetController().LoadURL(url, Referrer(),
                                      ui::PAGE_TRANSITION_TYPED,
                                      std::string());
+  entry = contents2->GetController().GetPendingEntry();
   contents2->GetMainFrame()->PrepareForCommit();
   // Need this page id to be 2 since the site instance is the same (which is the
   // scope of page IDs) and we want to consider this a new page.
-  contents2->TestDidNavigate(
-      contents2->GetMainFrame(), 2, url, ui::PAGE_TRANSITION_TYPED);
+  contents2->TestDidNavigate(contents2->GetMainFrame(), 2, entry->GetUniqueID(),
+                             true, url, ui::PAGE_TRANSITION_TYPED);
 
   // Navigate first contents to a new site.
   const GURL url2a("http://www.yahoo.com");
   controller().LoadURL(
       url2a, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  entry = controller().GetPendingEntry();
   orig_rfh->PrepareForCommit();
   TestRenderFrameHost* pending_rfh_a = contents()->GetPendingMainFrame();
-  contents()->TestDidNavigate(
-      pending_rfh_a, 1, url2a, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(pending_rfh_a, 1, entry->GetUniqueID(), true,
+                              url2a, ui::PAGE_TRANSITION_TYPED);
   SiteInstance* instance2a = contents()->GetSiteInstance();
   EXPECT_NE(instance1, instance2a);
 
   // Navigate second contents to the same site as the first tab.
   const GURL url2b("http://mail.yahoo.com");
   contents2->GetController().LoadURL(url2b, Referrer(),
                                      ui::PAGE_TRANSITION_TYPED,
                                      std::string());
+  entry = contents2->GetController().GetPendingEntry();
   TestRenderFrameHost* rfh2 = contents2->GetMainFrame();
   rfh2->PrepareForCommit();
   TestRenderFrameHost* pending_rfh_b = contents2->GetPendingMainFrame();
-  EXPECT_TRUE(pending_rfh_b != NULL);
+  EXPECT_NE(nullptr, pending_rfh_b);
   EXPECT_TRUE(contents2->cross_navigation_pending());
 
   // NOTE(creis): We used to be in danger of showing a crash page here if the
   // second contents hadn't navigated somewhere first (bug 1145430).  That case
   // is now covered by the CrossSiteBoundariesAfterCrash test.
-  contents2->TestDidNavigate(
-      pending_rfh_b, 2, url2b, ui::PAGE_TRANSITION_TYPED);
+  contents2->TestDidNavigate(pending_rfh_b, 2, entry->GetUniqueID(), true,
+                             url2b, ui::PAGE_TRANSITION_TYPED);
   SiteInstance* instance2b = contents2->GetSiteInstance();
   EXPECT_NE(instance1, instance2b);
 
   // Both contentses should now be in the same SiteInstance.
   EXPECT_EQ(instance2a, instance2b);
 }
 
 // The embedder can request sites for certain urls not be be assigned to the
 // SiteInstance through ShouldAssignSiteForURL() in content browser client,
 // allowing to reuse the renderer backing certain chrome urls for subsequent
 // navigation. The test verifies that the override is honored.
 TEST_F(WebContentsImplTest, NavigateFromSitelessUrl) {
   WebContentsImplTestBrowserClient browser_client;
   SetBrowserClientForTesting(&browser_client);
 
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
   int orig_rvh_delete_count = 0;
   orig_rfh->GetRenderViewHost()->set_delete_counter(&orig_rvh_delete_count);
   SiteInstanceImpl* orig_instance = contents()->GetSiteInstance();
 
   browser_client.set_assign_site_for_url(false);
   // Navigate to an URL that will not assign a new SiteInstance.
   const GURL native_url("non-site-url://stuffandthings");
   controller().LoadURL(
       native_url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   contents()->GetMainFrame()->PrepareForCommit();
-  contents()->TestDidNavigate(
-      orig_rfh, 1, native_url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true,
+                              native_url, ui::PAGE_TRANSITION_TYPED);
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
   EXPECT_EQ(native_url, contents()->GetLastCommittedURL());
   EXPECT_EQ(native_url, contents()->GetVisibleURL());
   EXPECT_EQ(orig_instance, contents()->GetSiteInstance());
   EXPECT_EQ(GURL(), contents()->GetSiteInstance()->GetSiteURL());
   EXPECT_FALSE(orig_instance->HasSite());
 
   browser_client.set_assign_site_for_url(true);
   // Navigate to new site (should keep same site instance).
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  entry = controller().GetPendingEntry();
   contents()->GetMainFrame()->PrepareForCommit();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(native_url, contents()->GetLastCommittedURL());
   EXPECT_EQ(url, contents()->GetVisibleURL());
   EXPECT_FALSE(contents()->GetPendingMainFrame());
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
 
   // Keep the number of active frames in orig_rfh's SiteInstance
   // non-zero so that orig_rfh doesn't get deleted when it gets
   // swapped out.
   orig_rfh->GetSiteInstance()->increment_active_frame_count();
 
   EXPECT_EQ(orig_instance, contents()->GetSiteInstance());
   EXPECT_TRUE(
       contents()->GetSiteInstance()->GetSiteURL().DomainIs("google.com"));
   EXPECT_EQ(url, contents()->GetLastCommittedURL());
 
   // Navigate to another new site (should create a new site instance).
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  entry = controller().GetPendingEntry();
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation)) {
     orig_rfh->PrepareForCommit();
   }
   EXPECT_TRUE(contents()->cross_navigation_pending());
   EXPECT_EQ(url, contents()->GetLastCommittedURL());
   EXPECT_EQ(url2, contents()->GetVisibleURL());
   TestRenderFrameHost* pending_rfh = contents()->GetPendingMainFrame();
   int pending_rvh_delete_count = 0;
   pending_rfh->GetRenderViewHost()->set_delete_counter(
       &pending_rvh_delete_count);
 
   // Navigations should be suspended in pending_rvh until BeforeUnloadACK.
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation)) {
     EXPECT_TRUE(pending_rfh->are_navigations_suspended());
     orig_rfh->SendBeforeUnloadACK(true);
     EXPECT_FALSE(pending_rfh->are_navigations_suspended());
   }
 
   // DidNavigate from the pending page.
-  contents()->TestDidNavigate(
-      pending_rfh, 1, url2, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(pending_rfh, 1, entry->GetUniqueID(), true, url2,
+                              ui::PAGE_TRANSITION_TYPED);
   SiteInstance* new_instance = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(pending_rfh, contents()->GetMainFrame());
   EXPECT_EQ(url2, contents()->GetLastCommittedURL());
   EXPECT_EQ(url2, contents()->GetVisibleURL());
   EXPECT_NE(new_instance, orig_instance);
   EXPECT_FALSE(contents()->GetPendingMainFrame());
   // We keep the original RFH around, swapped out.
   EXPECT_TRUE(contents()->GetRenderManagerForTesting()->IsOnSwappedOutList(
@@ skipping 26 matching lines @@
       browser_context());
   entry->SetPageID(0);
   entries.push_back(entry);
   controller().Restore(
       0,
       NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY,
       &entries);
   ASSERT_EQ(0u, entries.size());
   ASSERT_EQ(1, controller().GetEntryCount());
   controller().GoToIndex(0);
-  contents()->TestDidNavigate(
-      orig_rfh, 0, native_url, ui::PAGE_TRANSITION_RELOAD);
+  entry = controller().GetPendingEntry();
+  contents()->TestDidNavigate(orig_rfh, 0, entry->GetUniqueID(), false,
+                              native_url, ui::PAGE_TRANSITION_RELOAD);
   EXPECT_EQ(orig_instance, contents()->GetSiteInstance());
   EXPECT_EQ(GURL(), contents()->GetSiteInstance()->GetSiteURL());
   EXPECT_FALSE(orig_instance->HasSite());
 
   // Navigate to a regular site and verify that the SiteInstance was kept.
   browser_client.set_assign_site_for_url(true);
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
-  contents()->TestDidNavigate(orig_rfh, 2, url, ui::PAGE_TRANSITION_TYPED);
+  entry = controller().GetPendingEntry();
+  contents()->TestDidNavigate(orig_rfh, 2, entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
   EXPECT_EQ(orig_instance, contents()->GetSiteInstance());
 
   // Cleanup.
   DeleteContents();
 }
 
 // Complement for NavigateFromRestoredSitelessUrl, verifying that when a regular
 // tab is restored, the SiteInstance will change upon navigation.
 TEST_F(WebContentsImplTest, NavigateFromRestoredRegularUrl) {
   WebContentsImplTestBrowserClient browser_client;
@@ skipping 11 matching lines @@
       browser_context());
   entry->SetPageID(0);
   entries.push_back(entry);
   controller().Restore(
       0,
       NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY,
       &entries);
   ASSERT_EQ(0u, entries.size());
   ASSERT_EQ(1, controller().GetEntryCount());
   controller().GoToIndex(0);
+  entry = controller().GetPendingEntry();
   orig_rfh->PrepareForCommit();
-  contents()->TestDidNavigate(
-      orig_rfh, 0, regular_url, ui::PAGE_TRANSITION_RELOAD);
+  contents()->TestDidNavigate(orig_rfh, 0, entry->GetUniqueID(), false,
+                              regular_url, ui::PAGE_TRANSITION_RELOAD);
   EXPECT_EQ(orig_instance, contents()->GetSiteInstance());
   EXPECT_TRUE(orig_instance->HasSite());
 
   // Navigate to another site and verify that a new SiteInstance was created.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  entry = controller().GetPendingEntry();
   orig_rfh->PrepareForCommit();
-  contents()->TestDidNavigate(
-      contents()->GetPendingMainFrame(), 2, url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(contents()->GetPendingMainFrame(), 2,
+                              entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
   EXPECT_NE(orig_instance, contents()->GetSiteInstance());
 
   // Cleanup.
   DeleteContents();
 }
 
 // Test that we can find an opener RVH even if it's pending.
 // http://crbug.com/176252.
 TEST_F(WebContentsImplTest, FindOpenerRVHWhenPending) {
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
 
   // Navigate to a URL.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   orig_rfh->PrepareForCommit();
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
 
   // Start to navigate first tab to a new site, so that it has a pending RVH.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   orig_rfh->PrepareForCommit();
   TestRenderFrameHost* pending_rfh = contents()->GetPendingMainFrame();
 
   // While it is still pending, simulate opening a new tab with the first tab
   // as its opener.  This will call WebContentsImpl::CreateOpenerRenderViews
   // on the opener to ensure that an RVH exists.
   int opener_routing_id =
       contents()->CreateOpenerRenderViews(pending_rfh->GetSiteInstance());
 
   // We should find the pending RVH and not create a new one.
   EXPECT_EQ(pending_rfh->GetRenderViewHost()->GetRoutingID(),
             opener_routing_id);
 }
 
 // Tests that WebContentsImpl uses the current URL, not the SiteInstance's site,
 // to determine whether a navigation is cross-site.
 TEST_F(WebContentsImplTest, CrossSiteComparesAgainstCurrentPage) {
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   contents()->GetMainFrame()->PrepareForCommit();
-  contents()->TestDidNavigate(
-      orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
 
   // Open a related contents to a second site.
   scoped_ptr<TestWebContents> contents2(
       TestWebContents::Create(browser_context(), instance1));
   const GURL url2("http://www.yahoo.com");
   contents2->GetController().LoadURL(url2, Referrer(),
                                      ui::PAGE_TRANSITION_TYPED,
                                      std::string());
+  entry = contents2->GetController().GetPendingEntry();
   contents2->GetMainFrame()->PrepareForCommit();
+
   // The first RVH in contents2 isn't live yet, so we shortcut the cross site
   // pending.
   TestRenderFrameHost* rfh2 = contents2->GetMainFrame();
   EXPECT_FALSE(contents2->cross_navigation_pending());
-  contents2->TestDidNavigate(rfh2, 2, url2, ui::PAGE_TRANSITION_TYPED);
+  contents2->TestDidNavigate(rfh2, 2, entry->GetUniqueID(), true, url2,
+                             ui::PAGE_TRANSITION_TYPED);
   SiteInstance* instance2 = contents2->GetSiteInstance();
   EXPECT_NE(instance1, instance2);
   EXPECT_FALSE(contents2->cross_navigation_pending());
 
   // Simulate a link click in first contents to second site.  Doesn't switch
-  // SiteInstances, because we don't intercept WebKit navigations.
+  // SiteInstances, because we don't intercept Blink navigations.
   contents()->TestDidNavigate(
-      orig_rfh, 2, url2, ui::PAGE_TRANSITION_TYPED);
+      orig_rfh, 2, 0, true, url2, ui::PAGE_TRANSITION_TYPED);
   SiteInstance* instance3 = contents()->GetSiteInstance();
   EXPECT_EQ(instance1, instance3);
   EXPECT_FALSE(contents()->cross_navigation_pending());
 
   // Navigate to the new site.  Doesn't switch SiteInstancees, because we
   // compare against the current URL, not the SiteInstance's site.
   const GURL url3("http://mail.yahoo.com");
   controller().LoadURL(
       url3, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  entry = controller().GetPendingEntry();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   contents()->GetMainFrame()->PrepareForCommit();
-  contents()->TestDidNavigate(
-      orig_rfh, 3, url3, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 3, entry->GetUniqueID(), true, url3,
+                              ui::PAGE_TRANSITION_TYPED);
   SiteInstance* instance4 = contents()->GetSiteInstance();
   EXPECT_EQ(instance1, instance4);
 }
 
 // Test that the onbeforeunload and onunload handlers run when navigating
 // across site boundaries.
 TEST_F(WebContentsImplTest, CrossSiteUnloadHandlers) {
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.  First URL should use first RenderViewHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   contents()->GetMainFrame()->PrepareForCommit();
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
 
   // Navigate to new site, but simulate an onbeforeunload denial.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_TRUE(orig_rfh->IsWaitingForBeforeUnloadACK());
   base::TimeTicks now = base::TimeTicks::Now();
   orig_rfh->OnMessageReceived(
       FrameHostMsg_BeforeUnload_ACK(0, false, now, now));
   EXPECT_FALSE(orig_rfh->IsWaitingForBeforeUnloadACK());
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
 
   // Navigate again, but simulate an onbeforeunload approval.
   controller().LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  entry = controller().GetPendingEntry();
   EXPECT_TRUE(orig_rfh->IsWaitingForBeforeUnloadACK());
   now = base::TimeTicks::Now();
   orig_rfh->PrepareForCommit();
   EXPECT_FALSE(orig_rfh->IsWaitingForBeforeUnloadACK());
   EXPECT_TRUE(contents()->cross_navigation_pending());
   TestRenderFrameHost* pending_rfh = contents()->GetPendingMainFrame();
 
   // We won't hear DidNavigate until the onunload handler has finished running.
 
   // DidNavigate from the pending page.
-  contents()->TestDidNavigate(
-      pending_rfh, 1, url2, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(pending_rfh, 1, entry->GetUniqueID(), true, url2,
+                              ui::PAGE_TRANSITION_TYPED);
   SiteInstance* instance2 = contents()->GetSiteInstance();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(pending_rfh, contents()->GetMainFrame());
   EXPECT_NE(instance1, instance2);
-  EXPECT_TRUE(contents()->GetPendingMainFrame() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetPendingMainFrame());
 }
 
 // Test that during a slow cross-site navigation, the original renderer can
 // navigate to a different URL and have it displayed, canceling the slow
 // navigation.
 TEST_F(WebContentsImplTest, CrossSiteNavigationPreempted) {
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.  First URL should use first RenderFrameHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   contents()->GetMainFrame()->PrepareForCommit();
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
 
   // Navigate to new site, simulating an onbeforeunload approval.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_TRUE(orig_rfh->IsWaitingForBeforeUnloadACK());
   orig_rfh->PrepareForCommit();
   EXPECT_TRUE(contents()->cross_navigation_pending());
 
   // Suppose the original renderer navigates before the new one is ready.
-  orig_rfh->SendNavigate(2, GURL("http://www.google.com/foo"));
+  orig_rfh->SendNavigate(2, 0, true, GURL("http://www.google.com/foo"));
 
   // Verify that the pending navigation is cancelled.
   EXPECT_FALSE(orig_rfh->IsWaitingForBeforeUnloadACK());
   SiteInstance* instance2 = contents()->GetSiteInstance();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
   EXPECT_EQ(instance1, instance2);
-  EXPECT_TRUE(contents()->GetPendingMainFrame() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetPendingMainFrame());
 }
 
 TEST_F(WebContentsImplTest, CrossSiteNavigationBackPreempted) {
   // Start with a web ui page, which gets a new RVH with WebUI bindings.
   const GURL url1("chrome://blah");
   controller().LoadURL(
       url1, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   TestRenderFrameHost* ntp_rfh = contents()->GetMainFrame();
   ntp_rfh->PrepareForCommit();
-  contents()->TestDidNavigate(ntp_rfh, 1, url1, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(ntp_rfh, 1, entry->GetUniqueID(), true, url1,
+                              ui::PAGE_TRANSITION_TYPED);
   NavigationEntry* entry1 = controller().GetLastCommittedEntry();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(ntp_rfh, contents()->GetMainFrame());
   EXPECT_EQ(url1, entry1->GetURL());
   EXPECT_EQ(instance1,
             NavigationEntryImpl::FromNavigationEntry(entry1)->site_instance());
   EXPECT_TRUE(ntp_rfh->GetRenderViewHost()->GetEnabledBindings() &
               BINDINGS_POLICY_WEB_UI);
 
   // Navigate to new site.
   const GURL url2("http://www.google.com");
   controller().LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  entry = controller().GetPendingEntry();
   EXPECT_TRUE(contents()->cross_navigation_pending());
   TestRenderFrameHost* google_rfh = contents()->GetPendingMainFrame();
 
   // Simulate beforeunload approval.
   EXPECT_TRUE(ntp_rfh->IsWaitingForBeforeUnloadACK());
   base::TimeTicks now = base::TimeTicks::Now();
   ntp_rfh->PrepareForCommit();
 
   // DidNavigate from the pending page.
-  contents()->TestDidNavigate(
-      google_rfh, 1, url2, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(google_rfh, 1, entry->GetUniqueID(), true, url2,
+                              ui::PAGE_TRANSITION_TYPED);
   NavigationEntry* entry2 = controller().GetLastCommittedEntry();
   SiteInstance* instance2 = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(google_rfh, contents()->GetMainFrame());
   EXPECT_NE(instance1, instance2);
   EXPECT_FALSE(contents()->GetPendingMainFrame());
   EXPECT_EQ(url2, entry2->GetURL());
   EXPECT_EQ(instance2,
             NavigationEntryImpl::FromNavigationEntry(entry2)->site_instance());
   EXPECT_FALSE(google_rfh->GetRenderViewHost()->GetEnabledBindings() &
                BINDINGS_POLICY_WEB_UI);
 
   // Navigate to third page on same site.
   const GURL url3("http://news.google.com");
   controller().LoadURL(
       url3, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  entry = controller().GetPendingEntry();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   contents()->GetMainFrame()->PrepareForCommit();
-  contents()->TestDidNavigate(
-      google_rfh, 2, url3, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(google_rfh, 2, entry->GetUniqueID(), true, url3,
+                              ui::PAGE_TRANSITION_TYPED);
   NavigationEntry* entry3 = controller().GetLastCommittedEntry();
   SiteInstance* instance3 = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(google_rfh, contents()->GetMainFrame());
   EXPECT_EQ(instance2, instance3);
   EXPECT_FALSE(contents()->GetPendingMainFrame());
   EXPECT_EQ(url3, entry3->GetURL());
   EXPECT_EQ(instance3,
             NavigationEntryImpl::FromNavigationEntry(entry3)->site_instance());
 
   // Go back within the site.
   controller().GoBack();
+  NavigationEntry* goback_entry = controller().GetPendingEntry();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(entry2, controller().GetPendingEntry());
 
   // Before that commits, go back again.
   controller().GoBack();
   EXPECT_TRUE(contents()->cross_navigation_pending());
   EXPECT_TRUE(contents()->GetPendingMainFrame());
   EXPECT_EQ(entry1, controller().GetPendingEntry());
 
   // Simulate beforeunload approval.
   EXPECT_TRUE(google_rfh->IsWaitingForBeforeUnloadACK());
   now = base::TimeTicks::Now();
   google_rfh->PrepareForCommit();
   google_rfh->OnMessageReceived(
       FrameHostMsg_BeforeUnload_ACK(0, true, now, now));
 
   // DidNavigate from the first back. This aborts the second back's pending RFH.
-  contents()->TestDidNavigate(google_rfh, 1, url2, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(google_rfh, 1, goback_entry->GetUniqueID(), false,
+                              url2, ui::PAGE_TRANSITION_TYPED);
 
   // We should commit this page and forget about the second back.
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_FALSE(controller().GetPendingEntry());
   EXPECT_EQ(google_rfh, contents()->GetMainFrame());
   EXPECT_EQ(url2, controller().GetLastCommittedEntry()->GetURL());
 
   // We should not have corrupted the NTP entry.
   EXPECT_EQ(instance3,
             NavigationEntryImpl::FromNavigationEntry(entry3)->site_instance());
   EXPECT_EQ(instance2,
             NavigationEntryImpl::FromNavigationEntry(entry2)->site_instance());
   EXPECT_EQ(instance1,
             NavigationEntryImpl::FromNavigationEntry(entry1)->site_instance());
   EXPECT_EQ(url1, entry1->GetURL());
 }
 
 // Test that during a slow cross-site navigation, a sub-frame navigation in the
 // original renderer will not cancel the slow navigation (bug 42029).
 TEST_F(WebContentsImplTest, CrossSiteNavigationNotPreemptedByFrame) {
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
 
   // Navigate to URL.  First URL should use the original RenderFrameHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   contents()->GetMainFrame()->PrepareForCommit();
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
 
   // Start navigating to new site.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
 
   // Simulate a sub-frame navigation arriving and ensure the RVH is still
   // waiting for a before unload response.
   TestRenderFrameHost* child_rfh = orig_rfh->AppendChild("subframe");
   child_rfh->SendNavigateWithTransition(
-      1, GURL("http://google.com/frame"), ui::PAGE_TRANSITION_AUTO_SUBFRAME);
+      1, 0, false, GURL("http://google.com/frame"),
+      ui::PAGE_TRANSITION_AUTO_SUBFRAME);
   EXPECT_TRUE(orig_rfh->IsWaitingForBeforeUnloadACK());
 
   // Now simulate the onbeforeunload approval and verify the navigation is
   // not canceled.
   orig_rfh->PrepareForCommit();
   EXPECT_FALSE(orig_rfh->IsWaitingForBeforeUnloadACK());
   EXPECT_TRUE(contents()->cross_navigation_pending());
 }
 
 // Test that a cross-site navigation is not preempted if the previous
 // renderer sends a FrameNavigate message just before being told to stop.
 // We should only preempt the cross-site navigation if the previous renderer
 // has started a new navigation.  See http://crbug.com/79176.
 TEST_F(WebContentsImplTest, CrossSiteNotPreemptedDuringBeforeUnload) {
   // Navigate to NTP URL.
   const GURL url("chrome://blah");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  int entry1_id = controller().GetPendingEntry()->GetUniqueID();
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
   EXPECT_FALSE(contents()->cross_navigation_pending());
 
   // Navigate to new site, with the beforeunload request in flight.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  int entry2_id = controller().GetPendingEntry()->GetUniqueID();
   TestRenderFrameHost* pending_rfh = contents()->GetPendingMainFrame();
   EXPECT_TRUE(contents()->cross_navigation_pending());
   EXPECT_TRUE(orig_rfh->IsWaitingForBeforeUnloadACK());
 
   // Suppose the first navigation tries to commit now, with a
   // FrameMsg_Stop in flight.  This should not cancel the pending navigation,
   // but it should act as if the beforeunload ack arrived.
-  orig_rfh->SendNavigate(1, GURL("chrome://blah"));
+  orig_rfh->SendNavigate(1, entry1_id, true, GURL("chrome://blah"));
   EXPECT_TRUE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
   EXPECT_FALSE(orig_rfh->IsWaitingForBeforeUnloadACK());
 
   // The pending navigation should be able to commit successfully.
-  contents()->TestDidNavigate(pending_rfh, 1, url2, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(pending_rfh, 1, entry2_id, true, url2,
+                              ui::PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(pending_rfh, contents()->GetMainFrame());
 }
 
 // Test that a cross-site navigation that doesn't commit after the unload
 // handler doesn't leave the contents in a stuck state.  http://crbug.com/88562
 TEST_F(WebContentsImplTest, CrossSiteNavigationCanceled) {
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.  First URL should use original RenderFrameHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   contents()->GetMainFrame()->PrepareForCommit();
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
 
   // Navigate to new site, simulating an onbeforeunload approval.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_TRUE(orig_rfh->IsWaitingForBeforeUnloadACK());
   contents()->GetMainFrame()->PrepareForCommit();
   EXPECT_TRUE(contents()->cross_navigation_pending());
 
   // Simulate swap out message when the response arrives.
   orig_rfh->OnSwappedOut();
 
   // Suppose the navigation doesn't get a chance to commit, and the user
   // navigates in the current RFH's SiteInstance.
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
 
   // Verify that the pending navigation is cancelled and the renderer is no
   // longer swapped out.
   EXPECT_FALSE(orig_rfh->IsWaitingForBeforeUnloadACK());
   SiteInstance* instance2 = contents()->GetSiteInstance();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, orig_rfh->rfh_state());
   EXPECT_EQ(instance1, instance2);
-  EXPECT_TRUE(contents()->GetPendingMainFrame() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetPendingMainFrame());
 }
 
 // Test that NavigationEntries have the correct page state after going
 // forward and back.  Prevents regression for bug 1116137.
 TEST_F(WebContentsImplTest, NavigationEntryContentState) {
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
 
   // Navigate to URL.  There should be no committed entry yet.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
-  NavigationEntry* entry = controller().GetLastCommittedEntry();
-  EXPECT_TRUE(entry == NULL);
+  NavigationEntry* pending_entry = controller().GetPendingEntry();
+  NavigationEntry* last_entry = controller().GetLastCommittedEntry();
+  EXPECT_EQ(nullptr, last_entry);
 
   // Committed entry should have page state after DidNavigate.
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
-  entry = controller().GetLastCommittedEntry();
-  EXPECT_TRUE(entry->GetPageState().IsValid());
+  contents()->TestDidNavigate(orig_rfh, 1, pending_entry->GetUniqueID(), true,
+                              url, ui::PAGE_TRANSITION_TYPED);
+  last_entry = controller().GetLastCommittedEntry();
+  EXPECT_TRUE(last_entry->GetPageState().IsValid());
 
   // Navigate to same site.
   const GURL url2("http://images.google.com");
   controller().LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
-  entry = controller().GetLastCommittedEntry();
-  EXPECT_TRUE(entry->GetPageState().IsValid());
+  pending_entry = controller().GetPendingEntry();
+  last_entry = controller().GetLastCommittedEntry();
+  EXPECT_TRUE(last_entry->GetPageState().IsValid());
 
   // Committed entry should have page state after DidNavigate.
-  contents()->TestDidNavigate(orig_rfh, 2, url2, ui::PAGE_TRANSITION_TYPED);
-  entry = controller().GetLastCommittedEntry();
-  EXPECT_TRUE(entry->GetPageState().IsValid());
+  contents()->TestDidNavigate(orig_rfh, 2, pending_entry->GetUniqueID(), true,
+                              url2, ui::PAGE_TRANSITION_TYPED);
+  last_entry = controller().GetLastCommittedEntry();
+  EXPECT_TRUE(last_entry->GetPageState().IsValid());
 
   // Now go back.  Committed entry should still have page state.
   controller().GoBack();
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
-  entry = controller().GetLastCommittedEntry();
-  EXPECT_TRUE(entry->GetPageState().IsValid());
+  pending_entry = controller().GetPendingEntry();
+  contents()->TestDidNavigate(orig_rfh, 1, pending_entry->GetUniqueID(), false,
+                              url, ui::PAGE_TRANSITION_TYPED);
+  last_entry = controller().GetLastCommittedEntry();
+  EXPECT_TRUE(last_entry->GetPageState().IsValid());
 }
 
 // Test that NavigationEntries have the correct page state and SiteInstance
 // state after opening a new window to about:blank.  Prevents regression for
 // bugs b/1116137 and http://crbug.com/111975.
 TEST_F(WebContentsImplTest, NavigationEntryContentStateNewWindow) {
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
 
-  // When opening a new window, it is navigated to about:blank internally.
-  // Currently, this results in two DidNavigate events.
+  // Navigate to about:blank.
   const GURL url(url::kAboutBlankURL);
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, 0, true, url,
+                              ui::PAGE_TRANSITION_TYPED);
 
   // Should have a page state here.
   NavigationEntry* entry = controller().GetLastCommittedEntry();
   EXPECT_TRUE(entry->GetPageState().IsValid());
 
   // The SiteInstance should be available for other navigations to use.
   NavigationEntryImpl* entry_impl =
       NavigationEntryImpl::FromNavigationEntry(entry);
   EXPECT_FALSE(entry_impl->site_instance()->HasSite());
   int32 site_instance_id = entry_impl->site_instance()->GetId();
 
   // Navigating to a normal page should not cause a process swap.
   const GURL new_url("http://www.google.com");
   controller().LoadURL(new_url, Referrer(),
                        ui::PAGE_TRANSITION_TYPED, std::string());
+  entry = controller().GetPendingEntry();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
-  contents()->TestDidNavigate(orig_rfh, 1, new_url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true, new_url,
+                              ui::PAGE_TRANSITION_TYPED);
   NavigationEntryImpl* entry_impl2 = NavigationEntryImpl::FromNavigationEntry(
       controller().GetLastCommittedEntry());
   EXPECT_EQ(site_instance_id, entry_impl2->site_instance()->GetId());
   EXPECT_TRUE(entry_impl2->site_instance()->HasSite());
 }
 
 // Tests that fullscreen is exited throughout the object hierarchy when
 // navigating to a new page.
 TEST_F(WebContentsImplTest, NavigationExitsFullscreen) {
   FakeFullscreenDelegate fake_delegate;
   contents()->SetDelegate(&fake_delegate);
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
   TestRenderViewHost* orig_rvh = orig_rfh->GetRenderViewHost();
 
   // Navigate to a site.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   contents()->GetMainFrame()->PrepareForCommit();
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
   EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
 
   // Toggle fullscreen mode on (as if initiated via IPC from renderer).
   EXPECT_FALSE(orig_rvh->IsFullscreen());
   EXPECT_FALSE(contents()->IsFullscreenForCurrentTab());
   EXPECT_FALSE(fake_delegate.IsFullscreenForTabOrPending(contents()));
   orig_rfh->OnMessageReceived(
       FrameHostMsg_ToggleFullscreen(orig_rfh->GetRoutingID(), true));
   EXPECT_TRUE(orig_rvh->IsFullscreen());
   EXPECT_TRUE(contents()->IsFullscreenForCurrentTab());
   EXPECT_TRUE(fake_delegate.IsFullscreenForTabOrPending(contents()));
 
   // Navigate to a new site.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  entry = controller().GetPendingEntry();
   contents()->GetMainFrame()->PrepareForCommit();
   TestRenderFrameHost* const pending_rfh = contents()->GetPendingMainFrame();
-  contents()->TestDidNavigate(
-      pending_rfh, 1, url2, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(pending_rfh, 1, entry->GetUniqueID(), true, url2,
+                              ui::PAGE_TRANSITION_TYPED);
 
   // Confirm fullscreen has exited.
   EXPECT_FALSE(orig_rvh->IsFullscreen());
   EXPECT_FALSE(contents()->IsFullscreenForCurrentTab());
   EXPECT_FALSE(fake_delegate.IsFullscreenForTabOrPending(contents()));
 
-  contents()->SetDelegate(NULL);
+  contents()->SetDelegate(nullptr);
 }
 
 // Tests that fullscreen is exited throughout the object hierarchy when
 // instructing NavigationController to GoBack() or GoForward().
 TEST_F(WebContentsImplTest, HistoryNavigationExitsFullscreen) {
   FakeFullscreenDelegate fake_delegate;
   contents()->SetDelegate(&fake_delegate);
   TestRenderFrameHost* const orig_rfh = contents()->GetMainFrame();
   TestRenderViewHost* const orig_rvh = orig_rfh->GetRenderViewHost();
 
   // Navigate to a site.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
-  contents()->TestDidNavigate(orig_rfh, 1, url, ui::PAGE_TRANSITION_TYPED);
+  NavigationEntry* entry = controller().GetPendingEntry();
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
   EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
 
   // Now, navigate to another page on the same site.
   const GURL url2("http://www.google.com/search?q=kittens");
   controller().LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  entry = controller().GetPendingEntry();
   EXPECT_FALSE(contents()->cross_navigation_pending());
-  contents()->TestDidNavigate(orig_rfh, 2, url2, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 2, entry->GetUniqueID(), true, url2,
+                              ui::PAGE_TRANSITION_TYPED);
   EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
 
   // Sanity-check: Confirm we're not starting out in fullscreen mode.
   EXPECT_FALSE(orig_rvh->IsFullscreen());
   EXPECT_FALSE(contents()->IsFullscreenForCurrentTab());
   EXPECT_FALSE(fake_delegate.IsFullscreenForTabOrPending(contents()));
 
   for (int i = 0; i < 2; ++i) {
     // Toggle fullscreen mode on (as if initiated via IPC from renderer).
     orig_rfh->OnMessageReceived(
         FrameHostMsg_ToggleFullscreen(orig_rfh->GetRoutingID(), true));
     EXPECT_TRUE(orig_rvh->IsFullscreen());
     EXPECT_TRUE(contents()->IsFullscreenForCurrentTab());
     EXPECT_TRUE(fake_delegate.IsFullscreenForTabOrPending(contents()));
 
     // Navigate backward (or forward).
     if (i == 0)
       controller().GoBack();
     else
       controller().GoForward();
+    entry = controller().GetPendingEntry();
     EXPECT_FALSE(contents()->cross_navigation_pending());
     EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
-    contents()->TestDidNavigate(
-        orig_rfh, i + 1, url, ui::PAGE_TRANSITION_FORWARD_BACK);
+    contents()->TestDidNavigate(orig_rfh, i + 1, entry->GetUniqueID(), false,
+                                url, ui::PAGE_TRANSITION_FORWARD_BACK);
 
     // Confirm fullscreen has exited.
     EXPECT_FALSE(orig_rvh->IsFullscreen());
     EXPECT_FALSE(contents()->IsFullscreenForCurrentTab());
     EXPECT_FALSE(fake_delegate.IsFullscreenForTabOrPending(contents()));
   }
 
   contents()->SetDelegate(NULL);
 }
 
@@ skipping 16 matching lines @@
 // Tests that fullscreen is exited throughout the object hierarchy on a renderer
 // crash.
 TEST_F(WebContentsImplTest, CrashExitsFullscreen) {
   FakeFullscreenDelegate fake_delegate;
   contents()->SetDelegate(&fake_delegate);
 
   // Navigate to a site.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
-  contents()->TestDidNavigate(
-      contents()->GetMainFrame(), 1, url, ui::PAGE_TRANSITION_TYPED);
+  NavigationEntry* entry = controller().GetPendingEntry();
+  contents()->TestDidNavigate(contents()->GetMainFrame(), 1,
+                              entry->GetUniqueID(), true, url,
+                              ui::PAGE_TRANSITION_TYPED);
 
   // Toggle fullscreen mode on (as if initiated via IPC from renderer).
   EXPECT_FALSE(test_rvh()->IsFullscreen());
   EXPECT_FALSE(contents()->IsFullscreenForCurrentTab());
   EXPECT_FALSE(fake_delegate.IsFullscreenForTabOrPending(contents()));
   contents()->GetMainFrame()->OnMessageReceived(FrameHostMsg_ToggleFullscreen(
       contents()->GetMainFrame()->GetRoutingID(), true));
   EXPECT_TRUE(test_rvh()->IsFullscreen());
   EXPECT_TRUE(contents()->IsFullscreenForCurrentTab());
   EXPECT_TRUE(fake_delegate.IsFullscreenForTabOrPending(contents()));
@@ skipping 15 matching lines @@
 // Interstitial Tests
 ////////////////////////////////////////////////////////////////////////////////
 
 // Test navigating to a page (with the navigation initiated from the browser,
 // as when a URL is typed in the location bar) that shows an interstitial and
 // creates a new navigation entry, then hiding it without proceeding.
 TEST_F(WebContentsImplTest,
        ShowInterstitialFromBrowserWithNewNavigationDontProceed) {
   // Navigate to a page.
   GURL url1("http://www.google.com");
-  contents()->GetMainFrame()->SendNavigate(1, url1);
+  contents()->GetMainFrame()->SendNavigate(1, 0, true, url1);
   EXPECT_EQ(1, controller().GetEntryCount());
 
-  // Initiate a browser navigation that will trigger the interstitial
+  // Initiate a browser navigation that will trigger the interstitial.
   controller().LoadURL(GURL("http://www.evil.com"), Referrer(),
                        ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL url2("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, url2, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
   // The interstitial should not show until its navigation has committed.
   EXPECT_FALSE(interstitial->is_showing());
   EXPECT_FALSE(contents()->ShowingInterstitialPage());
-  EXPECT_TRUE(contents()->GetInterstitialPage() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetInterstitialPage());
   // Let's commit the interstitial navigation.
-  interstitial->TestDidNavigate(1, url2);
+  interstitial->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                url2);
   EXPECT_TRUE(interstitial->is_showing());
   EXPECT_TRUE(contents()->ShowingInterstitialPage());
   EXPECT_TRUE(contents()->GetInterstitialPage() == interstitial);
-  NavigationEntry* entry = controller().GetVisibleEntry();
-  ASSERT_TRUE(entry != NULL);
+  entry = controller().GetVisibleEntry();
+  ASSERT_NE(nullptr, entry);
   EXPECT_TRUE(entry->GetURL() == url2);
 
   // Now don't proceed.
   interstitial->DontProceed();
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
   EXPECT_FALSE(contents()->ShowingInterstitialPage());
-  EXPECT_TRUE(contents()->GetInterstitialPage() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetInterstitialPage());
   entry = controller().GetVisibleEntry();
-  ASSERT_TRUE(entry != NULL);
+  ASSERT_NE(nullptr, entry);
   EXPECT_TRUE(entry->GetURL() == url1);
   EXPECT_EQ(1, controller().GetEntryCount());
 
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted);
 }
 
 // Test navigating to a page (with the navigation initiated from the renderer,
 // as when clicking on a link in the page) that shows an interstitial and
 // creates a new navigation entry, then hiding it without proceeding.
 TEST_F(WebContentsImplTest,
-       ShowInterstitiaFromRendererlWithNewNavigationDontProceed) {
+       ShowInterstitialFromRendererWithNewNavigationDontProceed) {
   // Navigate to a page.
   GURL url1("http://www.google.com");
-  contents()->GetMainFrame()->SendNavigate(1, url1);
+  contents()->GetMainFrame()->SendNavigate(1, 0, true, url1);
   EXPECT_EQ(1, controller().GetEntryCount());
+  NavigationEntry* entry = controller().GetPendingEntry();
 
   // Show an interstitial (no pending entry, the interstitial would have been
   // triggered by clicking on a link).
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL url2("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, url2, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
   // The interstitial should not show until its navigation has committed.
   EXPECT_FALSE(interstitial->is_showing());
   EXPECT_FALSE(contents()->ShowingInterstitialPage());
-  EXPECT_TRUE(contents()->GetInterstitialPage() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetInterstitialPage());
   // Let's commit the interstitial navigation.
-  interstitial->TestDidNavigate(1, url2);
+  interstitial->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                url2);
   EXPECT_TRUE(interstitial->is_showing());
   EXPECT_TRUE(contents()->ShowingInterstitialPage());
   EXPECT_TRUE(contents()->GetInterstitialPage() == interstitial);
-  NavigationEntry* entry = controller().GetVisibleEntry();
-  ASSERT_TRUE(entry != NULL);
+  entry = controller().GetVisibleEntry();
+  ASSERT_NE(nullptr, entry);
   EXPECT_TRUE(entry->GetURL() == url2);
 
   // Now don't proceed.
   interstitial->DontProceed();
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
   EXPECT_FALSE(contents()->ShowingInterstitialPage());
-  EXPECT_TRUE(contents()->GetInterstitialPage() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetInterstitialPage());
   entry = controller().GetVisibleEntry();
-  ASSERT_TRUE(entry != NULL);
+  ASSERT_NE(nullptr, entry);
   EXPECT_TRUE(entry->GetURL() == url1);
   EXPECT_EQ(1, controller().GetEntryCount());
 
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted);
 }
 
 // Test navigating to a page that shows an interstitial without creating a new
 // navigation entry (this happens when the interstitial is triggered by a
 // sub-resource in the page), then hiding it without proceeding.
 TEST_F(WebContentsImplTest, ShowInterstitialNoNewNavigationDontProceed) {
   // Navigate to a page.
   GURL url1("http://www.google.com");
-  contents()->GetMainFrame()->SendNavigate(1, url1);
+  contents()->GetMainFrame()->SendNavigate(1, 0, true, url1);
   EXPECT_EQ(1, controller().GetEntryCount());
+  NavigationEntry* entry = controller().GetPendingEntry();
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL url2("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), false, url2, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
   // The interstitial should not show until its navigation has committed.
   EXPECT_FALSE(interstitial->is_showing());
   EXPECT_FALSE(contents()->ShowingInterstitialPage());
-  EXPECT_TRUE(contents()->GetInterstitialPage() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetInterstitialPage());
   // Let's commit the interstitial navigation.
-  interstitial->TestDidNavigate(1, url2);
+  interstitial->TestDidNavigate(1, 0, true, url2);
   EXPECT_TRUE(interstitial->is_showing());
   EXPECT_TRUE(contents()->ShowingInterstitialPage());
   EXPECT_TRUE(contents()->GetInterstitialPage() == interstitial);
-  NavigationEntry* entry = controller().GetVisibleEntry();
-  ASSERT_TRUE(entry != NULL);
+  entry = controller().GetVisibleEntry();
+  ASSERT_NE(nullptr, entry);
   // The URL specified to the interstitial should have been ignored.
   EXPECT_TRUE(entry->GetURL() == url1);
 
   // Now don't proceed.
   interstitial->DontProceed();
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
   EXPECT_FALSE(contents()->ShowingInterstitialPage());
-  EXPECT_TRUE(contents()->GetInterstitialPage() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetInterstitialPage());
   entry = controller().GetVisibleEntry();
-  ASSERT_TRUE(entry != NULL);
+  ASSERT_NE(nullptr, entry);
   EXPECT_TRUE(entry->GetURL() == url1);
   EXPECT_EQ(1, controller().GetEntryCount());
 
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted);
 }
 
 // Test navigating to a page (with the navigation initiated from the browser,
 // as when a URL is typed in the location bar) that shows an interstitial and
 // creates a new navigation entry, then proceeding.
 TEST_F(WebContentsImplTest,
        ShowInterstitialFromBrowserNewNavigationProceed) {
   // Navigate to a page.
   GURL url1("http://www.google.com");
-  contents()->GetMainFrame()->SendNavigate(1, url1);
+  contents()->GetMainFrame()->SendNavigate(1, 0, true, url1);
   EXPECT_EQ(1, controller().GetEntryCount());
 
   // Initiate a browser navigation that will trigger the interstitial
   controller().LoadURL(GURL("http://www.evil.com"), Referrer(),
                         ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL url2("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, url2, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
   // The interstitial should not show until its navigation has committed.
   EXPECT_FALSE(interstitial->is_showing());
   EXPECT_FALSE(contents()->ShowingInterstitialPage());
-  EXPECT_TRUE(contents()->GetInterstitialPage() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetInterstitialPage());
   // Let's commit the interstitial navigation.
-  interstitial->TestDidNavigate(1, url2);
+  interstitial->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                url2);
   EXPECT_TRUE(interstitial->is_showing());
   EXPECT_TRUE(contents()->ShowingInterstitialPage());
   EXPECT_TRUE(contents()->GetInterstitialPage() == interstitial);
-  NavigationEntry* entry = controller().GetVisibleEntry();
-  ASSERT_TRUE(entry != NULL);
+  entry = controller().GetVisibleEntry();
+  ASSERT_NE(nullptr, entry);
   EXPECT_TRUE(entry->GetURL() == url2);
 
   // Then proceed.
   interstitial->Proceed();
   // The interstitial should show until the new navigation commits.
   RunAllPendingInMessageLoop();
   ASSERT_FALSE(deleted);
   EXPECT_EQ(TestInterstitialPage::OKED, state);
   EXPECT_TRUE(contents()->ShowingInterstitialPage());
   EXPECT_TRUE(contents()->GetInterstitialPage() == interstitial);
 
   // Simulate the navigation to the page, that's when the interstitial gets
   // hidden.
   GURL url3("http://www.thepage.com");
-  contents()->GetMainFrame()->SendNavigate(2, url3);
+  contents()->GetMainFrame()->SendNavigate(2, 0, true, url3);
 
   EXPECT_FALSE(contents()->ShowingInterstitialPage());
-  EXPECT_TRUE(contents()->GetInterstitialPage() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetInterstitialPage());
   entry = controller().GetVisibleEntry();
-  ASSERT_TRUE(entry != NULL);
+  ASSERT_NE(nullptr, entry);
   EXPECT_TRUE(entry->GetURL() == url3);
 
   EXPECT_EQ(2, controller().GetEntryCount());
 
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted);
 }
 
 // Test navigating to a page (with the navigation initiated from the renderer,
 // as when clicking on a link in the page) that shows an interstitial and
 // creates a new navigation entry, then proceeding.
 TEST_F(WebContentsImplTest,
        ShowInterstitialFromRendererNewNavigationProceed) {
   // Navigate to a page.
   GURL url1("http://www.google.com");
-  contents()->GetMainFrame()->SendNavigate(1, url1);
+  contents()->GetMainFrame()->SendNavigate(1, 0, true, url1);
   EXPECT_EQ(1, controller().GetEntryCount());
+  NavigationEntry* entry = controller().GetPendingEntry();
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL url2("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, url2, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
   // The interstitial should not show until its navigation has committed.
   EXPECT_FALSE(interstitial->is_showing());
   EXPECT_FALSE(contents()->ShowingInterstitialPage());
-  EXPECT_TRUE(contents()->GetInterstitialPage() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetInterstitialPage());
   // Let's commit the interstitial navigation.
-  interstitial->TestDidNavigate(1, url2);
+  interstitial->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                url2);
   EXPECT_TRUE(interstitial->is_showing());
   EXPECT_TRUE(contents()->ShowingInterstitialPage());
   EXPECT_TRUE(contents()->GetInterstitialPage() == interstitial);
-  NavigationEntry* entry = controller().GetVisibleEntry();
-  ASSERT_TRUE(entry != NULL);
+  entry = controller().GetVisibleEntry();
+  ASSERT_NE(nullptr, entry);
   EXPECT_TRUE(entry->GetURL() == url2);
 
   // Then proceed.
   interstitial->Proceed();
   // The interstitial should show until the new navigation commits.
   RunAllPendingInMessageLoop();
   ASSERT_FALSE(deleted);
   EXPECT_EQ(TestInterstitialPage::OKED, state);
   EXPECT_TRUE(contents()->ShowingInterstitialPage());
   EXPECT_TRUE(contents()->GetInterstitialPage() == interstitial);
 
   // Simulate the navigation to the page, that's when the interstitial gets
   // hidden.
   GURL url3("http://www.thepage.com");
-  contents()->GetMainFrame()->SendNavigate(2, url3);
+  contents()->GetMainFrame()->SendNavigate(2, 0, true, url3);
 
   EXPECT_FALSE(contents()->ShowingInterstitialPage());
-  EXPECT_TRUE(contents()->GetInterstitialPage() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetInterstitialPage());
   entry = controller().GetVisibleEntry();
-  ASSERT_TRUE(entry != NULL);
+  ASSERT_NE(nullptr, entry);
   EXPECT_TRUE(entry->GetURL() == url3);
 
   EXPECT_EQ(2, controller().GetEntryCount());
 
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted);
 }
 
 // Test navigating to a page that shows an interstitial without creating a new
 // navigation entry (this happens when the interstitial is triggered by a
 // sub-resource in the page), then proceeding.
 TEST_F(WebContentsImplTest, ShowInterstitialNoNewNavigationProceed) {
   // Navigate to a page so we have a navigation entry in the controller.
   GURL url1("http://www.google.com");
-  contents()->GetMainFrame()->SendNavigate(1, url1);
+  contents()->GetMainFrame()->SendNavigate(1, 0, true, url1);
   EXPECT_EQ(1, controller().GetEntryCount());
+  NavigationEntry* entry = controller().GetPendingEntry();
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL url2("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), false, url2, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
   // The interstitial should not show until its navigation has committed.
   EXPECT_FALSE(interstitial->is_showing());
   EXPECT_FALSE(contents()->ShowingInterstitialPage());
-  EXPECT_TRUE(contents()->GetInterstitialPage() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetInterstitialPage());
   // Let's commit the interstitial navigation.
-  interstitial->TestDidNavigate(1, url2);
+  interstitial->TestDidNavigate(1, 0, true, url2);
   EXPECT_TRUE(interstitial->is_showing());
   EXPECT_TRUE(contents()->ShowingInterstitialPage());
   EXPECT_TRUE(contents()->GetInterstitialPage() == interstitial);
-  NavigationEntry* entry = controller().GetVisibleEntry();
-  ASSERT_TRUE(entry != NULL);
+  entry = controller().GetVisibleEntry();
+  ASSERT_NE(nullptr, entry);
   // The URL specified to the interstitial should have been ignored.
   EXPECT_TRUE(entry->GetURL() == url1);
 
   // Then proceed.
   interstitial->Proceed();
   // Since this is not a new navigation, the previous page is dismissed right
   // away and shows the original page.
   EXPECT_EQ(TestInterstitialPage::OKED, state);
   EXPECT_FALSE(contents()->ShowingInterstitialPage());
-  EXPECT_TRUE(contents()->GetInterstitialPage() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetInterstitialPage());
   entry = controller().GetVisibleEntry();
-  ASSERT_TRUE(entry != NULL);
+  ASSERT_NE(nullptr, entry);
   EXPECT_TRUE(entry->GetURL() == url1);
 
   EXPECT_EQ(1, controller().GetEntryCount());
 
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted);
 }
 
 // Test navigating to a page that shows an interstitial, then navigating away.
 TEST_F(WebContentsImplTest, ShowInterstitialThenNavigate) {
   // Show interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL url("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, url, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
-  interstitial->TestDidNavigate(1, url);
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
+  interstitial->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                url);
 
   // While interstitial showing, navigate to a new URL.
   const GURL url2("http://www.yahoo.com");
-  contents()->GetMainFrame()->SendNavigate(1, url2);
+  contents()->GetMainFrame()->SendNavigate(1, 1, true, url2);
 
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
 
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted);
 }
 
 // Test navigating to a page that shows an interstitial, then going back.
 TEST_F(WebContentsImplTest, ShowInterstitialThenGoBack) {
   // Navigate to a page so we have a navigation entry in the controller.
   GURL url1("http://www.google.com");
-  contents()->GetMainFrame()->SendNavigate(1, url1);
+  contents()->GetMainFrame()->SendNavigate(1, 0, true, url1);
   EXPECT_EQ(1, controller().GetEntryCount());
+  NavigationEntry* entry = controller().GetLastCommittedEntry();
 
   // Show interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL interstitial_url("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, interstitial_url,
                                &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
-  interstitial->TestDidNavigate(2, interstitial_url);
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
+  interstitial->TestDidNavigate(2, interstitial_entry->GetUniqueID(), true,
+                                interstitial_url);
 
   // While the interstitial is showing, go back.
   controller().GoBack();
-  contents()->GetMainFrame()->SendNavigate(1, url1);
+  contents()->GetMainFrame()->SendNavigate(
+      1, entry->GetUniqueID(), false, url1);
 
   // Make sure we are back to the original page and that the interstitial is
   // gone.
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
-  NavigationEntry* entry = controller().GetVisibleEntry();
+  entry = controller().GetVisibleEntry();
   ASSERT_TRUE(entry);
   EXPECT_EQ(url1.spec(), entry->GetURL().spec());
 
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted);
 }
 
 // Test navigating to a page that shows an interstitial, has a renderer crash,
 // and then goes back.
 TEST_F(WebContentsImplTest, ShowInterstitialCrashRendererThenGoBack) {
   // Navigate to a page so we have a navigation entry in the controller.
   GURL url1("http://www.google.com");
-  contents()->GetMainFrame()->SendNavigate(1, url1);
+  contents()->GetMainFrame()->SendNavigate(1, 0, true, url1);
   EXPECT_EQ(1, controller().GetEntryCount());
+  NavigationEntry* entry = controller().GetLastCommittedEntry();
 
   // Show interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL interstitial_url("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, interstitial_url,
                                &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
-  interstitial->TestDidNavigate(2, interstitial_url);
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
+  interstitial->TestDidNavigate(2, interstitial_entry->GetUniqueID(), true,
+                                interstitial_url);
 
   // Crash the renderer
   main_rfh()->OnMessageReceived(
       FrameHostMsg_RenderProcessGone(
           0, base::TERMINATION_STATUS_PROCESS_CRASHED, -1));
 
   // While the interstitial is showing, go back.
   controller().GoBack();
-  contents()->GetMainFrame()->SendNavigate(1, url1);
+  contents()->GetMainFrame()->SendNavigate(
+      1, entry->GetUniqueID(), false, url1);
 
   // Make sure we are back to the original page and that the interstitial is
   // gone.
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
-  NavigationEntry* entry = controller().GetVisibleEntry();
+  entry = controller().GetVisibleEntry();
   ASSERT_TRUE(entry);
   EXPECT_EQ(url1.spec(), entry->GetURL().spec());
 
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted);
 }
 
 // Test navigating to a page that shows an interstitial, has the renderer crash,
 // and then navigates to the interstitial.
 TEST_F(WebContentsImplTest, ShowInterstitialCrashRendererThenNavigate) {
   // Navigate to a page so we have a navigation entry in the controller.
   GURL url1("http://www.google.com");
-  contents()->GetMainFrame()->SendNavigate(1, url1);
+  contents()->GetMainFrame()->SendNavigate(1, 0, true, url1);
   EXPECT_EQ(1, controller().GetEntryCount());
 
   // Show interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL interstitial_url("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, interstitial_url,
                                &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
 
   // Crash the renderer
   main_rfh()->OnMessageReceived(
       FrameHostMsg_RenderProcessGone(
           0, base::TERMINATION_STATUS_PROCESS_CRASHED, -1));
 
-  interstitial->TestDidNavigate(2, interstitial_url);
+  interstitial->TestDidNavigate(2, interstitial_entry->GetUniqueID(), true,
+                                interstitial_url);
 }
 
 // Test navigating to a page that shows an interstitial, then close the
 // contents.
 TEST_F(WebContentsImplTest, ShowInterstitialThenCloseTab) {
   // Show interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL url("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, url, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
-  interstitial->TestDidNavigate(1, url);
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
+  interstitial->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                url);
 
   // Now close the contents.
   DeleteContents();
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
 
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted);
 }
 
 // Test navigating to a page that shows an interstitial, then close the
 // contents.
 TEST_F(WebContentsImplTest, ShowInterstitialThenCloseAndShutdown) {
   // Show interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL url("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, url, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
-  interstitial->TestDidNavigate(1, url);
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
+  interstitial->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                url);
   RenderViewHostImpl* rvh = static_cast<RenderViewHostImpl*>(
       interstitial->GetMainFrame()->GetRenderViewHost());
 
   // Now close the contents.
   DeleteContents();
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
 
   // Before the interstitial has a chance to process its shutdown task,
   // simulate quitting the browser.  This goes through all processes and
   // tells them to destruct.
   rvh->GetMainFrame()->OnMessageReceived(
         FrameHostMsg_RenderProcessGone(0, 0, 0));
 
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted);
 }
 
 // Test that after Proceed is called and an interstitial is still shown, no more
 // commands get executed.
 TEST_F(WebContentsImplTest, ShowInterstitialProceedMultipleCommands) {
   // Navigate to a page so we have a navigation entry in the controller.
   GURL url1("http://www.google.com");
-  contents()->GetMainFrame()->SendNavigate(1, url1);
+  contents()->GetMainFrame()->SendNavigate(1, 0, true, url1);
   EXPECT_EQ(1, controller().GetEntryCount());
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL url2("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, url2, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
-  interstitial->TestDidNavigate(1, url2);
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
+  interstitial->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                url2);
 
   // Run a command.
   EXPECT_EQ(0, interstitial->command_received_count());
   interstitial->TestDomOperationResponse("toto");
   EXPECT_EQ(1, interstitial->command_received_count());
 
   // Then proceed.
   interstitial->Proceed();
   RunAllPendingInMessageLoop();
   ASSERT_FALSE(deleted);
 
   // While the navigation to the new page is pending, send other commands, they
   // should be ignored.
   interstitial->TestDomOperationResponse("hello");
   interstitial->TestDomOperationResponse("hi");
   EXPECT_EQ(1, interstitial->command_received_count());
 }
 
 // Test showing an interstitial while another interstitial is already showing.
 TEST_F(WebContentsImplTest, ShowInterstitialOnInterstitial) {
   // Navigate to a page so we have a navigation entry in the controller.
   GURL start_url("http://www.google.com");
-  contents()->GetMainFrame()->SendNavigate(1, start_url);
+  contents()->GetMainFrame()->SendNavigate(1, 0, true, start_url);
   EXPECT_EQ(1, controller().GetEntryCount());
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state1 =
       TestInterstitialPage::INVALID;
   bool deleted1 = false;
   GURL url1("http://interstitial1");
   TestInterstitialPage* interstitial1 =
       new TestInterstitialPage(contents(), true, url1, &state1, &deleted1);
   TestInterstitialPageStateGuard state_guard1(interstitial1);
   interstitial1->Show();
-  interstitial1->TestDidNavigate(1, url1);
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
+  interstitial1->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                 url1);
 
   // Now show another interstitial.
   TestInterstitialPage::InterstitialState state2 =
       TestInterstitialPage::INVALID;
   bool deleted2 = false;
   GURL url2("http://interstitial2");
   TestInterstitialPage* interstitial2 =
       new TestInterstitialPage(contents(), true, url2, &state2, &deleted2);
   TestInterstitialPageStateGuard state_guard2(interstitial2);
   interstitial2->Show();
-  interstitial2->TestDidNavigate(1, url2);
+  interstitial_entry = controller().GetTransientEntry();
+  interstitial2->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                 url2);
 
   // Showing interstitial2 should have caused interstitial1 to go away.
   EXPECT_EQ(TestInterstitialPage::CANCELED, state1);
   EXPECT_EQ(TestInterstitialPage::UNDECIDED, state2);
 
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted1);
   ASSERT_FALSE(deleted2);
 
   // Let's make sure interstitial2 is working as intended.
   interstitial2->Proceed();
   GURL landing_url("http://www.thepage.com");
-  contents()->GetMainFrame()->SendNavigate(2, landing_url);
+  contents()->GetMainFrame()->SendNavigate(2, 0, true, landing_url);
 
   EXPECT_FALSE(contents()->ShowingInterstitialPage());
-  EXPECT_TRUE(contents()->GetInterstitialPage() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetInterstitialPage());
   NavigationEntry* entry = controller().GetVisibleEntry();
-  ASSERT_TRUE(entry != NULL);
+  ASSERT_NE(nullptr, entry);
   EXPECT_TRUE(entry->GetURL() == landing_url);
   EXPECT_EQ(2, controller().GetEntryCount());
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted2);
 }
 
 // Test showing an interstitial, proceeding and then navigating to another
 // interstitial.
 TEST_F(WebContentsImplTest, ShowInterstitialProceedShowInterstitial) {
   // Navigate to a page so we have a navigation entry in the controller.
   GURL start_url("http://www.google.com");
-  contents()->GetMainFrame()->SendNavigate(1, start_url);
+  contents()->GetMainFrame()->SendNavigate(1, 0, true, start_url);
   EXPECT_EQ(1, controller().GetEntryCount());
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state1 =
       TestInterstitialPage::INVALID;
   bool deleted1 = false;
   GURL url1("http://interstitial1");
   TestInterstitialPage* interstitial1 =
       new TestInterstitialPage(contents(), true, url1, &state1, &deleted1);
   TestInterstitialPageStateGuard state_guard1(interstitial1);
   interstitial1->Show();
-  interstitial1->TestDidNavigate(1, url1);
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
+  interstitial1->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                 url1);
 
   // Take action.  The interstitial won't be hidden until the navigation is
   // committed.
   interstitial1->Proceed();
   EXPECT_EQ(TestInterstitialPage::OKED, state1);
 
   // Now show another interstitial (simulating the navigation causing another
   // interstitial).
   TestInterstitialPage::InterstitialState state2 =
       TestInterstitialPage::INVALID;
   bool deleted2 = false;
   GURL url2("http://interstitial2");
   TestInterstitialPage* interstitial2 =
       new TestInterstitialPage(contents(), true, url2, &state2, &deleted2);
   TestInterstitialPageStateGuard state_guard2(interstitial2);
   interstitial2->Show();
-  interstitial2->TestDidNavigate(1, url2);
+  interstitial_entry = controller().GetTransientEntry();
+  interstitial2->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                 url2);
 
   // Showing interstitial2 should have caused interstitial1 to go away.
   EXPECT_EQ(TestInterstitialPage::UNDECIDED, state2);
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted1);
   ASSERT_FALSE(deleted2);
 
   // Let's make sure interstitial2 is working as intended.
   interstitial2->Proceed();
   GURL landing_url("http://www.thepage.com");
-  contents()->GetMainFrame()->SendNavigate(2, landing_url);
+  contents()->GetMainFrame()->SendNavigate(2, 0, true, landing_url);
 
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted2);
   EXPECT_FALSE(contents()->ShowingInterstitialPage());
-  EXPECT_TRUE(contents()->GetInterstitialPage() == NULL);
+  EXPECT_EQ(nullptr, contents()->GetInterstitialPage());
   NavigationEntry* entry = controller().GetVisibleEntry();
-  ASSERT_TRUE(entry != NULL);
+  ASSERT_NE(nullptr, entry);
   EXPECT_TRUE(entry->GetURL() == landing_url);
   EXPECT_EQ(2, controller().GetEntryCount());
 }
 
 // Test that navigating away from an interstitial while it's loading cause it
 // not to show.
 TEST_F(WebContentsImplTest, NavigateBeforeInterstitialShows) {
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL interstitial_url("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, interstitial_url,
                                &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
 
   // Let's simulate a navigation initiated from the browser before the
   // interstitial finishes loading.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_FALSE(interstitial->is_showing());
   RunAllPendingInMessageLoop();
   ASSERT_FALSE(deleted);
 
   // Now let's make the interstitial navigation commit.
-  interstitial->TestDidNavigate(1, interstitial_url);
+  interstitial->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                interstitial_url);
 
   // After it loaded the interstitial should be gone.
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
 
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted);
 }
 
 // Test that a new request to show an interstitial while an interstitial is
 // pending does not cause problems. htp://crbug/29655 and htp://crbug/9442.
@@ skipping 13 matching lines @@
   // Show another interstitial on that same contents before the first one had
   // time to load.
   TestInterstitialPage::InterstitialState state2 =
       TestInterstitialPage::INVALID;
   bool deleted2 = false;
   TestInterstitialPage* interstitial2 =
       new TestInterstitialPage(contents(), true, interstitial_url,
                                &state2, &deleted2);
   TestInterstitialPageStateGuard state_guard2(interstitial2);
   interstitial2->Show();
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
 
   // The first interstitial should have been closed and deleted.
   EXPECT_EQ(TestInterstitialPage::CANCELED, state1);
   // The 2nd one should still be OK.
   EXPECT_EQ(TestInterstitialPage::UNDECIDED, state2);
 
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted1);
   ASSERT_FALSE(deleted2);
 
   // Make the interstitial navigation commit it should be showing.
-  interstitial2->TestDidNavigate(1, interstitial_url);
+  interstitial2->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                 interstitial_url);
   EXPECT_EQ(interstitial2, contents()->GetInterstitialPage());
 }
 
 // Test showing an interstitial and have its renderer crash.
 TEST_F(WebContentsImplTest, InterstitialCrasher) {
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL url("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, url, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
   // Simulate a renderer crash before the interstitial is shown.
   interstitial->TestRenderViewTerminated(
       base::TERMINATION_STATUS_PROCESS_CRASHED, -1);
   // The interstitial should have been dismissed.
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted);
 
   // Now try again but this time crash the intersitial after it was shown.
   interstitial =
       new TestInterstitialPage(contents(), true, url, &state, &deleted);
   interstitial->Show();
-  interstitial->TestDidNavigate(1, url);
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
+  interstitial->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                url);
   // Simulate a renderer crash.
   interstitial->TestRenderViewTerminated(
       base::TERMINATION_STATUS_PROCESS_CRASHED, -1);
   // The interstitial should have been dismissed.
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted);
 }
 
 // Tests that showing an interstitial as a result of a browser initiated
 // navigation while an interstitial is showing does not remove the pending
 // entry (see http://crbug.com/9791).
 TEST_F(WebContentsImplTest, NewInterstitialDoesNotCancelPendingEntry) {
   const char kUrl[] = "http://www.badguys.com/";
   const GURL kGURL(kUrl);
 
   // Start a navigation to a page
   contents()->GetController().LoadURL(
       kGURL, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
 
   // Simulate that navigation triggering an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, kGURL, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
-  interstitial->TestDidNavigate(1, kGURL);
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
+  interstitial->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                kGURL);
 
   // Initiate a new navigation from the browser that also triggers an
   // interstitial.
   contents()->GetController().LoadURL(
       kGURL, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   TestInterstitialPage::InterstitialState state2 =
       TestInterstitialPage::INVALID;
   bool deleted2 = false;
   TestInterstitialPage* interstitial2 =
       new TestInterstitialPage(contents(), true, kGURL, &state2, &deleted2);
   TestInterstitialPageStateGuard state_guard2(interstitial2);
   interstitial2->Show();
-  interstitial2->TestDidNavigate(1, kGURL);
+  interstitial_entry = controller().GetTransientEntry();
+  interstitial2->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                 kGURL);
 
   // Make sure we still have an entry.
   NavigationEntry* entry = contents()->GetController().GetPendingEntry();
   ASSERT_TRUE(entry);
   EXPECT_EQ(kUrl, entry->GetURL().spec());
 
   // And that the first interstitial is gone, but not the second.
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
   EXPECT_EQ(TestInterstitialPage::UNDECIDED, state2);
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(deleted);
   EXPECT_FALSE(deleted2);
 }
 
 // Tests that Javascript messages are not shown while an interstitial is
 // showing.
 TEST_F(WebContentsImplTest, NoJSMessageOnInterstitials) {
   const char kUrl[] = "http://www.badguys.com/";
   const GURL kGURL(kUrl);
 
   // Start a navigation to a page
   contents()->GetController().LoadURL(
       kGURL, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   // DidNavigate from the page
-  contents()->TestDidNavigate(
-      contents()->GetMainFrame(), 1, kGURL, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(contents()->GetMainFrame(), 1,
+                              entry->GetUniqueID(), true, kGURL,
+                              ui::PAGE_TRANSITION_TYPED);
 
   // Simulate showing an interstitial while the page is showing.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, kGURL, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
-  interstitial->TestDidNavigate(1, kGURL);
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
+  interstitial->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                kGURL);
 
   // While the interstitial is showing, let's simulate the hidden page
   // attempting to show a JS message.
   IPC::Message* dummy_message = new IPC::Message;
   contents()->RunJavaScriptMessage(contents()->GetMainFrame(),
       base::ASCIIToUTF16("This is an informative message"),
       base::ASCIIToUTF16("OK"),
       kGURL, JAVASCRIPT_MESSAGE_TYPE_ALERT, dummy_message);
   EXPECT_TRUE(contents()->last_dialog_suppressed_);
 }
 
 // Makes sure that if the source passed to CopyStateFromAndPrune has an
 // interstitial it isn't copied over to the destination.
 TEST_F(WebContentsImplTest, CopyStateFromAndPruneSourceInterstitial) {
   // Navigate to a page.
   GURL url1("http://www.google.com");
-  contents()->GetMainFrame()->SendNavigate(1, url1);
+  contents()->GetMainFrame()->SendNavigate(1, 0, true, url1);
   EXPECT_EQ(1, controller().GetEntryCount());
 
   // Initiate a browser navigation that will trigger the interstitial
   controller().LoadURL(GURL("http://www.evil.com"), Referrer(),
                         ui::PAGE_TRANSITION_TYPED, std::string());
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL url2("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, url2, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
-  interstitial->TestDidNavigate(1, url2);
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
+  interstitial->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                url2);
   EXPECT_TRUE(interstitial->is_showing());
   EXPECT_EQ(2, controller().GetEntryCount());
 
   // Create another NavigationController.
   GURL url3("http://foo2");
   scoped_ptr<TestWebContents> other_contents(
       static_cast<TestWebContents*>(CreateTestWebContents()));
   NavigationControllerImpl& other_controller = other_contents->GetController();
   other_contents->NavigateAndCommit(url3);
   other_contents->ExpectSetHistoryOffsetAndLength(1, 2);
@@ skipping 28 matching lines @@
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::INVALID;
   bool deleted = false;
   GURL url3("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(other_contents.get(), true, url3, &state,
                                &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
-  interstitial->TestDidNavigate(1, url3);
+  NavigationEntry* interstitial_entry = controller().GetTransientEntry();
+  interstitial->TestDidNavigate(1, interstitial_entry->GetUniqueID(), true,
+                                url3);
   EXPECT_TRUE(interstitial->is_showing());
   EXPECT_EQ(2, other_controller.GetEntryCount());
 
   // Ensure that we do not allow calling CopyStateFromAndPrune when an
   // interstitial is showing in the target.
   EXPECT_FALSE(other_controller.CanPruneAllButLastCommitted());
 }
 
 // Regression test for http://crbug.com/168611 - the URLs passed by the
 // DidFinishLoad and DidFailLoadWithError IPCs should get filtered.
@@ skipping 28 matching lines @@
 }
 
 // Test that if a pending contents is deleted before it is shown, we don't
 // crash.
 TEST_F(WebContentsImplTest, PendingContents) {
   scoped_ptr<TestWebContents> other_contents(
       static_cast<TestWebContents*>(CreateTestWebContents()));
   contents()->AddPendingContents(other_contents.get());
   int route_id = other_contents->GetRenderViewHost()->GetRoutingID();
   other_contents.reset();
-  EXPECT_EQ(NULL, contents()->GetCreatedWindow(route_id));
+  EXPECT_EQ(nullptr, contents()->GetCreatedWindow(route_id));
 }
 
 TEST_F(WebContentsImplTest, CapturerOverridesPreferredSize) {
   const gfx::Size original_preferred_size(1024, 768);
   contents()->UpdatePreferredSize(original_preferred_size);
 
   // With no capturers, expect the preferred size to be the one propagated into
   // WebContentsImpl via the RenderViewHostDelegate interface.
   EXPECT_EQ(contents()->GetCapturerCount(), 0);
   EXPECT_EQ(original_preferred_size, contents()->GetPreferredSize());
@@ skipping 371 matching lines @@
   const GURL bar_url("http://bar.chromium.org");
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
 
   // Use a WebContentsObserver to approximate the behavior of the tab's spinner.
   LoadingWebContentsObserver observer(contents());
 
   // Navigate the main RenderFrame, simulate the DidStartLoading, and commit.
   // The frame should still be loading.
   controller().LoadURL(
       main_url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   orig_rfh->OnMessageReceived(
       FrameHostMsg_DidStartLoading(orig_rfh->GetRoutingID(), false));
-  contents()->TestDidNavigate(orig_rfh, 1, main_url, ui::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rfh, 1, entry->GetUniqueID(), true, main_url,
+                              ui::PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rfh, contents()->GetMainFrame());
   EXPECT_TRUE(contents()->IsLoading());
   EXPECT_TRUE(observer.is_loading());
 
   // Create a child frame to navigate multiple times.
   TestRenderFrameHost* subframe = orig_rfh->AppendChild("subframe");
 
   // Navigate the child frame to about:blank, which will send both
   // DidStartLoading and DidStopLoading messages.
   {
     subframe->OnMessageReceived(
         FrameHostMsg_DidStartLoading(subframe->GetRoutingID(), true));
     subframe->SendNavigateWithTransition(
-        1, GURL("about:blank"), ui::PAGE_TRANSITION_AUTO_SUBFRAME);
+        1, 0, false, GURL("about:blank"), ui::PAGE_TRANSITION_AUTO_SUBFRAME);
     subframe->OnMessageReceived(
         FrameHostMsg_DidStopLoading(subframe->GetRoutingID()));
   }
 
   // Navigate the frame to another URL, which will send again
   // DidStartLoading and DidStopLoading messages.
   {
     subframe->OnMessageReceived(
         FrameHostMsg_DidStartLoading(subframe->GetRoutingID(), true));
     subframe->SendNavigateWithTransition(
-        1, foo_url, ui::PAGE_TRANSITION_AUTO_SUBFRAME);
+        1, 0, false, foo_url, ui::PAGE_TRANSITION_AUTO_SUBFRAME);
     subframe->OnMessageReceived(
         FrameHostMsg_DidStopLoading(subframe->GetRoutingID()));
   }
 
   // Since the main frame hasn't sent any DidStopLoading messages, it is
   // expected that the WebContents is still in loading state.
   EXPECT_TRUE(contents()->IsLoading());
   EXPECT_TRUE(observer.is_loading());
 
   // Navigate the frame again, this time using LoadURLWithParams. This causes
   // RenderFrameHost to call into WebContents::DidStartLoading, which starts
   // the spinner.
   {
     NavigationController::LoadURLParams load_params(bar_url);
     load_params.referrer =
         Referrer(GURL("http://referrer"), blink::WebReferrerPolicyDefault);
     load_params.transition_type = ui::PAGE_TRANSITION_GENERATED;
     load_params.extra_headers = "content-type: text/plain";
     load_params.load_type = NavigationController::LOAD_TYPE_DEFAULT;
     load_params.is_renderer_initiated = false;
     load_params.override_user_agent = NavigationController::UA_OVERRIDE_TRUE;
     load_params.frame_tree_node_id =
         subframe->frame_tree_node()->frame_tree_node_id();
     controller().LoadURLWithParams(load_params);
+    entry = controller().GetPendingEntry();
 
     subframe->OnMessageReceived(
         FrameHostMsg_DidStartLoading(subframe->GetRoutingID(), true));
 
     // Commit the navigation in the child frame and send the DidStopLoading
     // message.
-    contents()->TestDidNavigate(
-        subframe, 3, bar_url, ui::PAGE_TRANSITION_MANUAL_SUBFRAME);
+    contents()->TestDidNavigate(subframe, 3, entry->GetUniqueID(), true,
+                                bar_url, ui::PAGE_TRANSITION_MANUAL_SUBFRAME);
     subframe->OnMessageReceived(
         FrameHostMsg_DidStopLoading(subframe->GetRoutingID()));
   }
 
   // At this point the status should still be loading, since the main frame
   // hasn't sent the DidstopLoading message yet.
   EXPECT_TRUE(contents()->IsLoading());
   EXPECT_TRUE(observer.is_loading());
 
   // Send the DidStopLoading for the main frame and ensure it isn't loading
@@ skipping 15 matching lines @@
   const GURL kUrl3("http://www.wikipedia.org");
 
   contents()->NavigateAndCommit(kUrl1);
 
   TestRenderFrameHost* current_rfh = contents()->GetMainFrame();
 
   // Start a browser-initiated cross-process navigation to |kUrl2|. There should
   // be a pending RenderFrameHost and the WebContents should be loading.
   controller().LoadURL(
       kUrl2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  NavigationEntry* entry = controller().GetPendingEntry();
   EXPECT_TRUE(contents()->cross_navigation_pending());
   TestRenderFrameHost* pending_rfh = contents()->GetPendingMainFrame();
   ASSERT_TRUE(pending_rfh);
   EXPECT_TRUE(contents()->IsLoading());
 
   // The current RenderFrameHost starts a non user-initiated render-initiated
   // navigation and sends a DidStartLoading IPC. The WebContents should still be
   // loading.
   current_rfh->OnMessageReceived(
       FrameHostMsg_DidStartLoading(current_rfh->GetRoutingID(), false));
   EXPECT_TRUE(contents()->IsLoading());
 
   // Simulate the pending RenderFrameHost DidStartLoading. There should still be
   // a pending RenderFrameHost and the WebContents should still be loading.
   pending_rfh->PrepareForCommit();
   pending_rfh->OnMessageReceived(
       FrameHostMsg_DidStartLoading(pending_rfh->GetRoutingID(), false));
   EXPECT_EQ(contents()->GetPendingMainFrame(), pending_rfh);
   EXPECT_TRUE(contents()->IsLoading());
 
   // Simulate the commit and DidStopLoading from the renderer-initiated
   // navigation in the current RenderFrameHost. There should still be a pending
   // RenderFrameHost and the WebContents should still be loading.
-  current_rfh->SendNavigate(1, kUrl3);
+  current_rfh->SendNavigate(1, 0, true, kUrl3);
   current_rfh->OnMessageReceived(
       FrameHostMsg_DidStopLoading(current_rfh->GetRoutingID()));
   EXPECT_EQ(contents()->GetPendingMainFrame(), pending_rfh);
   EXPECT_TRUE(contents()->IsLoading());
 
   // Commit the navigation. The formerly pending RenderFrameHost should now be
   // the current RenderFrameHost and the WebContents should still be loading.
-  contents()->TestDidNavigate(pending_rfh, 1, kUrl2,
+  contents()->TestDidNavigate(pending_rfh, 1, entry->GetUniqueID(), true, kUrl2,
                               ui::PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->GetPendingMainFrame());
   TestRenderFrameHost* new_current_rfh = contents()->GetMainFrame();
   EXPECT_EQ(new_current_rfh, pending_rfh);
   EXPECT_TRUE(contents()->IsLoading());
 
   // Simulate the new current RenderFrameHost DidStopLoading. The WebContents
   // should now have stopped loading.
   new_current_rfh->OnMessageReceived(
       FrameHostMsg_DidStopLoading(new_current_rfh->GetRoutingID()));
@@ skipping 158 matching lines @@
   frame->SendBeforeUnloadHandlersPresent(false);
   EXPECT_FALSE(frame->SuddenTerminationAllowed());
   frame->SendBeforeUnloadHandlersPresent(true);
   frame->SendUnloadHandlersPresent(false);
   EXPECT_FALSE(frame->SuddenTerminationAllowed());
   frame->SendBeforeUnloadHandlersPresent(false);
   EXPECT_TRUE(frame->SuddenTerminationAllowed());
 }
 
 }  // namespace content