PlzNavigate: have renderer-initiated navigations be same-process

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"
@@ skipping 17 matching lines @@
 #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/page_type.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_navigation_url_loader.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"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 
 namespace {
@@ skipping 190 matching lines @@
       return navigation_request->common_params().url;
     }
     const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(FrameMsg_Navigate::ID);
     CHECK(message);
     Tuple<FrameMsg_Navigate_Params> nav_params;
     FrameMsg_Navigate::Read(message, &nav_params);
     return get<0>(nav_params).common_params.url;
   }
 
+  void SimulateServerRedirectIfPlzNavigate(TestRenderFrameHost* test_rfh,

[clamy, 2015/02/23 10:52:34]

Please rename that method SimulateServerRedirect and add a // PlzNavigate
comment above. We do not want to have the name PlzNavigate anywhere in function
names and variables.

[carlosk, 2015/03/04 19:42:40]

Change was moved to another CL.

+                                           const GURL& redirect_url) {
+    if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnableBrowserSideNavigation)) {
+      return;
+    }
+
+    NavigatorImpl* navigator_impl =
+        static_cast<NavigatorImpl*>(test_rfh->frame_tree_node()->navigator());
+    NavigationRequest* request =
+        navigator_impl->GetNavigationRequestForNodeForTesting(
+            test_rfh->frame_tree_node());
+    CHECK(request);
+
+    if (request->state() == NavigationRequest::WAITING_FOR_RENDERER_RESPONSE)
+      test_rfh->SendBeforeUnloadACK(true);
+

[clamy, 2015/02/23 10:52:34]

CHECK that the request status is STARTED here (the patch on data urls introduce
a path that may result in the request going from WAITING_FOR_RENDERER_RESPONSE
to RESPONSE_STARTED).

[carlosk, 2015/03/04 19:42:40]

Change was moved to another CL.

+    TestNavigationURLLoader* loader =
+        static_cast<TestNavigationURLLoader*>(request->loader_for_testing());
+    CHECK(loader);
+    loader->SimulateServerRedirect(redirect_url);
+  }
+
  protected:
   GURL navigated_url_;
   size_t navigation_entry_committed_counter_;
 };
 
 void RegisterForAllNavNotifications(TestNotificationTracker* tracker,
                                     NavigationController* controller) {
   tracker->ListenFor(NOTIFICATION_NAV_LIST_PRUNED,
                      Source<NavigationController>(controller));
   tracker->ListenFor(NOTIFICATION_NAV_ENTRY_CHANGED,
@@ skipping 55 matching lines @@
   NavigationControllerImpl& controller = controller_impl();
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller);
 
   const int kNumUrls = 5;
   std::vector<GURL> urls(kNumUrls);
   for (int i = 0; i < kNumUrls; ++i) {
     urls[i] = GURL(base::StringPrintf("http://www.a.com/%d", i));
   }
 
+  main_test_rfh()->RendererRequestIfPlzNavigate(urls[0], true);

[carlosk, 2015/02/20 19:16:51]

For each SendNavigate call the intent might be different as it might be:
* A reply from the renderer carrying on with a browser-initiated navigation
* Same as above but after one or more server redirects happened
* A renderer-initiated user-initiated navigation
* A renderer-initiated non-user-initiated navigation

As those cases are handled differently in PlzNavigate world I did my best to
interpret each situation. I made comments on a few cases but please let me know
if you notice something I missed.

   main_test_rfh()->PrepareForCommit(urls[0]);
   main_test_rfh()->SendNavigate(0, urls[0]);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
   EXPECT_EQ(urls[0], controller.GetVisibleEntry()->GetVirtualURL());
   EXPECT_FALSE(controller.CanGoBack());
   EXPECT_FALSE(controller.CanGoForward());
   EXPECT_FALSE(controller.CanGoToOffset(1));
 
   for (int i = 1; i <= 4; ++i) {
+    main_test_rfh()->RendererRequestIfPlzNavigate(urls[i], true);
     main_test_rfh()->PrepareForCommit(urls[i]);
     main_test_rfh()->SendNavigate(i, urls[i]);
     EXPECT_EQ(1U, navigation_entry_committed_counter_);
     navigation_entry_committed_counter_ = 0;
     EXPECT_EQ(urls[i], controller.GetVisibleEntry()->GetVirtualURL());
     EXPECT_TRUE(controller.CanGoToOffset(-i));
     EXPECT_FALSE(controller.CanGoToOffset(-(i + 1)));
     EXPECT_FALSE(controller.CanGoToOffset(1));
   }
 
@@ skipping 494 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");
+  main_test_rfh()->RendererRequestIfPlzNavigate(kNewURL, true);
   main_test_rfh()->PrepareForCommit(kNewURL);
   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());
@@ skipping 33 matching lines @@
   controller.GoBack();
   foo_rfh->SendBeforeUnloadACK(true);
   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");
+  foo_rfh->RendererRequestIfPlzNavigate(kNewURL, true);
   foo_rfh->PrepareForCommit(kNewURL);
   foo_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());
@@ skipping 28 matching lines @@
 
   // Now make a pending new navigation.
   const GURL kNewURL("http://foo/see");
   controller.LoadURL(
       kNewURL, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_EQ(0U, notifications.size());
   EXPECT_EQ(-1, controller.GetPendingEntryIndex());
   EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
 
   // Before that commits, a back navigation from the renderer commits.
+  main_test_rfh()->RendererRequestIfPlzNavigate(kExistingURL1, true);
   main_test_rfh()->PrepareForCommit(kExistingURL1);
   main_test_rfh()->SendNavigate(0, kExistingURL1);
 
   // There should no longer be any pending entry, and the back 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(0, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(kExistingURL1, controller.GetVisibleEntry()->GetURL());
@@ skipping 20 matching lines @@
   controller.LoadURL(
       kNewURL, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_EQ(0U, notifications.size());
   EXPECT_EQ(-1, controller.GetPendingEntryIndex());
   EXPECT_TRUE(controller.GetPendingEntry());
   EXPECT_EQ(-1, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(1, delegate->navigation_state_change_count());
 
   // Before that commits, a document.write and location.reload can cause the
   // renderer to send a FrameNavigate with page_id -1.
+  main_test_rfh()->RendererRequestIfPlzNavigate(kExistingURL, true);

[carlosk, 2015/02/20 19:16:51]

This one I am really unsure about. From test comment it seems like a
non-user-initiated navigation.
Now from the referred bug's description it seems like it would be triggered by a
re-layout of the page that I think could be caused by the user re-sizing the
window so user initiated? I assumed this was the case.
Ideas?

[clamy, 2015/02/23 10:52:34]

The way blink determines if a request has a user gesture is whether it was
processing a user gesture at the same time. So if it is coming from a resize
then I guess it would be user initiated, but it could also be coming from pure
javascript in which case it would not. In any case, we expect a commit here, so
I guess it should probably stay as user-initiated.

[carlosk, 2015/03/04 19:42:40]

Ack. Also with the current cancellation policy a non-user-initiated request here
would be ignored.

   main_test_rfh()->PrepareForCommit(kExistingURL);
   main_test_rfh()->SendNavigate(-1, kExistingURL);
 
   // This should clear the pending entry and notify of a navigation state
   // change, so that we do not keep displaying kNewURL.
   EXPECT_EQ(-1, controller.GetPendingEntryIndex());
   EXPECT_FALSE(controller.GetPendingEntry());
   EXPECT_EQ(-1, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(2, delegate->navigation_state_change_count());
 
@@ skipping 244 matching lines @@
   controller.LoadURL(
       url1, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   main_test_rfh()->PrepareForCommit(url1);
   main_test_rfh()->SendNavigate(0, url1);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
   controller.Reload(true);
   EXPECT_EQ(0U, notifications.size());
 
+  SimulateServerRedirectIfPlzNavigate(main_test_rfh(), url2);

[carlosk, 2015/02/20 19:16:51]

I guess that "a reload navigation produces a new page" means that the user did
hit Reload but the server redirected it to a new page.

[clamy, 2015/02/23 10:52:34]

Acknowledged.

   main_test_rfh()->PrepareForCommit(url2);
   main_test_rfh()->SendNavigate(1, url2);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
   // Now the reload is committed.
   EXPECT_EQ(controller.GetEntryCount(), 2);
   EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 1);
   EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
   EXPECT_TRUE(controller.GetLastCommittedEntry());
@@ skipping 40 matching lines @@
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller);
 
   const GURL original_url("http://foo1");
   const GURL final_url("http://foo2");
 
   // Load up the original URL, but get redirected.
   controller.LoadURL(
       original_url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_EQ(0U, notifications.size());
+  SimulateServerRedirectIfPlzNavigate(main_test_rfh(), final_url);
   main_test_rfh()->PrepareForCommit(final_url);
   main_test_rfh()->SendNavigateWithOriginalRequestURL(
       0, final_url, original_url);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
   // The NavigationEntry should save both the original URL and the final
   // redirected URL.
   EXPECT_EQ(
       original_url, controller.GetVisibleEntry()->GetOriginalRequestURL());
@@ skipping 13 matching lines @@
   EXPECT_TRUE(controller.GetPendingEntry());
   EXPECT_FALSE(controller.CanGoBack());
   EXPECT_FALSE(controller.CanGoForward());
 
   // Make sure the title has been cleared (will be redrawn just after reload).
   // Avoids a stale cached title when the new page being reloaded has no title.
   // See http://crbug.com/96041.
   EXPECT_TRUE(controller.GetVisibleEntry()->GetTitle().empty());
 
   // Send that the navigation has proceeded; say it got redirected again.
+  SimulateServerRedirectIfPlzNavigate(main_test_rfh(), final_url);
   main_test_rfh()->PrepareForCommit(final_url);
   main_test_rfh()->SendNavigate(0, final_url);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
   // Now the reload is committed.
   EXPECT_EQ(controller.GetEntryCount(), 1);
   EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
   EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
   EXPECT_TRUE(controller.GetLastCommittedEntry());
@@ skipping 174 matching lines @@
 
   // We should now have a pending navigation to go back.
   EXPECT_EQ(controller.GetEntryCount(), 2);
   EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 1);
   EXPECT_EQ(controller.GetPendingEntryIndex(), 0);
   EXPECT_TRUE(controller.GetLastCommittedEntry());
   EXPECT_TRUE(controller.GetPendingEntry());
   EXPECT_FALSE(controller.CanGoBack());
   EXPECT_TRUE(controller.CanGoForward());
 
+  SimulateServerRedirectIfPlzNavigate(main_test_rfh(), url3);

[carlosk, 2015/02/20 19:16:51]

Same as previous comment for "a reload navigation produces a new page" but now
for "back".

[clamy, 2015/02/23 10:52:34]

Acknowledged.

   main_test_rfh()->PrepareForCommit(url3);
   main_test_rfh()->SendNavigate(2, url3);
   EXPECT_EQ(1U, navigation_entry_committed_counter_);
   navigation_entry_committed_counter_ = 0;
 
   // The back navigation resulted in a completely new navigation.
   // TODO(darin): perhaps this behavior will be confusing to users?
   EXPECT_EQ(controller.GetEntryCount(), 3);
   EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 2);
   EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
@@ skipping 38 matching lines @@
 
 // Receives a back message when there is a different renavigation already
 // pending.
 TEST_F(NavigationControllerTest, Back_OtherBackPending) {
   NavigationControllerImpl& controller = controller_impl();
   const GURL kUrl1("http://foo/1");
   const GURL kUrl2("http://foo/2");
   const GURL kUrl3("http://foo/3");
 
   // First navigate three places so we have some back history.
+  main_test_rfh()->RendererRequestIfPlzNavigate(kUrl1, true);
   main_test_rfh()->PrepareForCommit(kUrl1);
   main_test_rfh()->SendNavigate(0, kUrl1);
+  main_test_rfh()->RendererRequestIfPlzNavigate(kUrl2, true);
   main_test_rfh()->PrepareForCommit(kUrl2);
   main_test_rfh()->SendNavigate(1, kUrl2);
+  main_test_rfh()->RendererRequestIfPlzNavigate(kUrl3, true);
   main_test_rfh()->PrepareForCommit(kUrl3);
   main_test_rfh()->SendNavigate(2, kUrl3);
 
   // With nothing pending, say we get a navigation to the second entry.
+  main_test_rfh()->RendererRequestIfPlzNavigate(kUrl2, true);
   main_test_rfh()->PrepareForCommit(kUrl2);
   main_test_rfh()->SendNavigate(1, kUrl2);
 
   // We know all the entries have the same site instance, so we can just grab
   // a random one for looking up other entries.
   SiteInstance* site_instance =
       NavigationEntryImpl::FromNavigationEntry(
           controller.GetLastCommittedEntry())->site_instance();
 
   // That second URL should be the last committed and it should have gotten the
   // new title.
   EXPECT_EQ(kUrl2, controller.GetEntryWithPageID(site_instance, 1)->GetURL());
   EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(-1, controller.GetPendingEntryIndex());
 
   // Now go forward to the last item again and say it was committed.
   controller.GoForward();
   main_test_rfh()->PrepareForCommit(kUrl3);
   main_test_rfh()->SendNavigate(2, kUrl3);
 
   // Now start going back one to the second page. It will be pending.
   controller.GoBack();
   EXPECT_EQ(1, controller.GetPendingEntryIndex());
   EXPECT_EQ(2, controller.GetLastCommittedEntryIndex());
 
-  // Not synthesize a totally new back event to the first page. This will not
+  // Now synthesize a totally new back event to the first page. This will not
   // match the pending one.
+  main_test_rfh()->RendererRequestIfPlzNavigate(kUrl1, true);
   main_test_rfh()->PrepareForCommit(kUrl1);
   main_test_rfh()->SendNavigate(0, kUrl1);
 
   // The committed navigation should clear the pending entry.
   EXPECT_EQ(-1, controller.GetPendingEntryIndex());
 
   // But the navigated entry should be the last committed.
   EXPECT_EQ(0, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(kUrl1, controller.GetLastCommittedEntry()->GetURL());
 }
@@ skipping 975 matching lines @@
   NavigationControllerImpl& controller = controller_impl();
   // First navigate somewhere normal.
   const GURL url1("http://foo");
   controller.LoadURL(
       url1, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   main_test_rfh()->PrepareForCommit(url1);
   main_test_rfh()->SendNavigate(0, url1);
 
   // Now navigate somewhere with an interstitial.
   const GURL url2("http://bar");
-  controller.LoadURL(
-      url1, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
+  controller.LoadURL(url2, Referrer(), ui::PAGE_TRANSITION_TYPED,
+                     std::string());

[carlosk, 2015/02/20 19:16:51]

The previous URL value here seemed to not be what the author meant to use.

[clamy, 2015/02/23 10:52:34]

Acknowledged.

   NavigationEntryImpl::FromNavigationEntry(controller.GetPendingEntry())->
       set_page_type(PAGE_TYPE_INTERSTITIAL);
 
   // At this point the interstitial will be displayed and the load will still
   // be pending. If the user continues, the load will commit.
   main_test_rfh()->PrepareForCommit(url2);
   main_test_rfh()->SendNavigate(1, url2);
 
   // The page should be a normal page again.
   EXPECT_EQ(url2, controller.GetLastCommittedEntry()->GetURL());
@@ skipping 161 matching lines @@
 
   // We should have navigated, transient entry should be gone.
   EXPECT_EQ(url2, controller.GetVisibleEntry()->GetURL());
   EXPECT_EQ(controller.GetEntryCount(), 3);
 
   // Add a transient again, then navigate with no pending entry this time.
   transient_entry = new NavigationEntryImpl;
   transient_entry->SetURL(transient_url);
   controller.SetTransientEntry(transient_entry);
   EXPECT_EQ(transient_url, controller.GetVisibleEntry()->GetURL());
+  main_test_rfh()->RendererRequestIfPlzNavigate(url3, true);

[carlosk, 2015/02/20 19:16:51]

Again not really sure about these ones in this test. I assumed they were all
renderer-initiated requests.

[clamy, 2015/02/23 10:52:34]

Acknowledged.

   main_test_rfh()->PrepareForCommit(url3);
   main_test_rfh()->SendNavigate(3, url3);
   // Transient entry should be gone.
   EXPECT_EQ(url3, controller.GetVisibleEntry()->GetURL());
   EXPECT_EQ(controller.GetEntryCount(), 4);
 
   // Initiate a navigation, add a transient then commit navigation.
   controller.LoadURL(
       url4, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
   transient_entry = new NavigationEntryImpl;
   transient_entry->SetURL(transient_url);
   controller.SetTransientEntry(transient_entry);
   EXPECT_EQ(transient_url, controller.GetVisibleEntry()->GetURL());
   main_test_rfh()->PrepareForCommit(url4);
   main_test_rfh()->SendNavigate(4, url4);
   EXPECT_EQ(url4, controller.GetVisibleEntry()->GetURL());
   EXPECT_EQ(controller.GetEntryCount(), 5);
 
   // Add a transient and go back.  This should simply remove the transient.
   transient_entry = new NavigationEntryImpl;
   transient_entry->SetURL(transient_url);
   controller.SetTransientEntry(transient_entry);
   EXPECT_EQ(transient_url, controller.GetVisibleEntry()->GetURL());
   EXPECT_TRUE(controller.CanGoBack());
   EXPECT_FALSE(controller.CanGoForward());
   controller.GoBack();
   // Transient entry should be gone.
   EXPECT_EQ(url4, controller.GetVisibleEntry()->GetURL());
   EXPECT_EQ(controller.GetEntryCount(), 5);
+
+  main_test_rfh()->RendererRequestIfPlzNavigate(url3, false);
   main_test_rfh()->PrepareForCommit(url3);
   main_test_rfh()->SendNavigate(3, url3);
 
   // Add a transient and go to an entry before the current one.
   transient_entry = new NavigationEntryImpl;
   transient_entry->SetURL(transient_url);
   controller.SetTransientEntry(transient_entry);
   EXPECT_EQ(transient_url, controller.GetVisibleEntry()->GetURL());
   controller.GoToIndex(1);
   // The navigation should have been initiated, transient entry should be gone.
@@ skipping 33 matching lines @@
   EXPECT_EQ(url2, controller.GetVisibleEntry()->GetURL());
   main_test_rfh()->PrepareForCommit(url3);
   main_test_rfh()->SendNavigate(3, url3);
   EXPECT_EQ(url3, controller.GetVisibleEntry()->GetURL());
 
   // Add a transient and do an in-page navigation, replacing the current entry.
   transient_entry = new NavigationEntryImpl;
   transient_entry->SetURL(transient_url);
   controller.SetTransientEntry(transient_entry);
   EXPECT_EQ(transient_url, controller.GetVisibleEntry()->GetURL());
+
+  main_test_rfh()->RendererRequestIfPlzNavigate(url3_ref, false);
   main_test_rfh()->PrepareForCommit(url3_ref);
   main_test_rfh()->SendNavigate(3, url3_ref);
   // Transient entry should be gone.
   EXPECT_FALSE(controller.GetTransientEntry());
   EXPECT_EQ(url3_ref, controller.GetVisibleEntry()->GetURL());
 
   // Ensure the URLs are correct.
   EXPECT_EQ(controller.GetEntryCount(), 5);
   EXPECT_EQ(controller.GetEntryAtIndex(0)->GetURL(), url0);
   EXPECT_EQ(controller.GetEntryAtIndex(1)->GetURL(), url1);
@@ skipping 1687 matching lines @@
   {
     LoadCommittedDetails details;
     controller_impl().RendererDidNavigate(main_test_rfh(), params, &details);
     EXPECT_EQ(PAGE_TYPE_ERROR,
               controller_impl().GetLastCommittedEntry()->GetPageType());
     EXPECT_EQ(NAVIGATION_TYPE_IN_PAGE, details.type);
   }
 }
 
 }  // namespace content