Ensure the NavigationHandle's nav entry ID is updated during transfers.

content/browser/frame_host/navigation_controller_impl_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/frame_host/navigation_controller_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 277 matching lines @@
   }
 
  private:
   // The number of times NavigationStateChanged has been called.
   int navigation_state_change_count_;
 
   // The number of times ShowRepostFormWarningDialog() was called.
   int repost_form_warning_count_;
 };
 
+// Observer that records the LoadCommittedDetails from the most recent commit.
+class LoadCommittedDetailsObserver : public WebContentsObserver {
+ public:
+  // Observes navigation for the specified |web_contents|.
+  explicit LoadCommittedDetailsObserver(WebContents* web_contents)
+      : WebContentsObserver(web_contents) {}
+
+  const LoadCommittedDetails& details() { return details_; }
+
+ private:
+  void DidNavigateAnyFrame(RenderFrameHost* render_frame_host,
+                           const LoadCommittedDetails& details,
+                           const FrameNavigateParams& params) override {
+    details_ = details;
+  }
+
+  LoadCommittedDetails details_;
+};
+
 // -----------------------------------------------------------------------------
 
 TEST_F(NavigationControllerTest, Defaults) {
   NavigationControllerImpl& controller = controller_impl();
 
   EXPECT_FALSE(controller.GetPendingEntry());
   EXPECT_FALSE(controller.GetVisibleEntry());
   EXPECT_FALSE(controller.GetLastCommittedEntry());
   EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
   EXPECT_EQ(controller.GetLastCommittedEntryIndex(), -1);
@@ skipping 93 matching lines @@
   GURL url_2("http://foo2.com");
 
   // Navigate inititally. This is the url that could erroneously be the visible
   // entry when url_1 fails.
   NavigateAndCommit(initial_url);
 
   // Set the pending entry as url_1 and receive the DidStartProvisionalLoad
   // message, creating the NavigationHandle.
   controller.LoadURL(url_1, Referrer(), ui::PAGE_TRANSITION_TYPED,
                      std::string());
-  EXPECT_EQ(controller.GetVisibleEntry()->GetURL(), url_1);
+  EXPECT_EQ(url_1, controller.GetVisibleEntry()->GetURL());

[Charlie Reis, 2016/03/14 18:48:50]

I also included changes to this test to list the expected value before the
actual value, since the test output was wrong when it failed in a previous
version of this CL.

   main_test_rfh()->SimulateNavigationStart(url_1);
-  EXPECT_EQ(controller.GetVisibleEntry()->GetURL(), url_1);
+  EXPECT_EQ(url_1, controller.GetVisibleEntry()->GetURL());
 
   // Navigate to url_2, aborting url_1 before the DidStartProvisionalLoad
   // message is received for url_2. Do not discard the pending entry for url_2
   // here.
   controller.LoadURL(url_2, Referrer(), ui::PAGE_TRANSITION_TYPED,
                      std::string());
-  EXPECT_EQ(controller.GetVisibleEntry()->GetURL(), url_2);
+  EXPECT_EQ(url_2, controller.GetVisibleEntry()->GetURL());
   main_test_rfh()->SimulateNavigationError(url_1, net::ERR_ABORTED);
-  EXPECT_EQ(controller.GetVisibleEntry()->GetURL(), url_2);
+  EXPECT_EQ(url_2, controller.GetVisibleEntry()->GetURL());
 
   // Get the DidStartProvisionalLoad message for url_2.
   main_test_rfh()->SimulateNavigationStart(url_2);
 
-  EXPECT_EQ(controller.GetVisibleEntry()->GetURL(), url_2);
+  EXPECT_EQ(url_2, controller.GetVisibleEntry()->GetURL());
 }
 
 TEST_F(NavigationControllerTest, LoadURL) {
   NavigationControllerImpl& controller = controller_impl();
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller);
 
   const GURL url1("http://foo1");
   const GURL url2("http://foo2");
 
@@ skipping 1419 matching lines @@
   params.did_create_new_entry = true;
   params.url = url2;
   params.transition = ui::PAGE_TRANSITION_SERVER_REDIRECT;
   params.redirects.push_back(GURL("http://foo1"));
   params.redirects.push_back(GURL("http://foo2"));
   params.should_update_history = false;
   params.gesture = NavigationGestureAuto;
   params.is_post = false;
   params.page_state = PageState::CreateFromURL(url2);
 
-  LoadCommittedDetails details;
-
-  EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), params,
-                                             &details));
+  main_test_rfh()->PrepareForCommit();
+  main_test_rfh()->SendNavigateWithParams(&params);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
   // Second request.
   controller.LoadURL(
       url1, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   entry_id = controller.GetPendingEntry()->GetUniqueID();
 
   EXPECT_TRUE(controller.GetPendingEntry());
   EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
   EXPECT_EQ(url1, controller.GetVisibleEntry()->GetURL());
 
   params.nav_entry_id = entry_id;
   params.did_create_new_entry = false;
 
   EXPECT_EQ(0U, notifications.size());
-  EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), params,
-                                             &details));
+  LoadCommittedDetailsObserver observer(contents());
+  main_test_rfh()->PrepareForCommit();
+  main_test_rfh()->SendNavigateWithParams(&params);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
-  EXPECT_TRUE(details.type == NAVIGATION_TYPE_SAME_PAGE);
+  EXPECT_EQ(NAVIGATION_TYPE_SAME_PAGE, observer.details().type);
   EXPECT_EQ(controller.GetEntryCount(), 1);
   EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
   EXPECT_TRUE(controller.GetLastCommittedEntry());
   EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
   EXPECT_FALSE(controller.GetPendingEntry());
   EXPECT_EQ(url2, controller.GetVisibleEntry()->GetURL());
 
   EXPECT_FALSE(controller.CanGoBack());
   EXPECT_FALSE(controller.CanGoForward());
 }
@@ skipping 23 matching lines @@
   params.did_create_new_entry = true;
   params.url = url2;
   params.transition = ui::PAGE_TRANSITION_SERVER_REDIRECT;
   params.redirects.push_back(GURL("http://foo1"));
   params.redirects.push_back(GURL("http://foo2"));
   params.should_update_history = false;
   params.gesture = NavigationGestureAuto;
   params.is_post = true;
   params.page_state = PageState::CreateFromURL(url2);
 
-  LoadCommittedDetails details;
-
-  EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), params,
-                                             &details));
+  main_test_rfh()->PrepareForCommit();
+  main_test_rfh()->SendNavigateWithParams(&params);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
   // Second request.
   controller.LoadURL(
       url1, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   entry_id = controller.GetPendingEntry()->GetUniqueID();
 
   EXPECT_TRUE(controller.GetPendingEntry());
   EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
   EXPECT_EQ(url1, controller.GetVisibleEntry()->GetURL());
 
   params.nav_entry_id = entry_id;
   params.did_create_new_entry = false;
   params.is_post = false;
 
   EXPECT_EQ(0U, notifications.size());
-  EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), params,
-                                             &details));
+  LoadCommittedDetailsObserver observer(contents());
+  main_test_rfh()->PrepareForCommit();
+  main_test_rfh()->SendNavigateWithParams(&params);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
-  EXPECT_TRUE(details.type == NAVIGATION_TYPE_SAME_PAGE);
+  EXPECT_EQ(NAVIGATION_TYPE_SAME_PAGE, observer.details().type);
   EXPECT_EQ(controller.GetEntryCount(), 1);
   EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
   EXPECT_TRUE(controller.GetLastCommittedEntry());
   EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
   EXPECT_FALSE(controller.GetPendingEntry());
   EXPECT_EQ(url2, controller.GetVisibleEntry()->GetURL());
   EXPECT_FALSE(controller.GetVisibleEntry()->GetHasPostData());
 
   EXPECT_FALSE(controller.CanGoBack());
   EXPECT_FALSE(controller.CanGoForward());
@@ skipping 23 matching lines @@
   params.did_create_new_entry = true;
   params.url = url2;
   params.transition = ui::PAGE_TRANSITION_SERVER_REDIRECT;
   params.redirects.push_back(GURL("http://foo1"));
   params.redirects.push_back(GURL("http://foo2"));
   params.should_update_history = false;
   params.gesture = NavigationGestureAuto;
   params.is_post = false;
   params.page_state = PageState::CreateFromURL(url2);
 
-  LoadCommittedDetails details;
+  LoadCommittedDetailsObserver observer(contents());
 
   EXPECT_EQ(0U, notifications.size());
-  EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), params,
-                                             &details));
+  main_test_rfh()->PrepareForCommit();
+  main_test_rfh()->SendNavigateWithParams(&params);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
-  EXPECT_TRUE(details.type == NAVIGATION_TYPE_NEW_PAGE);
+  EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, observer.details().type);
   EXPECT_EQ(controller.GetEntryCount(), 1);
   EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
   EXPECT_TRUE(controller.GetLastCommittedEntry());
   EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
   EXPECT_FALSE(controller.GetPendingEntry());
   EXPECT_EQ(url2, controller.GetVisibleEntry()->GetURL());
 
   EXPECT_FALSE(controller.CanGoBack());
   EXPECT_FALSE(controller.CanGoForward());
 }
@@ skipping 36 matching lines @@
   // ... and now the renderer sends a commit for the first navigation.
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   params.page_id = 0;
   params.nav_entry_id = entry_id1;
   params.intended_as_new_entry = true;
   params.did_create_new_entry = false;
   params.url = url1;
   params.transition = ui::PAGE_TRANSITION_TYPED;
   params.page_state = PageState::CreateFromURL(url1);
 
-  LoadCommittedDetails details;
+  LoadCommittedDetailsObserver observer(contents());
 
   main_test_rfh()->PrepareForCommit();
-  EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), params,
-                                             &details));
-  EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, details.type);
+  main_test_rfh()->SendNavigateWithParams(&params);
+  EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, observer.details().type);
 }
 
 // Tests navigation via link click within a subframe. A new navigation entry
 // should be created.
 TEST_F(NavigationControllerTest, NewSubframe) {
   NavigationControllerImpl& controller = controller_impl();
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller);
 
   const GURL url1("http://foo1");
   main_test_rfh()->NavigateAndCommitRendererInitiated(1, true, url1);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
   // Prereq: add a subframe with an initial auto-subframe navigation.
   main_test_rfh()->OnCreateChildFrame(
       process()->GetNextRoutingID(), blink::WebTreeScopeType::Document,
       std::string(), "uniqueName0", blink::WebSandboxFlags::None,
       blink::WebFrameOwnerProperties());
-  RenderFrameHostImpl* subframe =
-      contents()->GetFrameTree()->root()->child_at(0)->current_frame_host();
+  TestRenderFrameHost* subframe = static_cast<TestRenderFrameHost*>(
+      contents()->GetFrameTree()->root()->child_at(0)->current_frame_host());
   const GURL subframe_url("http://foo1/subframe");
   {
     FrameHostMsg_DidCommitProvisionalLoad_Params params;
     params.page_id = 1;
     params.nav_entry_id = 0;
     params.did_create_new_entry = false;
     params.url = subframe_url;
     params.transition = ui::PAGE_TRANSITION_AUTO_SUBFRAME;
     params.should_update_history = false;
     params.gesture = NavigationGestureUser;
     params.is_post = false;
     params.page_state = PageState::CreateFromURL(subframe_url);
 
     // Navigating should do nothing.
-    LoadCommittedDetails details;
-    EXPECT_FALSE(controller.RendererDidNavigate(subframe, params, &details));
+    subframe->PrepareForCommit();
+    subframe->SendNavigateWithParams(&params);
     EXPECT_EQ(0U, notifications.size());
   }
 
   // Now do a new navigation in the frame.
   const GURL url2("http://foo2");
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   params.page_id = 2;
   params.nav_entry_id = 0;
   params.did_create_new_entry = true;
   params.url = url2;
   params.transition = ui::PAGE_TRANSITION_MANUAL_SUBFRAME;
   params.should_update_history = false;
   params.gesture = NavigationGestureUser;
   params.is_post = false;
   params.page_state = PageState::CreateFromURL(url2);
 
-  LoadCommittedDetails details;
-  EXPECT_TRUE(controller.RendererDidNavigate(subframe, params, &details));
+  LoadCommittedDetailsObserver observer(contents());
+  subframe->PrepareForCommit();
+  subframe->SendNavigateWithParams(&params);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
-  EXPECT_EQ(url1, details.previous_url);
-  EXPECT_FALSE(details.is_in_page);
-  EXPECT_FALSE(details.is_main_frame);
+  EXPECT_EQ(url1, observer.details().previous_url);
+  EXPECT_FALSE(observer.details().is_in_page);
+  EXPECT_FALSE(observer.details().is_main_frame);
 
   // The new entry should be appended.
   NavigationEntryImpl* entry = controller.GetLastCommittedEntry();
   EXPECT_EQ(2, controller.GetEntryCount());
-  EXPECT_EQ(entry, details.entry);
+  EXPECT_EQ(entry, observer.details().entry);
 
   // New entry should refer to the new page, but the old URL (entries only
   // reflect the toplevel URL).
   EXPECT_EQ(url1, entry->GetURL());
   EXPECT_EQ(params.page_id, entry->GetPageID());
 
   // Verify subframe entries if they're enabled (e.g. in --site-per-process).
   if (SiteIsolationPolicy::UseSubframeNavigationEntries()) {
     // The entry should have a subframe FrameNavigationEntry.
     ASSERT_EQ(1U, entry->root_node()->children.size());
@@ skipping 15 matching lines @@
   const GURL url1("http://foo/1");
   main_test_rfh()->NavigateAndCommitRendererInitiated(1, true, url1);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
   // Add a subframe and navigate it.
   main_test_rfh()->OnCreateChildFrame(
       process()->GetNextRoutingID(), blink::WebTreeScopeType::Document,
       std::string(), "uniqueName0", blink::WebSandboxFlags::None,
       blink::WebFrameOwnerProperties());
-  RenderFrameHostImpl* subframe =
-      contents()->GetFrameTree()->root()->child_at(0)->current_frame_host();
+  TestRenderFrameHost* subframe = static_cast<TestRenderFrameHost*>(
+      contents()->GetFrameTree()->root()->child_at(0)->current_frame_host());
   const GURL url2("http://foo/2");
   {
     FrameHostMsg_DidCommitProvisionalLoad_Params params;
     params.page_id = 1;
     params.nav_entry_id = 0;
     params.did_create_new_entry = false;
     params.url = url2;
     params.transition = ui::PAGE_TRANSITION_AUTO_SUBFRAME;
     params.should_update_history = false;
     params.gesture = NavigationGestureUser;
     params.is_post = false;
     params.page_state = PageState::CreateFromURL(url2);
 
     // Navigating should do nothing.
-    LoadCommittedDetails details;
-    EXPECT_FALSE(controller.RendererDidNavigate(subframe, params, &details));
+    subframe->PrepareForCommit();
+    subframe->SendNavigateWithParams(&params);
     EXPECT_EQ(0U, notifications.size());
   }
 
   // There should still be only one entry.
   EXPECT_EQ(1, controller.GetEntryCount());
   NavigationEntryImpl* entry = controller.GetLastCommittedEntry();
   EXPECT_EQ(url1, entry->GetURL());
   EXPECT_EQ(1, entry->GetPageID());
   FrameNavigationEntry* root_entry = entry->root_node()->frame_entry.get();
   EXPECT_EQ(url1, root_entry->url());
 
   // Verify subframe entries if they're enabled (e.g. in --site-per-process).
   if (SiteIsolationPolicy::UseSubframeNavigationEntries()) {
     // The entry should now have a subframe FrameNavigationEntry.
     ASSERT_EQ(1U, entry->root_node()->children.size());
     FrameNavigationEntry* frame_entry =
         entry->root_node()->children[0]->frame_entry.get();
     EXPECT_EQ(url2, frame_entry->url());
   } else {
     // There are no subframe FrameNavigationEntries by default.
     EXPECT_EQ(0U, entry->root_node()->children.size());
   }
 
   // Add a second subframe and navigate.
   main_test_rfh()->OnCreateChildFrame(
       process()->GetNextRoutingID(), blink::WebTreeScopeType::Document,
       std::string(), "uniqueName1", blink::WebSandboxFlags::None,
       blink::WebFrameOwnerProperties());
-  RenderFrameHostImpl* subframe2 =
-      contents()->GetFrameTree()->root()->child_at(1)->current_frame_host();
+  TestRenderFrameHost* subframe2 = static_cast<TestRenderFrameHost*>(
+      contents()->GetFrameTree()->root()->child_at(1)->current_frame_host());
   const GURL url3("http://foo/3");
   {
     FrameHostMsg_DidCommitProvisionalLoad_Params params;
     params.page_id = 1;
     params.nav_entry_id = 0;
     params.did_create_new_entry = false;
     params.url = url3;
     params.transition = ui::PAGE_TRANSITION_AUTO_SUBFRAME;
     params.should_update_history = false;
     params.gesture = NavigationGestureUser;
     params.is_post = false;
     params.page_state = PageState::CreateFromURL(url3);
 
     // Navigating should do nothing.
-    LoadCommittedDetails details;
-    EXPECT_FALSE(controller.RendererDidNavigate(subframe2, params, &details));
+    subframe2->PrepareForCommit();
+    subframe2->SendNavigateWithParams(&params);
     EXPECT_EQ(0U, notifications.size());
   }
 
   // There should still be only one entry, mostly unchanged.
   EXPECT_EQ(1, controller.GetEntryCount());
   EXPECT_EQ(entry, controller.GetLastCommittedEntry());
   EXPECT_EQ(url1, entry->GetURL());
   EXPECT_EQ(1, entry->GetPageID());
   EXPECT_EQ(root_entry, entry->root_node()->frame_entry.get());
   EXPECT_EQ(url1, root_entry->url());
 
   // Verify subframe entries if they're enabled (e.g. in --site-per-process).
   if (SiteIsolationPolicy::UseSubframeNavigationEntries()) {
     // The entry should now have 2 subframe FrameNavigationEntries.
     ASSERT_EQ(2U, entry->root_node()->children.size());
     FrameNavigationEntry* new_frame_entry =
         entry->root_node()->children[1]->frame_entry.get();
     EXPECT_EQ(url3, new_frame_entry->url());
   } else {
     // There are no subframe FrameNavigationEntries by default.
     EXPECT_EQ(0U, entry->root_node()->children.size());
   }
 
   // Add a nested subframe and navigate.
   subframe->OnCreateChildFrame(process()->GetNextRoutingID(),
                                blink::WebTreeScopeType::Document, std::string(),
                                "uniqueName2", blink::WebSandboxFlags::None,
                                blink::WebFrameOwnerProperties());
-  RenderFrameHostImpl* subframe3 = contents()
-                                       ->GetFrameTree()
-                                       ->root()
-                                       ->child_at(0)
-                                       ->child_at(0)
-                                       ->current_frame_host();
+  TestRenderFrameHost* subframe3 =
+      static_cast<TestRenderFrameHost*>(contents()
+                                            ->GetFrameTree()
+                                            ->root()
+                                            ->child_at(0)
+                                            ->child_at(0)
+                                            ->current_frame_host());
   const GURL url4("http://foo/4");
   {
     FrameHostMsg_DidCommitProvisionalLoad_Params params;
     params.page_id = 1;
     params.nav_entry_id = 0;
     params.did_create_new_entry = false;
     params.url = url4;
     params.transition = ui::PAGE_TRANSITION_AUTO_SUBFRAME;
     params.should_update_history = false;
     params.gesture = NavigationGestureUser;
     params.is_post = false;
     params.page_state = PageState::CreateFromURL(url4);
 
     // Navigating should do nothing.
-    LoadCommittedDetails details;
-    EXPECT_FALSE(controller.RendererDidNavigate(subframe3, params, &details));
+    subframe3->PrepareForCommit();
+    subframe3->SendNavigateWithParams(&params);
     EXPECT_EQ(0U, notifications.size());
   }
 
   // There should still be only one entry, mostly unchanged.
   EXPECT_EQ(1, controller.GetEntryCount());
   EXPECT_EQ(entry, controller.GetLastCommittedEntry());
   EXPECT_EQ(url1, entry->GetURL());
   EXPECT_EQ(1, entry->GetPageID());
   EXPECT_EQ(root_entry, entry->root_node()->frame_entry.get());
   EXPECT_EQ(url1, root_entry->url());
@@ skipping 23 matching lines @@
   main_test_rfh()->NavigateAndCommitRendererInitiated(1, true, url1);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   NavigationEntry* entry1 = controller.GetLastCommittedEntry();
   navigation_entry_committed_counter_ = 0;
 
   // Prereq: add a subframe with an initial auto-subframe navigation.
   main_test_rfh()->OnCreateChildFrame(
       process()->GetNextRoutingID(), blink::WebTreeScopeType::Document,
       std::string(), "uniqueName0", blink::WebSandboxFlags::None,
       blink::WebFrameOwnerProperties());
-  RenderFrameHostImpl* subframe =
-      contents()->GetFrameTree()->root()->child_at(0)->current_frame_host();
+  TestRenderFrameHost* subframe = static_cast<TestRenderFrameHost*>(
+      contents()->GetFrameTree()->root()->child_at(0)->current_frame_host());
   const GURL subframe_url("http://foo1/subframe");
   {
     FrameHostMsg_DidCommitProvisionalLoad_Params params;
     params.page_id = 1;
     params.nav_entry_id = 0;
     params.did_create_new_entry = false;
     params.url = subframe_url;
     params.transition = ui::PAGE_TRANSITION_AUTO_SUBFRAME;
     params.should_update_history = false;
     params.gesture = NavigationGestureUser;
     params.is_post = false;
     params.page_state = PageState::CreateFromURL(subframe_url);
 
     // Navigating should do nothing.
-    LoadCommittedDetails details;
-    EXPECT_FALSE(controller.RendererDidNavigate(subframe, params, &details));
+    subframe->PrepareForCommit();
+    subframe->SendNavigateWithParams(&params);
     EXPECT_EQ(0U, notifications.size());
   }
 
   // First manual subframe navigation.
   const GURL url2("http://foo2");
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   params.page_id = 2;
   params.nav_entry_id = 0;
   params.did_create_new_entry = true;
   params.url = url2;
   params.transition = ui::PAGE_TRANSITION_MANUAL_SUBFRAME;
   params.should_update_history = false;
   params.gesture = NavigationGestureUser;
   params.is_post = false;
   params.page_state = PageState::CreateFromURL(url2);
 
   // This should generate a new entry.
-  LoadCommittedDetails details;
-  EXPECT_TRUE(controller.RendererDidNavigate(subframe, params, &details));
+  subframe->PrepareForCommit();
+  subframe->SendNavigateWithParams(&params);
   NavigationEntryImpl* entry2 = controller.GetLastCommittedEntry();
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
   EXPECT_EQ(2, controller.GetEntryCount());
 
   // Verify subframe entries if they're enabled (e.g. in --site-per-process).
   if (SiteIsolationPolicy::UseSubframeNavigationEntries()) {
     // The entry should have a subframe FrameNavigationEntry.
     ASSERT_EQ(1U, entry2->root_node()->children.size());
     EXPECT_EQ(url2, entry2->root_node()->children[0]->frame_entry->url());
   } else {
     // There are no subframe FrameNavigationEntries by default.
     EXPECT_EQ(0U, entry2->root_node()->children.size());
   }
 
   // Second manual subframe navigation should also make a new entry.
   const GURL url3("http://foo3");
   params.page_id = 3;
   params.nav_entry_id = 0;
   params.did_create_new_entry = true;
   params.url = url3;
   params.transition = ui::PAGE_TRANSITION_MANUAL_SUBFRAME;
   params.page_state = PageState::CreateFromURL(url3);
-  EXPECT_TRUE(controller.RendererDidNavigate(subframe, params, &details));
+  subframe->PrepareForCommit();
+  subframe->SendNavigateWithParams(&params);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
   NavigationEntryImpl* entry3 = controller.GetLastCommittedEntry();
   EXPECT_EQ(3, controller.GetEntryCount());
   EXPECT_EQ(2, controller.GetCurrentEntryIndex());
 
   // Verify subframe entries if they're enabled (e.g. in --site-per-process).
   if (SiteIsolationPolicy::UseSubframeNavigationEntries()) {
     // The entry should have a subframe FrameNavigationEntry.
     ASSERT_EQ(1U, entry3->root_node()->children.size());
     EXPECT_EQ(url3, entry3->root_node()->children[0]->frame_entry->url());
   } else {
     // There are no subframe FrameNavigationEntries by default.
     EXPECT_EQ(0U, entry3->root_node()->children.size());
   }
 
   // Go back one.
   controller.GoBack();
   params.page_id = 2;
   params.nav_entry_id = entry2->GetUniqueID();
   params.did_create_new_entry = false;
   params.url = url2;
   params.transition = ui::PAGE_TRANSITION_AUTO_SUBFRAME;
   params.page_state = PageState::CreateFromURL(url2);
-  EXPECT_TRUE(controller.RendererDidNavigate(subframe, params, &details));
+  subframe->PrepareForCommit();
+  subframe->SendNavigateWithParams(&params);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
   EXPECT_EQ(entry2, controller.GetLastCommittedEntry());
   EXPECT_EQ(3, controller.GetEntryCount());
   EXPECT_EQ(1, controller.GetCurrentEntryIndex());
   EXPECT_EQ(-1, controller.GetPendingEntryIndex());
   EXPECT_FALSE(controller.GetPendingEntry());
 
   // Go back one more.
   controller.GoBack();
   params.page_id = 1;
   params.nav_entry_id = entry1->GetUniqueID();
   params.did_create_new_entry = false;
   params.url = subframe_url;
   params.transition = ui::PAGE_TRANSITION_AUTO_SUBFRAME;
   params.page_state = PageState::CreateFromURL(subframe_url);
-  EXPECT_TRUE(controller.RendererDidNavigate(subframe, params, &details));
+  subframe->PrepareForCommit();
+  subframe->SendNavigateWithParams(&params);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
   EXPECT_EQ(entry1, controller.GetLastCommittedEntry());
   EXPECT_EQ(3, controller.GetEntryCount());
   EXPECT_EQ(0, controller.GetCurrentEntryIndex());
   EXPECT_EQ(-1, controller.GetPendingEntryIndex());
   EXPECT_FALSE(controller.GetPendingEntry());
 }
 
 TEST_F(NavigationControllerTest, LinkClick) {
@@ skipping 40 matching lines @@
   self_params.nav_entry_id = 0;
   self_params.did_create_new_entry = false;
   self_params.url = url1;
   self_params.transition = ui::PAGE_TRANSITION_LINK;
   self_params.should_update_history = false;
   self_params.gesture = NavigationGestureUser;
   self_params.is_post = false;
   self_params.page_state = PageState::CreateFromURL(url1);
   self_params.was_within_same_page = true;
 
-  LoadCommittedDetails details;
-  EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), self_params,
-                                             &details));
+  LoadCommittedDetailsObserver observer(contents());
+  main_test_rfh()->PrepareForCommit();
+  main_test_rfh()->SendNavigateWithParams(&self_params);
   NavigationEntry* entry1 = controller.GetLastCommittedEntry();
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
-  EXPECT_TRUE(details.is_in_page);
-  EXPECT_TRUE(details.did_replace_entry);
+  EXPECT_TRUE(observer.details().is_in_page);
+  EXPECT_TRUE(observer.details().did_replace_entry);
   EXPECT_EQ(1, controller.GetEntryCount());
 
   // Fragment navigation to a new page_id.
   const GURL url2("http://foo#a");
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   params.page_id = 1;
   params.nav_entry_id = 0;
   params.did_create_new_entry = true;
   params.url = url2;
   params.transition = ui::PAGE_TRANSITION_LINK;
   params.should_update_history = false;
   params.gesture = NavigationGestureUser;
   params.is_post = false;
   params.page_state = PageState::CreateFromURL(url2);
   params.was_within_same_page = true;
 
   // This should generate a new entry.
-  EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), params,
-                                             &details));
+  main_test_rfh()->PrepareForCommit();
+  main_test_rfh()->SendNavigateWithParams(&params);
   NavigationEntry* entry2 = controller.GetLastCommittedEntry();
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
-  EXPECT_TRUE(details.is_in_page);
-  EXPECT_FALSE(details.did_replace_entry);
+  EXPECT_TRUE(observer.details().is_in_page);
+  EXPECT_FALSE(observer.details().did_replace_entry);
   EXPECT_EQ(2, controller.GetEntryCount());
 
   // Go back one.
   FrameHostMsg_DidCommitProvisionalLoad_Params back_params(params);
   controller.GoBack();
   back_params.url = url1;
   back_params.page_id = 0;
   back_params.nav_entry_id = entry1->GetUniqueID();
   back_params.did_create_new_entry = false;
-  EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), back_params,
-                                             &details));
+  main_test_rfh()->PrepareForCommit();
+  main_test_rfh()->SendNavigateWithParams(&back_params);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
-  EXPECT_TRUE(details.is_in_page);
+  EXPECT_TRUE(observer.details().is_in_page);
   EXPECT_EQ(2, controller.GetEntryCount());
   EXPECT_EQ(0, controller.GetCurrentEntryIndex());
   EXPECT_EQ(back_params.url, controller.GetVisibleEntry()->GetURL());
 
   // Go forward.
   FrameHostMsg_DidCommitProvisionalLoad_Params forward_params(params);
   controller.GoForward();
   forward_params.url = url2;
   forward_params.page_id = 1;
   forward_params.nav_entry_id = entry2->GetUniqueID();
   forward_params.did_create_new_entry = false;
-  EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), forward_params,
-                                             &details));
+  main_test_rfh()->PrepareForCommit();
+  main_test_rfh()->SendNavigateWithParams(&forward_params);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
-  EXPECT_TRUE(details.is_in_page);
+  EXPECT_TRUE(observer.details().is_in_page);
   EXPECT_EQ(2, controller.GetEntryCount());
   EXPECT_EQ(1, controller.GetCurrentEntryIndex());
   EXPECT_EQ(forward_params.url,
             controller.GetVisibleEntry()->GetURL());
 
   // Now go back and forward again. This is to work around a bug where we would
   // compare the incoming URL with the last committed entry rather than the
   // one identified by an existing page ID. This would result in the second URL
   // losing the reference fragment when you navigate away from it and then back.
   controller.GoBack();
-  EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), back_params,
-                                             &details));
+  main_test_rfh()->PrepareForCommit();
+  main_test_rfh()->SendNavigateWithParams(&back_params);
   controller.GoForward();
-  EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), forward_params,
-                                             &details));
+  main_test_rfh()->PrepareForCommit();
+  main_test_rfh()->SendNavigateWithParams(&forward_params);
   EXPECT_EQ(forward_params.url,
             controller.GetVisibleEntry()->GetURL());
 
   // Finally, navigate to an unrelated URL to make sure in_page is not sticky.
   const GURL url3("http://bar");
   params.page_id = 2;
   params.nav_entry_id = 0;
   params.did_create_new_entry = true;
   params.url = url3;
   navigation_entry_committed_counter_ = 0;
-  EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), params,
-                                             &details));
+  main_test_rfh()->PrepareForCommit();
+  main_test_rfh()->SendNavigateWithParams(&params);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
-  EXPECT_FALSE(details.is_in_page);
+  EXPECT_FALSE(observer.details().is_in_page);
   EXPECT_EQ(3, controller.GetEntryCount());
   EXPECT_EQ(2, controller.GetCurrentEntryIndex());
 }
 
 TEST_F(NavigationControllerTest, InPage_Replace) {
   NavigationControllerImpl& controller = controller_impl();
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller);
 
   // Main page.
@@ skipping 10 matching lines @@
   params.did_create_new_entry = false;
   params.url = url2;
   params.transition = ui::PAGE_TRANSITION_LINK;
   params.should_update_history = false;
   params.gesture = NavigationGestureUser;
   params.is_post = false;
   params.page_state = PageState::CreateFromURL(url2);
   params.was_within_same_page = true;
 
   // This should NOT generate a new entry, nor prune the list.
-  LoadCommittedDetails details;
-  EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), params,
-                                             &details));
+  LoadCommittedDetailsObserver observer(contents());
+  main_test_rfh()->PrepareForCommit();
+  main_test_rfh()->SendNavigateWithParams(&params);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
-  EXPECT_TRUE(details.is_in_page);
-  EXPECT_TRUE(details.did_replace_entry);
+  EXPECT_TRUE(observer.details().is_in_page);
+  EXPECT_TRUE(observer.details().did_replace_entry);
   EXPECT_EQ(1, controller.GetEntryCount());
 }
 
 // Tests for http://crbug.com/40395
 // Simulates this:
 //   <script>
 //     window.location.replace("#a");
 //     window.location='http://foo3/';
 //   </script>
 TEST_F(NavigationControllerTest, ClientRedirectAfterInPageNavigation) {
@@ skipping 27 matching lines @@
     params.url = url;
     params.transition = ui::PAGE_TRANSITION_LINK;
     params.redirects.push_back(url);
     params.should_update_history = true;
     params.gesture = NavigationGestureUnknown;
     params.is_post = false;
     params.page_state = PageState::CreateFromURL(url);
     params.was_within_same_page = true;
 
     // This should NOT generate a new entry, nor prune the list.
-    LoadCommittedDetails details;
-    EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), params,
-                                               &details));
+    LoadCommittedDetailsObserver observer(contents());
+    main_test_rfh()->PrepareForCommit();
+    main_test_rfh()->SendNavigateWithParams(&params);
     EXPECT_EQ(1U, navigation_entry_committed_counter_);
     navigation_entry_committed_counter_ = 0;
-    EXPECT_TRUE(details.is_in_page);
-    EXPECT_TRUE(details.did_replace_entry);
+    EXPECT_TRUE(observer.details().is_in_page);
+    EXPECT_TRUE(observer.details().did_replace_entry);
     EXPECT_EQ(2, controller.GetEntryCount());
   }
 
   // Perform a client redirect to a new page.
   {
     const GURL url("http://foo3/");
     FrameHostMsg_DidCommitProvisionalLoad_Params params;
     params.page_id = 2;  // New page_id
     params.nav_entry_id = 0;
     params.did_create_new_entry = true;
     params.url = url;
     params.transition = ui::PAGE_TRANSITION_CLIENT_REDIRECT;
     params.redirects.push_back(GURL("http://foo2/#a"));
     params.redirects.push_back(url);
     params.should_update_history = true;
     params.gesture = NavigationGestureUnknown;
     params.is_post = false;
     params.page_state = PageState::CreateFromURL(url);
 
     // This SHOULD generate a new entry.
-    LoadCommittedDetails details;
-    EXPECT_TRUE(controller.RendererDidNavigate(main_test_rfh(), params,
-                                               &details));
+    LoadCommittedDetailsObserver observer(contents());
+    main_test_rfh()->PrepareForCommit();
+    main_test_rfh()->SendNavigateWithParams(&params);
     EXPECT_EQ(1U, navigation_entry_committed_counter_);
     navigation_entry_committed_counter_ = 0;
-    EXPECT_FALSE(details.is_in_page);
+    EXPECT_FALSE(observer.details().is_in_page);
     EXPECT_EQ(3, controller.GetEntryCount());
   }
 
   // Verify that BACK brings us back to http://foo2/.
   {
     const GURL url("http://foo2/");
     controller.GoBack();
     int entry_id = controller.GetPendingEntry()->GetUniqueID();
     main_test_rfh()->PrepareForCommit();
     main_test_rfh()->SendNavigate(1, entry_id, false, url);
@@ skipping 158 matching lines @@
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   params.page_id = 0;
   params.nav_entry_id = our_controller.GetPendingEntry()->GetUniqueID();
   params.did_create_new_entry = false;
   params.url = url;
   params.transition = ui::PAGE_TRANSITION_LINK;
   params.should_update_history = false;
   params.gesture = NavigationGestureUser;
   params.is_post = false;
   params.page_state = PageState::CreateFromURL(url);
-  LoadCommittedDetails details;
-  our_controller.RendererDidNavigate(our_contents->GetMainFrame(), params,
-                                     &details);
+  TestRenderFrameHost* main_rfh =
+      static_cast<TestRenderFrameHost*>(our_contents->GetMainFrame());
+  main_rfh->PrepareForCommit();
+  main_rfh->SendNavigateWithParams(&params);
 
   // There should be no longer any pending entry and one committed one. This
   // means that we were able to locate the entry, assign its site instance, and
   // commit it properly.
   EXPECT_EQ(1, our_controller.GetEntryCount());
   EXPECT_EQ(0, our_controller.GetLastCommittedEntryIndex());
   EXPECT_FALSE(our_controller.GetPendingEntry());
   EXPECT_EQ(
       url,
       our_controller.GetLastCommittedEntry()->site_instance()->GetSiteURL());
@@ skipping 59 matching lines @@
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   params.page_id = 0;
   params.nav_entry_id = entry->GetUniqueID();
   params.did_create_new_entry = false;
   params.url = url;
   params.transition = ui::PAGE_TRANSITION_LINK;
   params.should_update_history = false;
   params.gesture = NavigationGestureUser;
   params.is_post = false;
   params.page_state = PageState::CreateFromURL(url);
-  LoadCommittedDetails details;
-  our_controller.RendererDidNavigate(our_contents->GetMainFrame(), params,
-                                     &details);
+  TestRenderFrameHost* main_rfh =
+      static_cast<TestRenderFrameHost*>(our_contents->GetMainFrame());
+  main_rfh->PrepareForCommit();
+  main_rfh->SendNavigateWithParams(&params);
 
   // There should be no pending entry and one committed one.
   EXPECT_EQ(1, our_controller.GetEntryCount());
   EXPECT_EQ(0, our_controller.GetLastCommittedEntryIndex());
   EXPECT_FALSE(our_controller.GetPendingEntry());
   EXPECT_EQ(
       url,
       our_controller.GetLastCommittedEntry()->site_instance()->GetSiteURL());
   EXPECT_EQ(NavigationEntryImpl::RESTORE_NONE,
             our_controller.GetEntryAtIndex(0)->restore_type());
@@ skipping 784 matching lines @@
 
   // We should be at the first navigation entry.
   EXPECT_EQ(controller.GetEntryCount(), 1);
   EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
 
   // Add and navigate a subframe that would normally count as in-page.
   main_test_rfh()->OnCreateChildFrame(
       process()->GetNextRoutingID(), blink::WebTreeScopeType::Document,
       std::string(), "uniqueName0", blink::WebSandboxFlags::None,
       blink::WebFrameOwnerProperties());
-  RenderFrameHostImpl* subframe =
-      contents()->GetFrameTree()->root()->child_at(0)->current_frame_host();
+  TestRenderFrameHost* subframe = static_cast<TestRenderFrameHost*>(
+      contents()->GetFrameTree()->root()->child_at(0)->current_frame_host());
   const GURL subframe_url("http://www.google.com/#");
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   params.page_id = 0;
   params.nav_entry_id = 0;
   params.did_create_new_entry = false;
   params.url = subframe_url;
   params.transition = ui::PAGE_TRANSITION_AUTO_SUBFRAME;
   params.should_update_history = false;
   params.gesture = NavigationGestureAuto;
   params.is_post = false;
   params.page_state = PageState::CreateFromURL(subframe_url);
-  LoadCommittedDetails details;
-  EXPECT_FALSE(controller.RendererDidNavigate(subframe, params, &details));
+  subframe->PrepareForCommit();
+  subframe->SendNavigateWithParams(&params);
 
   // Nothing should have changed.
   EXPECT_EQ(controller.GetEntryCount(), 1);
   EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
 }
 
 // Make sure that on cloning a WebContentsImpl and going back needs_reload is
 // false.
 TEST_F(NavigationControllerTest, CloneAndGoBack) {
   NavigationControllerImpl& controller = controller_impl();
@@ skipping 132 matching lines @@
   const GURL url2("http://bar/");
   controller.LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
 
   // Send a subframe update from the first page, as if one had just
   // automatically loaded. Auto subframes don't increment the page ID.
   main_test_rfh()->OnCreateChildFrame(
       process()->GetNextRoutingID(), blink::WebTreeScopeType::Document,
       std::string(), "uniqueName0", blink::WebSandboxFlags::None,
       blink::WebFrameOwnerProperties());
-  RenderFrameHostImpl* subframe =
-      contents()->GetFrameTree()->root()->child_at(0)->current_frame_host();
+  TestRenderFrameHost* subframe = static_cast<TestRenderFrameHost*>(
+      contents()->GetFrameTree()->root()->child_at(0)->current_frame_host());
   const GURL url1_sub("http://foo/subframe");
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   params.page_id = controller.GetLastCommittedEntry()->GetPageID();
   params.nav_entry_id = 0;
   params.did_create_new_entry = false;
   params.url = url1_sub;
   params.transition = ui::PAGE_TRANSITION_AUTO_SUBFRAME;
   params.should_update_history = false;
   params.gesture = NavigationGestureAuto;
   params.is_post = false;
   params.page_state = PageState::CreateFromURL(url1_sub);
-  LoadCommittedDetails details;
 
   // This should return false meaning that nothing was actually updated.
-  EXPECT_FALSE(controller.RendererDidNavigate(subframe, params, &details));
+  subframe->PrepareForCommit();
+  subframe->SendNavigateWithParams(&params);
 
   // The notification should have updated the last committed one, and not
   // the pending load.
   EXPECT_EQ(url1, controller.GetLastCommittedEntry()->GetURL());
 
   // The active entry should be unchanged by the subframe load.
   EXPECT_EQ(url2, controller.GetVisibleEntry()->GetURL());
 }
 
 // Test CopyStateFrom with 2 urls, the first selected and nothing in the target.
@@ skipping 1038 matching lines @@
   contents()->GetMainFrame()->SendNavigateWithParams(&params);
 
   // Now reload. replaceState overrides the POST, so we should not show a
   // repost warning dialog.
   controller_impl().Reload(true);
   EXPECT_EQ(0, delegate->repost_form_warning_count());
 }
 
 TEST_F(NavigationControllerTest, UnreachableURLGivesErrorPage) {
   GURL url("http://foo");
+  controller().LoadURL(url, Referrer(), ui::PAGE_TRANSITION_TYPED,
+                       std::string());
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   params.page_id = 1;
   params.nav_entry_id = 0;
   params.did_create_new_entry = true;
   params.url = url;
   params.transition = ui::PAGE_TRANSITION_LINK;
   params.gesture = NavigationGestureUser;
   params.page_state = PageState::CreateFromURL(url);
   params.was_within_same_page = false;
   params.is_post = true;
   params.post_id = 2;
   params.url_is_unreachable = true;
 
   // Navigate to new page.
   {
-    LoadCommittedDetails details;
-    controller_impl().RendererDidNavigate(main_test_rfh(), params, &details);
+    LoadCommittedDetailsObserver observer(contents());
+    main_test_rfh()->PrepareForCommit();
+    main_test_rfh()->SendNavigateWithParams(&params);
     EXPECT_EQ(PAGE_TYPE_ERROR,
               controller_impl().GetLastCommittedEntry()->GetPageType());
-    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, details.type);
+    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, observer.details().type);
   }
 
   // Navigate to existing page.
   {
     params.did_create_new_entry = false;
-    LoadCommittedDetails details;
-    controller_impl().RendererDidNavigate(main_test_rfh(), params, &details);
+    LoadCommittedDetailsObserver observer(contents());
+    main_test_rfh()->PrepareForCommit();
+    main_test_rfh()->SendNavigateWithParams(&params);
     EXPECT_EQ(PAGE_TYPE_ERROR,
               controller_impl().GetLastCommittedEntry()->GetPageType());
-    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, details.type);
+    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, observer.details().type);
   }
 
   // Navigate to same page.
   // Note: The call to LoadURL() creates a pending entry in order to trigger the
   // same-page transition.
   controller_impl().LoadURL(
       url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   params.nav_entry_id = controller_impl().GetPendingEntry()->GetUniqueID();
   params.transition = ui::PAGE_TRANSITION_TYPED;
   {
-    LoadCommittedDetails details;
-    controller_impl().RendererDidNavigate(main_test_rfh(), params, &details);
+    LoadCommittedDetailsObserver observer(contents());
+    main_test_rfh()->PrepareForCommit();
+    main_test_rfh()->SendNavigateWithParams(&params);
     EXPECT_EQ(PAGE_TYPE_ERROR,
               controller_impl().GetLastCommittedEntry()->GetPageType());
-    EXPECT_EQ(NAVIGATION_TYPE_SAME_PAGE, details.type);
+    EXPECT_EQ(NAVIGATION_TYPE_SAME_PAGE, observer.details().type);
   }
 
   // Navigate in page.
   params.url = GURL("http://foo#foo");
   params.transition = ui::PAGE_TRANSITION_LINK;
   params.was_within_same_page = true;
   {
-    LoadCommittedDetails details;
-    controller_impl().RendererDidNavigate(main_test_rfh(), params, &details);
+    LoadCommittedDetailsObserver observer(contents());
+    main_test_rfh()->PrepareForCommit();
+    main_test_rfh()->SendNavigateWithParams(&params);
     EXPECT_EQ(PAGE_TYPE_ERROR,
               controller_impl().GetLastCommittedEntry()->GetPageType());
-    EXPECT_TRUE(details.is_in_page);
+    EXPECT_TRUE(observer.details().is_in_page);
   }
 }
 
 // Tests that if a stale navigation comes back from the renderer, it is properly
 // resurrected.
 TEST_F(NavigationControllerTest, StaleNavigationsResurrected) {
   NavigationControllerImpl& controller = controller_impl();
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller);
 
@@ skipping 50 matching lines @@
   EXPECT_EQ(url_a, controller.GetEntryAtIndex(0)->GetURL());
   EXPECT_EQ(url_c, controller.GetEntryAtIndex(1)->GetURL());
   EXPECT_EQ(url_b, controller.GetEntryAtIndex(2)->GetURL());
 }
 
 // Test that if a renderer provides bogus security info (that fails to
 // deserialize properly) when reporting a navigation, the renderer gets
 // killed.
 TEST_F(NavigationControllerTest, RendererNavigateBogusSecurityInfo) {
   GURL url("http://foo.test");
+  controller().LoadURL(url, Referrer(), ui::PAGE_TRANSITION_TYPED,
+                       std::string());
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   params.page_id = 0;
   params.nav_entry_id = 0;
   params.did_create_new_entry = true;
   params.url = url;
   params.transition = ui::PAGE_TRANSITION_LINK;
   params.should_update_history = true;
   params.gesture = NavigationGestureUser;
   params.is_post = false;
   params.page_state = PageState::CreateFromURL(url);
   params.was_within_same_page = false;
   params.security_info = "bogus security info!";
 
-  LoadCommittedDetails details;
+  LoadCommittedDetailsObserver observer(contents());
   EXPECT_EQ(0, main_test_rfh()->GetProcess()->bad_msg_count());
-  EXPECT_TRUE(
-      controller_impl().RendererDidNavigate(main_test_rfh(), params, &details));
+  main_test_rfh()->PrepareForCommit();
+  main_test_rfh()->SendNavigateWithParams(&params);
 
   SSLStatus default_ssl_status;
   EXPECT_EQ(default_ssl_status.security_style,
-            details.ssl_status.security_style);
-  EXPECT_EQ(default_ssl_status.cert_id, details.ssl_status.cert_id);
-  EXPECT_EQ(default_ssl_status.cert_status, details.ssl_status.cert_status);
-  EXPECT_EQ(default_ssl_status.security_bits, details.ssl_status.security_bits);
+            observer.details().ssl_status.security_style);
+  EXPECT_EQ(default_ssl_status.cert_id, observer.details().ssl_status.cert_id);
+  EXPECT_EQ(default_ssl_status.cert_status,
+            observer.details().ssl_status.cert_status);
+  EXPECT_EQ(default_ssl_status.security_bits,
+            observer.details().ssl_status.security_bits);
   EXPECT_EQ(default_ssl_status.connection_status,
-            details.ssl_status.connection_status);
+            observer.details().ssl_status.connection_status);
   EXPECT_EQ(default_ssl_status.content_status,
-            details.ssl_status.content_status);
-  EXPECT_EQ(0u, details.ssl_status.signed_certificate_timestamp_ids.size());
+            observer.details().ssl_status.content_status);
+  EXPECT_EQ(
+      0u,
+      observer.details().ssl_status.signed_certificate_timestamp_ids.size());
 
   EXPECT_EQ(1, main_test_rfh()->GetProcess()->bad_msg_count());
 }
 
 }  // namespace content