PlzNavigate: add support in several navigation controller unit tests

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 "base/basictypes.h"
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "content/browser/frame_host/cross_site_transferring_request.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/frame_host/navigation_entry_screenshot_manager.h"
 #include "content/browser/frame_host/navigator.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/frame_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
+#include "content/public/common/content_switches.h"
 #include "content/public/common/page_state.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_notification_tracker.h"
 #include "content/public/test/test_utils.h"
 #include "content/test/test_render_frame_host.h"
 #include "content/test/test_render_view_host.h"
 #include "content/test/test_web_contents.h"
 #include "net/base/net_util.h"
 #include "skia/ext/platform_canvas.h"
@@ skipping 329 matching lines @@
   EXPECT_FALSE(controller.CanGoForward());
   EXPECT_EQ(contents()->GetMaxPageID(), -1);
 
   // Neither the timestamp nor the status code should have been set yet.
   EXPECT_TRUE(controller.GetPendingEntry()->GetTimestamp().is_null());
   EXPECT_EQ(0, controller.GetPendingEntry()->GetHttpStatusCode());
 
   // We should have gotten no notifications from the preceeding checks.
   EXPECT_EQ(0U, notifications.size());
 
-  main_test_rfh()->SendNavigate(0, url1);
+  contents()->CommitNavigationWithPageID(0, url1, false);

[nasko, 2014/12/11 00:51:45]

Why do we have false in this case?

   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
   // The load should now be committed.
   EXPECT_EQ(controller.GetEntryCount(), 1);
   EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
   EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
   EXPECT_TRUE(controller.GetLastCommittedEntry());
   EXPECT_FALSE(controller.GetPendingEntry());
   ASSERT_TRUE(controller.GetVisibleEntry());
@@ skipping 19 matching lines @@
   EXPECT_EQ(controller.GetPendingEntry(), controller.GetVisibleEntry());
   // TODO(darin): maybe this should really be true?
   EXPECT_FALSE(controller.CanGoBack());
   EXPECT_FALSE(controller.CanGoForward());
   EXPECT_EQ(contents()->GetMaxPageID(), 0);
 
   EXPECT_TRUE(controller.GetPendingEntry()->GetTimestamp().is_null());
 
   // Simulate the beforeunload ack for the cross-site transition, and then the
   // commit.
-  main_test_rfh()->SendBeforeUnloadACK(true);
-  contents()->GetPendingMainFrame()->SendNavigate(1, url2);
+  contents()->CommitNavigationWithPageID(1, url2, true);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
   // The load should now be committed.
   EXPECT_EQ(controller.GetEntryCount(), 2);
   EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 1);
   EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
   EXPECT_TRUE(controller.GetLastCommittedEntry());
   EXPECT_FALSE(controller.GetPendingEntry());
   ASSERT_TRUE(controller.GetVisibleEntry());
@@ skipping 305 matching lines @@
 // commits.
 TEST_F(NavigationControllerTest, LoadURL_NewPending) {
   NavigationControllerImpl& controller = controller_impl();
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller);
 
   // First make an existing committed entry.
   const GURL kExistingURL1("http://eh");
   controller.LoadURL(
       kExistingURL1, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
-  main_test_rfh()->SendNavigate(0, kExistingURL1);
+  contents()->CommitPendingNavigation();
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
   // Make a pending entry to somewhere new.
   const GURL kExistingURL2("http://bee");
   controller.LoadURL(
       kExistingURL2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_EQ(0U, notifications.size());
 
   // After the beforeunload but before it commits, do a new navigation.
-  main_test_rfh()->SendBeforeUnloadACK(true);
+  contents()->ProceedNavigationWithRendererResponse(kExistingURL2);
   const GURL kNewURL("http://see");
-  contents()->GetPendingMainFrame()->SendNavigate(3, kNewURL);
+  contents()->SimulateRendererInitiatedNavigation(3, kNewURL);
 
   // There should no longer be any pending entry, and the third navigation we
   // just made should be committed.
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
   EXPECT_EQ(-1, controller.GetPendingEntryIndex());
   EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(kNewURL, controller.GetVisibleEntry()->GetURL());
 }
 
@@ skipping 22 matching lines @@
 
   // Now make a pending back/forward navigation. The zeroth entry should be
   // pending.
   controller.GoBack();
   EXPECT_EQ(0U, notifications.size());
   EXPECT_EQ(0, controller.GetPendingEntryIndex());
   EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
 
   // Before that commits, do a new navigation.
   const GURL kNewURL("http://foo/see");
   LoadCommittedDetails details;

[nasko, 2014/12/11 00:51:45]

drive-by nit: It looks like details isn't used anymore and can be cleaned up. It
appears in a few places in this file.

[clamy, 2014/12/15 17:01:38]

Done.

   main_test_rfh()->SendNavigate(3, kNewURL);
 
   // There should no longer be any pending entry, and the third navigation we
   // just made should be committed.
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
   EXPECT_EQ(-1, controller.GetPendingEntryIndex());
   EXPECT_EQ(2, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(kNewURL, controller.GetVisibleEntry()->GetURL());
 }
 
 // Tests navigating to a new URL when there is a pending back/forward
 // navigation to a cross-process, privileged URL. This will happen if the user
 // hits back, but before that commits, they navigate somewhere new.
 TEST_F(NavigationControllerTest, LoadURL_PrivilegedPending) {
   NavigationControllerImpl& controller = controller_impl();
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller);
 
   // First make some history, starting with a privileged URL.
   const GURL kExistingURL1("http://privileged");
   controller.LoadURL(
       kExistingURL1, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   // Pretend it has bindings so we can tell if we incorrectly copy it.
-  main_test_rfh()->GetRenderViewHost()->AllowBindings(2);
-  main_test_rfh()->SendNavigate(0, kExistingURL1);
+  contents()->CommitPendingNavigationWithBindings(2, false);

[nasko, 2014/12/11 00:51:45]

As I'm reading through these changes, it seems like we are losing the capability
to perform those navigation operations on the FTN/RFH level. If we want to test
subframe navigations, which I believe we will want to add more tests for, the
way the code in this patch is written won't allow for it.

[clamy, 2014/12/15 17:01:39]

Done.

   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
   // Navigate cross-process to a second URL.
   const GURL kExistingURL2("http://foo/eh");
   controller.LoadURL(
       kExistingURL2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
-  main_test_rfh()->SendBeforeUnloadACK(true);
-  TestRenderFrameHost* foo_rfh = contents()->GetPendingMainFrame();
-  foo_rfh->SendNavigate(1, kExistingURL2);
+  contents()->CommitPendingNavigation();
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
   // Now make a pending back/forward navigation to a privileged entry.
   // The zeroth entry should be pending.
   controller.GoBack();
-  foo_rfh->SendBeforeUnloadACK(true);
+  contents()->ProceedNavigationWithRendererResponse(kExistingURL1);
   EXPECT_EQ(0U, notifications.size());
   EXPECT_EQ(0, controller.GetPendingEntryIndex());
   EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(2, NavigationEntryImpl::FromNavigationEntry(
                 controller.GetPendingEntry())->bindings());
 
   // Before that commits, do a new navigation.
   const GURL kNewURL("http://foo/bee");
   LoadCommittedDetails details;
-  foo_rfh->SendNavigate(3, kNewURL);
+  contents()->SimulateRendererInitiatedNavigation(3, kNewURL);
 
   // There should no longer be any pending entry, and the third navigation we
   // just made should be committed.
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
   EXPECT_EQ(-1, controller.GetPendingEntryIndex());
   EXPECT_EQ(2, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(kNewURL, controller.GetVisibleEntry()->GetURL());
   EXPECT_EQ(0, NavigationEntryImpl::FromNavigationEntry(
                 controller.GetLastCommittedEntry())->bindings());
@@ skipping 214 matching lines @@
 
   // Navigate to a first, unprivileged URL.
   controller.LoadURL(
       url1, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_EQ(NavigationEntryImpl::kInvalidBindings,
             NavigationEntryImpl::FromNavigationEntry(
                 controller.GetPendingEntry())->bindings());
 
   // Commit.
   TestRenderFrameHost* orig_rfh = contents()->GetMainFrame();
-  orig_rfh->SendNavigate(0, url1);
+  contents()->CommitPendingNavigationNoLiveRenderer();
   EXPECT_EQ(controller.GetEntryCount(), 1);
   EXPECT_EQ(0, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(0, NavigationEntryImpl::FromNavigationEntry(
       controller.GetLastCommittedEntry())->bindings());
 
   // Manually increase the number of active frames in the SiteInstance
   // that orig_rfh belongs to, to prevent it from being destroyed when
   // it gets swapped out, so that we can reuse orig_rfh when the
   // controller goes back.
   orig_rfh->GetSiteInstance()->increment_active_frame_count();
 
   // Navigate to a second URL, simulate the beforeunload ack for the cross-site
   // transition, and set bindings on the pending RenderViewHost to simulate a
   // privileged url.
   controller.LoadURL(
       url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
-  orig_rfh->SendBeforeUnloadACK(true);
-  TestRenderFrameHost* new_rfh = contents()->GetPendingMainFrame();
-  new_rfh->GetRenderViewHost()->AllowBindings(1);
-  new_rfh->SendNavigate(1, url2);
+  contents()->CommitPendingNavigationWithBindings(1, true);
 
   // The second load should be committed, and bindings should be remembered.
   EXPECT_EQ(controller.GetEntryCount(), 2);
   EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
   EXPECT_TRUE(controller.CanGoBack());
   EXPECT_EQ(1, NavigationEntryImpl::FromNavigationEntry(
       controller.GetLastCommittedEntry())->bindings());
 
   // Going back, the first entry should still appear unprivileged.
   controller.GoBack();
-  new_rfh->SendBeforeUnloadACK(true);
-  orig_rfh->SendNavigate(0, url1);
+  contents()->CommitPendingNavigation();
   EXPECT_EQ(0, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(0, NavigationEntryImpl::FromNavigationEntry(
       controller.GetLastCommittedEntry())->bindings());
 }
 
 TEST_F(NavigationControllerTest, Reload) {
   NavigationControllerImpl& controller = controller_impl();
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller);
 
@@ skipping 2740 matching lines @@
   scoped_ptr<TestWebContents> source_contents(
       static_cast<TestWebContents*>(CreateTestWebContents()));
   NavigationControllerImpl& source_controller =
       source_contents->GetController();
   source_controller.Restore(
       entries.size() - 1,
       NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY,
       &entries);
   ASSERT_EQ(0u, entries.size());
   source_controller.LoadIfNecessary();
-  source_contents->CommitPendingNavigation();
+  source_contents->CommitPendingNavigationNoLiveRenderer();
 
   // Load a page, then copy state from |source_contents|.
   NavigateAndCommit(kInitialUrl);
   contents()->ExpectSetHistoryLengthAndPrune(
       GetSiteInstanceFromEntry(controller_impl().GetEntryAtIndex(0)), 2,
       controller_impl().GetEntryAtIndex(0)->GetPageID());
   controller_impl().CopyStateFromAndPrune(&source_controller, false);
   ASSERT_EQ(3, controller_impl().GetEntryCount());
 
   // Go back to the first entry one at a time and
@@ skipping 18 matching lines @@
   NavigationControllerImpl& controller = controller_impl();
   const GURL url1("http://foo/1");
   const GURL url2("http://foo/2");
   const GURL url3("http://foo/3");
 
   NavigateAndCommit(url1);
   NavigateAndCommit(url2);
   NavigateAndCommit(url3);
   controller.GoBack();
   contents()->CommitPendingNavigation();
+  process()->sink().ClearMessages();
 
   // Simulate the page calling history.back(). It should create a pending entry.
   contents()->OnGoToEntryAtOffset(-1);
   EXPECT_EQ(0, controller.GetPendingEntryIndex());
   // The actual cross-navigation is suspended until the current RVH tells us
   // it unloaded, simulate that.
-  contents()->ProceedWithCrossSiteNavigation();
+  contents()->ProceedNavigationWithRendererResponse(url1);
   // Also make sure we told the page to navigate.
-  const IPC::Message* message =
-      process()->sink().GetFirstMessageMatching(FrameMsg_Navigate::ID);
-  ASSERT_TRUE(message != NULL);
-  Tuple1<FrameMsg_Navigate_Params> nav_params;
-  FrameMsg_Navigate::Read(message, &nav_params);
-  EXPECT_EQ(url1, nav_params.a.common_params.url);
+  GURL nav_url;
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableBrowserSideNavigation)) {
+    const IPC::Message* message = process()->sink().GetFirstMessageMatching(
+        FrameMsg_RequestNavigation::ID);
+    ASSERT_TRUE(message != NULL);
+    Tuple2<CommonNavigationParams, RequestNavigationParams> nav_params;
+    FrameMsg_RequestNavigation::Read(message, &nav_params);
+    nav_url = nav_params.a.url;
+  } else {
+    const IPC::Message* message =
+        process()->sink().GetFirstMessageMatching(FrameMsg_Navigate::ID);
+    ASSERT_TRUE(message != NULL);
+    Tuple1<FrameMsg_Navigate_Params> nav_params;
+    FrameMsg_Navigate::Read(message, &nav_params);
+    nav_url = nav_params.a.common_params.url;
+  }
+  EXPECT_EQ(url1, nav_url);
   process()->sink().ClearMessages();
 
   // Now test history.forward()
   contents()->OnGoToEntryAtOffset(2);
   EXPECT_EQ(2, controller.GetPendingEntryIndex());
   // The actual cross-navigation is suspended until the current RVH tells us
   // it unloaded, simulate that.
-  contents()->ProceedWithCrossSiteNavigation();
-  message = process()->sink().GetFirstMessageMatching(FrameMsg_Navigate::ID);
-  ASSERT_TRUE(message != NULL);
-  FrameMsg_Navigate::Read(message, &nav_params);
-  EXPECT_EQ(url3, nav_params.a.common_params.url);
+  contents()->ProceedNavigationWithRendererResponse(url3);
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableBrowserSideNavigation)) {
+    const IPC::Message* message = process()->sink().GetFirstMessageMatching(
+        FrameMsg_RequestNavigation::ID);
+    ASSERT_TRUE(message != NULL);
+    Tuple2<CommonNavigationParams, RequestNavigationParams> nav_params;
+    FrameMsg_RequestNavigation::Read(message, &nav_params);
+    nav_url = nav_params.a.url;
+  } else {
+    const IPC::Message* message =
+        process()->sink().GetFirstMessageMatching(FrameMsg_Navigate::ID);
+    ASSERT_TRUE(message != NULL);
+    Tuple1<FrameMsg_Navigate_Params> nav_params;
+    FrameMsg_Navigate::Read(message, &nav_params);
+    nav_url = nav_params.a.common_params.url;
+  }
+  EXPECT_EQ(url3, nav_url);
   process()->sink().ClearMessages();
 
   controller.DiscardNonCommittedEntries();
 
   // Make sure an extravagant history.go() doesn't break.
   contents()->OnGoToEntryAtOffset(120);  // Out of bounds.
   EXPECT_EQ(-1, controller.GetPendingEntryIndex());
-  message = process()->sink().GetFirstMessageMatching(FrameMsg_Navigate::ID);
-  EXPECT_TRUE(message == NULL);
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableBrowserSideNavigation)) {
+    const IPC::Message* message = process()->sink().GetFirstMessageMatching(
+        FrameMsg_RequestNavigation::ID);
+    EXPECT_TRUE(message == NULL);
+  } else {
+    const IPC::Message* message =
+        process()->sink().GetFirstMessageMatching(FrameMsg_Navigate::ID);
+    EXPECT_TRUE(message == NULL);
+  }
 }
 
 // Test call to PruneAllButLastCommitted for the only entry.
 TEST_F(NavigationControllerTest, PruneAllButLastCommittedForSingle) {
   NavigationControllerImpl& controller = controller_impl();
   const GURL url1("http://foo1");
   NavigateAndCommit(url1);
 
   contents()->ExpectSetHistoryLengthAndPrune(
       GetSiteInstanceFromEntry(controller.GetEntryAtIndex(0)), 0,
@@ skipping 372 matching lines @@
 
   // Verify that the pending entry correctly indicates that the session history
   // should be cleared.
   NavigationEntryImpl* entry =
       NavigationEntryImpl::FromNavigationEntry(
           controller.GetPendingEntry());
   ASSERT_TRUE(entry);
   EXPECT_TRUE(entry->should_clear_history_list());
 
   // Assume that the RF correctly cleared its history and commit the navigation.
-  contents()->GetPendingMainFrame()->
-      set_simulate_history_list_was_cleared(true);
-  contents()->CommitPendingNavigation();
+  contents()->CommitPendingNavigationWithHistoryCleared(true, true);
 
   // Verify that the NavigationController's session history was correctly
   // cleared.
   EXPECT_EQ(1, controller.GetEntryCount());
   EXPECT_EQ(0, controller.GetCurrentEntryIndex());
   EXPECT_EQ(0, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(-1, controller.GetPendingEntryIndex());
   EXPECT_FALSE(controller.CanGoBack());
   EXPECT_FALSE(controller.CanGoForward());
   EXPECT_EQ(url4, controller.GetVisibleEntry()->GetURL());
@@ skipping 29 matching lines @@
   params.post_id = -1;
   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());
 }
 
 }  // namespace content