content/browser/frame_host/navigator_impl_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/command_line.h"
   6 #include "base/macros.h"
   7 #include "base/time/time.h"
   8 #include "content/browser/frame_host/navigation_controller_impl.h"
   9 #include "content/browser/frame_host/navigation_entry_impl.h"
  10 #include "content/browser/frame_host/navigation_request.h"
  11 #include "content/browser/frame_host/navigation_request_info.h"
  12 #include "content/browser/frame_host/navigator.h"
  13 #include "content/browser/frame_host/navigator_impl.h"
  14 #include "content/browser/frame_host/render_frame_host_manager.h"
  15 #include "content/browser/site_instance_impl.h"
  16 #include "content/browser/streams/stream.h"
  17 #include "content/common/frame_messages.h"
  18 #include "content/common/navigation_params.h"
  19 #include "content/public/browser/stream_handle.h"
  20 #include "content/public/common/content_switches.h"
  21 #include "content/public/common/url_constants.h"
  22 #include "content/public/common/url_utils.h"
  23 #include "content/public/test/mock_render_process_host.h"
  24 #include "content/test/browser_side_navigation_test_utils.h"
  25 #include "content/test/test_navigation_url_loader.h"
  26 #include "content/test/test_render_frame_host.h"
  27 #include "content/test/test_web_contents.h"
  28 #include "net/base/load_flags.h"
  29 #include "net/http/http_response_headers.h"
  30 #include "net/url_request/redirect_info.h"
  31 #include "ui/base/page_transition_types.h"
  32 #include "url/url_constants.h"
  33
  34 #if !defined(OS_ANDROID)
  35 #include "content/browser/compositor/test/no_transport_image_transport_factory.h"
  36 #endif
  37
  38 namespace content {
  39
  40 class NavigatorTestWithBrowserSideNavigation
  41     : public RenderViewHostImplTestHarness {
  42  public:
  43   // Re-defines the private RenderFrameHostManager::SiteInstanceDescriptor here
  44   // to allow access to it from tests.
  45   typedef RenderFrameHostManager::SiteInstanceDescriptor SiteInstanceDescriptor;
  46
  47   void SetUp() override {
  48 #if !defined(OS_ANDROID)
  49     ImageTransportFactory::InitializeForUnitTests(
  50         scoped_ptr<ImageTransportFactory>(
  51             new NoTransportImageTransportFactory));
  52 #endif
  53     EnableBrowserSideNavigation();
  54     RenderViewHostImplTestHarness::SetUp();
  55   }
  56
  57   void TearDown() override {
  58 #if !defined(OS_ANDROID)
  59     ImageTransportFactory::Terminate();
  60 #endif
  61     RenderViewHostImplTestHarness::TearDown();
  62   }
  63
  64   TestNavigationURLLoader* GetLoaderForNavigationRequest(
  65       NavigationRequest* request) const {
  66     return static_cast<TestNavigationURLLoader*>(request->loader_for_testing());
  67   }
  68
  69   // Requests a navigation of the specified FrameTreeNode to the specified URL;
  70   // returns the unique ID of the pending NavigationEntry.
  71   int RequestNavigation(FrameTreeNode* node, const GURL& url) {
  72     return RequestNavigationWithParameters(node, url, Referrer(),
  73                                            ui::PAGE_TRANSITION_LINK);
  74   }
  75
  76   // Requests a navigation of the specified FrameTreeNode to the specified URL,
  77   // using other specified parameters; returns the unique ID of the pending
  78   // NavigationEntry.
  79   int RequestNavigationWithParameters(
  80       FrameTreeNode* node,
  81       const GURL& url,
  82       const Referrer& referrer,
  83       ui::PageTransition transition_type) {
  84     NavigationController::LoadURLParams load_params(url);
  85     load_params.frame_tree_node_id = node->frame_tree_node_id();
  86     load_params.referrer = referrer;
  87     load_params.transition_type = transition_type;
  88
  89     controller().LoadURLWithParams(load_params);
  90     return controller().GetPendingEntry()->GetUniqueID();
  91   }
  92
  93   TestRenderFrameHost* GetSpeculativeRenderFrameHost(FrameTreeNode* node) {
  94     return static_cast<TestRenderFrameHost*>(
  95         node->render_manager()->speculative_render_frame_host_.get());
  96   }
  97
  98   // Checks if this RenderFrameHost sent a single FrameMsg_CommitNavigation
  99   // since the last clearing of the sink.
 100   // Note: caller must invoke ClearMessages on the sink at some point before
 101   // the tracked commit happens to clear up commit messages from previous
 102   // navigations.
 103   bool DidRenderFrameHostRequestCommit(TestRenderFrameHost* rfh) {
 104     const FrameMsg_CommitNavigation* commit_message =
 105         static_cast<const FrameMsg_CommitNavigation*>(
 106             rfh->GetProcess()->sink().GetUniqueMessageMatching(
 107                 FrameMsg_CommitNavigation::ID));
 108     return commit_message &&
 109            rfh->GetRoutingID() == commit_message->routing_id();
 110   }
 111
 112   SiteInstance* ConvertToSiteInstance(RenderFrameHostManager* rfhm,
 113                                       const SiteInstanceDescriptor& descriptor,
 114                                       SiteInstance* candidate_instance) {
 115     return rfhm->ConvertToSiteInstance(descriptor, candidate_instance);
 116   }
 117 };
 118
 119 // PlzNavigate: Test a complete browser-initiated navigation starting with a
 120 // non-live renderer.
 121 TEST_F(NavigatorTestWithBrowserSideNavigation,
 122        SimpleBrowserInitiatedNavigationFromNonLiveRenderer) {
 123   const GURL kUrl("http://chromium.org/");
 124
 125   EXPECT_FALSE(main_test_rfh()->IsRenderFrameLive());
 126
 127   // Start a browser-initiated navigation.
 128   int32 site_instance_id = main_test_rfh()->GetSiteInstance()->GetId();
 129   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 130   int entry_id = RequestNavigation(node, kUrl);
 131   NavigationRequest* request = node->navigation_request();
 132   ASSERT_TRUE(request);
 133   EXPECT_EQ(kUrl, request->common_params().url);
 134   EXPECT_TRUE(request->browser_initiated());
 135
 136   // As there's no live renderer the navigation should not wait for a
 137   // beforeUnload ACK from the renderer and start right away.
 138   EXPECT_EQ(NavigationRequest::STARTED, request->state());
 139   ASSERT_TRUE(GetLoaderForNavigationRequest(request));
 140   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 141   EXPECT_FALSE(node->render_manager()->pending_frame_host());
 142
 143   // Have the current RenderFrameHost commit the navigation.
 144   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 145   GetLoaderForNavigationRequest(request)
 146       ->CallOnResponseStarted(response, MakeEmptyStream());
 147   EXPECT_TRUE(DidRenderFrameHostRequestCommit(main_test_rfh()));
 148   EXPECT_EQ(NavigationRequest::RESPONSE_STARTED, request->state());
 149
 150   // Commit the navigation.
 151   main_test_rfh()->SendNavigate(0, entry_id, true, kUrl);
 152   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, main_test_rfh()->rfh_state());
 153   EXPECT_EQ(SiteInstanceImpl::GetSiteForURL(browser_context(), kUrl),
 154             main_test_rfh()->GetSiteInstance()->GetSiteURL());
 155   EXPECT_EQ(kUrl, contents()->GetLastCommittedURL());
 156   EXPECT_FALSE(node->navigation_request());
 157   EXPECT_FALSE(node->render_manager()->pending_frame_host());
 158
 159   // The main RenderFrameHost should not have been changed, and the renderer
 160   // should have been initialized.
 161   EXPECT_EQ(site_instance_id, main_test_rfh()->GetSiteInstance()->GetId());
 162   EXPECT_TRUE(main_test_rfh()->IsRenderFrameLive());
 163
 164   // After a navigation is finished no speculative RenderFrameHost should
 165   // exist.
 166   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 167
 168   // With PlzNavigate enabled a pending RenderFrameHost should never exist.
 169   EXPECT_FALSE(node->render_manager()->pending_frame_host());
 170 }
 171
 172 // PlzNavigate: Test a complete renderer-initiated same-site navigation.
 173 TEST_F(NavigatorTestWithBrowserSideNavigation,
 174        SimpleRendererInitiatedSameSiteNavigation) {
 175   const GURL kUrl1("http://www.chromium.org/");
 176   const GURL kUrl2("http://www.chromium.org/Home");
 177
 178   contents()->NavigateAndCommit(kUrl1);
 179   EXPECT_TRUE(main_test_rfh()->IsRenderFrameLive());
 180
 181   // Start a renderer-initiated non-user-initiated navigation.
 182   process()->sink().ClearMessages();
 183   main_test_rfh()->SendRendererInitiatedNavigationRequest(kUrl2, false);
 184   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 185   NavigationRequest* request = node->navigation_request();
 186   ASSERT_TRUE(request);
 187
 188   // The navigation is immediately started as there's no need to wait for
 189   // beforeUnload to be executed.
 190   EXPECT_EQ(NavigationRequest::STARTED, request->state());
 191   EXPECT_FALSE(request->begin_params().has_user_gesture);
 192   EXPECT_EQ(kUrl2, request->common_params().url);
 193   EXPECT_FALSE(request->browser_initiated());
 194   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 195
 196   // Have the current RenderFrameHost commit the navigation.
 197   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 198   GetLoaderForNavigationRequest(request)
 199       ->CallOnResponseStarted(response, MakeEmptyStream());
 200   EXPECT_TRUE(DidRenderFrameHostRequestCommit(main_test_rfh()));
 201   EXPECT_EQ(NavigationRequest::RESPONSE_STARTED, request->state());
 202
 203   // Commit the navigation.
 204   main_test_rfh()->SendNavigate(1, 0, true, kUrl2);
 205   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, main_test_rfh()->rfh_state());
 206   EXPECT_EQ(SiteInstanceImpl::GetSiteForURL(browser_context(), kUrl2),
 207             main_test_rfh()->GetSiteInstance()->GetSiteURL());
 208   EXPECT_EQ(kUrl2, contents()->GetLastCommittedURL());
 209   EXPECT_FALSE(node->navigation_request());
 210   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 211   EXPECT_FALSE(node->render_manager()->pending_frame_host());
 212 }
 213
 214 // PlzNavigate: Test a complete renderer-initiated navigation that should be
 215 // cross-site but does not result in a SiteInstance swap because its
 216 // renderer-initiated.
 217 TEST_F(NavigatorTestWithBrowserSideNavigation,
 218        SimpleRendererInitiatedCrossSiteNavigation) {
 219   const GURL kUrl1("http://www.chromium.org/");
 220   const GURL kUrl2("http://www.google.com");
 221
 222   contents()->NavigateAndCommit(kUrl1);
 223   EXPECT_TRUE(main_test_rfh()->IsRenderFrameLive());
 224   int32 site_instance_id_1 = main_test_rfh()->GetSiteInstance()->GetId();
 225
 226   // Start a renderer-initiated non-user-initiated navigation.
 227   process()->sink().ClearMessages();
 228   main_test_rfh()->SendRendererInitiatedNavigationRequest(kUrl2, false);
 229   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 230   NavigationRequest* request = node->navigation_request();
 231   ASSERT_TRUE(request);
 232
 233   // The navigation is immediately started as there's no need to wait for
 234   // beforeUnload to be executed.
 235   EXPECT_EQ(NavigationRequest::STARTED, request->state());
 236   EXPECT_FALSE(request->begin_params().has_user_gesture);
 237   EXPECT_EQ(kUrl2, request->common_params().url);
 238   EXPECT_FALSE(request->browser_initiated());
 239   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 240
 241   // Have the current RenderFrameHost commit the navigation.
 242   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 243   GetLoaderForNavigationRequest(request)
 244       ->CallOnResponseStarted(response, MakeEmptyStream());
 245   EXPECT_TRUE(DidRenderFrameHostRequestCommit(main_test_rfh()));
 246   EXPECT_EQ(NavigationRequest::RESPONSE_STARTED, request->state());
 247
 248   // Commit the navigation.
 249   main_test_rfh()->SendNavigate(1, 0, true, kUrl2);
 250   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, main_test_rfh()->rfh_state());
 251   EXPECT_EQ(kUrl2, contents()->GetLastCommittedURL());
 252   EXPECT_FALSE(node->navigation_request());
 253   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 254   EXPECT_FALSE(node->render_manager()->pending_frame_host());
 255
 256   // The SiteInstance did not change.
 257   EXPECT_EQ(site_instance_id_1, main_test_rfh()->GetSiteInstance()->GetId());
 258 }
 259
 260 // PlzNavigate: Test that a beforeUnload denial cancels the navigation.
 261 TEST_F(NavigatorTestWithBrowserSideNavigation,
 262        BeforeUnloadDenialCancelNavigation) {
 263   const GURL kUrl1("http://www.google.com/");
 264   const GURL kUrl2("http://www.chromium.org/");
 265
 266   contents()->NavigateAndCommit(kUrl1);
 267
 268   // Start a new navigation.
 269   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 270   RequestNavigation(node, kUrl2);
 271   NavigationRequest* request = node->navigation_request();
 272   ASSERT_TRUE(request);
 273   EXPECT_TRUE(request->browser_initiated());
 274   EXPECT_EQ(NavigationRequest::WAITING_FOR_RENDERER_RESPONSE, request->state());
 275   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 276
 277   // Simulate a beforeUnload denial.
 278   main_test_rfh()->SendBeforeUnloadACK(false);
 279   EXPECT_FALSE(node->navigation_request());
 280   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 281 }
 282
 283 // PlzNavigate: Test that a proper NavigationRequest is created by
 284 // RequestNavigation.
 285 TEST_F(NavigatorTestWithBrowserSideNavigation, BeginNavigation) {
 286   const GURL kUrl1("http://www.google.com/");
 287   const GURL kUrl2("http://www.chromium.org/");
 288   const GURL kUrl3("http://www.gmail.com/");
 289
 290   contents()->NavigateAndCommit(kUrl1);
 291
 292   // Add a subframe.
 293   FrameTreeNode* root_node = contents()->GetFrameTree()->root();
 294   TestRenderFrameHost* subframe_rfh = main_test_rfh()->AppendChild("Child");
 295   ASSERT_TRUE(subframe_rfh);
 296
 297   // Start a navigation at the subframe.
 298   FrameTreeNode* subframe_node = subframe_rfh->frame_tree_node();
 299   RequestNavigation(subframe_node, kUrl2);
 300   NavigationRequest* subframe_request = subframe_node->navigation_request();
 301   TestNavigationURLLoader* subframe_loader =
 302       GetLoaderForNavigationRequest(subframe_request);
 303
 304   // Subframe navigations should start right away as they don't have to request
 305   // beforeUnload to run at the renderer.
 306   ASSERT_TRUE(subframe_request);
 307   ASSERT_TRUE(subframe_loader);
 308   EXPECT_EQ(NavigationRequest::STARTED, subframe_request->state());
 309   EXPECT_EQ(kUrl2, subframe_request->common_params().url);
 310   EXPECT_EQ(kUrl2, subframe_loader->request_info()->common_params.url);
 311   // First party for cookies url should be that of the main frame.
 312   EXPECT_EQ(kUrl1, subframe_loader->request_info()->first_party_for_cookies);
 313   EXPECT_FALSE(subframe_loader->request_info()->is_main_frame);
 314   EXPECT_TRUE(subframe_loader->request_info()->parent_is_main_frame);
 315   EXPECT_TRUE(subframe_request->browser_initiated());
 316   EXPECT_FALSE(GetSpeculativeRenderFrameHost(root_node));
 317
 318   // Subframe navigations should never create a speculative RenderFrameHost,
 319   // unless site-per-process is enabled. In that case, as the subframe
 320   // navigation is to a different site and is still ongoing, it should have one.
 321   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
 322           switches::kSitePerProcess)) {
 323     EXPECT_TRUE(GetSpeculativeRenderFrameHost(subframe_node));
 324   } else {
 325     EXPECT_FALSE(GetSpeculativeRenderFrameHost(subframe_node));
 326   }
 327
 328   // Now start a navigation at the root node.
 329   RequestNavigation(root_node, kUrl3);
 330   NavigationRequest* main_request = root_node->navigation_request();
 331   ASSERT_TRUE(main_request);
 332   EXPECT_EQ(NavigationRequest::WAITING_FOR_RENDERER_RESPONSE,
 333             main_request->state());
 334   EXPECT_FALSE(GetSpeculativeRenderFrameHost(root_node));
 335
 336   // Simulate a BeforeUnloadACK IPC on the main frame.
 337   main_test_rfh()->SendBeforeUnloadACK(true);
 338   TestNavigationURLLoader* main_loader =
 339       GetLoaderForNavigationRequest(main_request);
 340   EXPECT_EQ(kUrl3, main_request->common_params().url);
 341   EXPECT_EQ(kUrl3, main_loader->request_info()->common_params.url);
 342   EXPECT_EQ(kUrl3, main_loader->request_info()->first_party_for_cookies);
 343   EXPECT_TRUE(main_loader->request_info()->is_main_frame);
 344   EXPECT_FALSE(main_loader->request_info()->parent_is_main_frame);
 345   EXPECT_TRUE(main_request->browser_initiated());
 346   // BeforeUnloadACK was received from the renderer so the navigation should
 347   // have started.
 348   EXPECT_EQ(NavigationRequest::STARTED, main_request->state());
 349
 350   // Main frame navigation to a different site should use a speculative
 351   // RenderFrameHost.
 352   EXPECT_TRUE(GetSpeculativeRenderFrameHost(root_node));
 353
 354   // As the main frame hasn't yet committed the subframe still exists. Thus, the
 355   // above situation regarding subframe navigations is valid here.
 356   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
 357           switches::kSitePerProcess)) {
 358     EXPECT_TRUE(GetSpeculativeRenderFrameHost(subframe_node));
 359   } else {
 360     EXPECT_FALSE(GetSpeculativeRenderFrameHost(subframe_node));
 361   }
 362 }
 363
 364 // PlzNavigate: Test that committing an HTTP 204 or HTTP 205 response cancels
 365 // the navigation.
 366 TEST_F(NavigatorTestWithBrowserSideNavigation, NoContent) {
 367   const GURL kUrl1("http://www.chromium.org/");
 368   const GURL kUrl2("http://www.google.com/");
 369
 370   // Load a URL.
 371   contents()->NavigateAndCommit(kUrl1);
 372   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 373
 374   // Navigate to a different site.
 375   process()->sink().ClearMessages();
 376   RequestNavigation(node, kUrl2);
 377   main_test_rfh()->SendBeforeUnloadACK(true);
 378
 379   NavigationRequest* main_request = node->navigation_request();
 380   ASSERT_TRUE(main_request);
 381
 382   // Navigations to a different site do create a speculative RenderFrameHost.
 383   EXPECT_TRUE(GetSpeculativeRenderFrameHost(node));
 384
 385   // Commit an HTTP 204 response.
 386   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 387   const char kNoContentHeaders[] = "HTTP/1.1 204 No Content\0\0";
 388   response->head.headers = new net::HttpResponseHeaders(
 389       std::string(kNoContentHeaders, arraysize(kNoContentHeaders)));
 390   GetLoaderForNavigationRequest(main_request)->CallOnResponseStarted(
 391       response, MakeEmptyStream());
 392
 393   // There should be no pending nor speculative RenderFrameHost; the navigation
 394   // was aborted.
 395   EXPECT_FALSE(DidRenderFrameHostRequestCommit(main_test_rfh()));
 396   EXPECT_FALSE(node->navigation_request());
 397   EXPECT_FALSE(node->render_manager()->pending_frame_host());
 398   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 399
 400   // Now, repeat the test with 205 Reset Content.
 401
 402   // Navigate to a different site again.
 403   process()->sink().ClearMessages();
 404   RequestNavigation(node, kUrl2);
 405   main_test_rfh()->SendBeforeUnloadACK(true);
 406
 407   main_request = node->navigation_request();
 408   ASSERT_TRUE(main_request);
 409   EXPECT_TRUE(GetSpeculativeRenderFrameHost(node));
 410
 411   // Commit an HTTP 205 response.
 412   response = new ResourceResponse;
 413   const char kResetContentHeaders[] = "HTTP/1.1 205 Reset Content\0\0";
 414   response->head.headers = new net::HttpResponseHeaders(
 415       std::string(kResetContentHeaders, arraysize(kResetContentHeaders)));
 416   GetLoaderForNavigationRequest(main_request)->CallOnResponseStarted(
 417       response, MakeEmptyStream());
 418
 419   // There should be no pending nor speculative RenderFrameHost; the navigation
 420   // was aborted.
 421   EXPECT_FALSE(DidRenderFrameHostRequestCommit(main_test_rfh()));
 422   EXPECT_FALSE(node->navigation_request());
 423   EXPECT_FALSE(node->render_manager()->pending_frame_host());
 424   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 425 }
 426
 427 // PlzNavigate: Test that a new RenderFrameHost is created when doing a cross
 428 // site navigation.
 429 TEST_F(NavigatorTestWithBrowserSideNavigation, CrossSiteNavigation) {
 430   const GURL kUrl1("http://www.chromium.org/");
 431   const GURL kUrl2("http://www.google.com/");
 432
 433   contents()->NavigateAndCommit(kUrl1);
 434   RenderFrameHostImpl* initial_rfh = main_test_rfh();
 435   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 436
 437   // Navigate to a different site.
 438   process()->sink().ClearMessages();
 439   int entry_id = RequestNavigation(node, kUrl2);
 440   NavigationRequest* main_request = node->navigation_request();
 441   ASSERT_TRUE(main_request);
 442   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 443
 444   // Receive the beforeUnload ACK.
 445   main_test_rfh()->SendBeforeUnloadACK(true);
 446   EXPECT_TRUE(GetSpeculativeRenderFrameHost(node));
 447   EXPECT_FALSE(contents()->CrossProcessNavigationPending());
 448
 449   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 450   GetLoaderForNavigationRequest(main_request)->CallOnResponseStarted(
 451       response, MakeEmptyStream());
 452   TestRenderFrameHost* speculative_rfh = GetSpeculativeRenderFrameHost(node);
 453   ASSERT_TRUE(speculative_rfh);
 454   EXPECT_TRUE(DidRenderFrameHostRequestCommit(speculative_rfh));
 455   EXPECT_FALSE(DidRenderFrameHostRequestCommit(main_test_rfh()));
 456   EXPECT_TRUE(contents()->CrossProcessNavigationPending());
 457
 458   speculative_rfh->SendNavigate(0, entry_id, true, kUrl2);
 459
 460   RenderFrameHostImpl* final_rfh = main_test_rfh();
 461   EXPECT_EQ(speculative_rfh, final_rfh);
 462   EXPECT_NE(initial_rfh, final_rfh);
 463   EXPECT_TRUE(final_rfh->IsRenderFrameLive());
 464   EXPECT_TRUE(final_rfh->render_view_host()->IsRenderViewLive());
 465   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 466 }
 467
 468 // PlzNavigate: Test that redirects are followed and the speculative
 469 // RenderFrameHost logic behaves as expected.
 470 TEST_F(NavigatorTestWithBrowserSideNavigation, RedirectCrossSite) {
 471   const GURL kUrl1("http://www.chromium.org/");
 472   const GURL kUrl2("http://www.google.com/");
 473
 474   contents()->NavigateAndCommit(kUrl1);
 475   RenderFrameHostImpl* rfh = main_test_rfh();
 476   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 477
 478   // Navigate to a URL on the same site.
 479   process()->sink().ClearMessages();
 480   int entry_id = RequestNavigation(node, kUrl1);
 481   main_test_rfh()->SendBeforeUnloadACK(true);
 482   NavigationRequest* main_request = node->navigation_request();
 483   ASSERT_TRUE(main_request);
 484   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 485
 486   // It then redirects to another site.
 487   GetLoaderForNavigationRequest(main_request)->SimulateServerRedirect(kUrl2);
 488
 489   // The redirect should have been followed.
 490   EXPECT_EQ(1, GetLoaderForNavigationRequest(main_request)->redirect_count());
 491   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 492
 493   // Have the RenderFrameHost commit the navigation.
 494   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 495   GetLoaderForNavigationRequest(main_request)->CallOnResponseStarted(
 496       response, MakeEmptyStream());
 497   TestRenderFrameHost* final_speculative_rfh =
 498       GetSpeculativeRenderFrameHost(node);
 499   EXPECT_TRUE(final_speculative_rfh);
 500   EXPECT_TRUE(DidRenderFrameHostRequestCommit(final_speculative_rfh));
 501
 502   // Commit the navigation.
 503   final_speculative_rfh->SendNavigate(0, entry_id, true, kUrl2);
 504   RenderFrameHostImpl* final_rfh = main_test_rfh();
 505   ASSERT_TRUE(final_rfh);
 506   EXPECT_NE(rfh, final_rfh);
 507   EXPECT_EQ(final_speculative_rfh, final_rfh);
 508   EXPECT_TRUE(final_rfh->IsRenderFrameLive());
 509   EXPECT_TRUE(final_rfh->render_view_host()->IsRenderViewLive());
 510   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 511 }
 512
 513 // PlzNavigate: Test that a navigation is canceled if another browser-initiated
 514 // request has been issued in the meantime. Also confirms that the speculative
 515 // RenderFrameHost is correctly updated in the process.
 516 TEST_F(NavigatorTestWithBrowserSideNavigation,
 517        BrowserInitiatedNavigationCancel) {
 518   const GURL kUrl0("http://www.wikipedia.org/");
 519   const GURL kUrl1("http://www.chromium.org/");
 520   const GURL kUrl1_site = SiteInstance::GetSiteForURL(browser_context(), kUrl1);
 521   const GURL kUrl2("http://www.google.com/");
 522   const GURL kUrl2_site = SiteInstance::GetSiteForURL(browser_context(), kUrl2);
 523
 524   // Initialization.
 525   contents()->NavigateAndCommit(kUrl0);
 526   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 527
 528   // Request navigation to the 1st URL.
 529   process()->sink().ClearMessages();
 530   RequestNavigation(node, kUrl1);
 531   main_test_rfh()->SendBeforeUnloadACK(true);
 532   NavigationRequest* request1 = node->navigation_request();
 533   ASSERT_TRUE(request1);
 534   EXPECT_EQ(kUrl1, request1->common_params().url);
 535   EXPECT_TRUE(request1->browser_initiated());
 536   base::WeakPtr<TestNavigationURLLoader> loader1 =
 537       GetLoaderForNavigationRequest(request1)->AsWeakPtr();
 538   EXPECT_TRUE(loader1);
 539
 540   // Confirm a speculative RenderFrameHost was created.
 541   TestRenderFrameHost* speculative_rfh = GetSpeculativeRenderFrameHost(node);
 542   ASSERT_TRUE(speculative_rfh);
 543   int32 site_instance_id_1 = speculative_rfh->GetSiteInstance()->GetId();
 544   EXPECT_EQ(kUrl1_site, speculative_rfh->GetSiteInstance()->GetSiteURL());
 545
 546   // Request navigation to the 2nd URL; the NavigationRequest must have been
 547   // replaced by a new one with a different URL.
 548   int entry_id = RequestNavigation(node, kUrl2);
 549   main_test_rfh()->SendBeforeUnloadACK(true);
 550   NavigationRequest* request2 = node->navigation_request();
 551   ASSERT_TRUE(request2);
 552   EXPECT_EQ(kUrl2, request2->common_params().url);
 553   EXPECT_TRUE(request2->browser_initiated());
 554
 555   // Confirm that the first loader got destroyed.
 556   EXPECT_FALSE(loader1);
 557
 558   // Confirm that a new speculative RenderFrameHost was created.
 559   speculative_rfh = GetSpeculativeRenderFrameHost(node);
 560   ASSERT_TRUE(speculative_rfh);
 561   int32 site_instance_id_2 = speculative_rfh->GetSiteInstance()->GetId();
 562   EXPECT_NE(site_instance_id_1, site_instance_id_2);
 563
 564   // Have the RenderFrameHost commit the navigation.
 565   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 566   GetLoaderForNavigationRequest(request2)->CallOnResponseStarted(
 567       response, MakeEmptyStream());
 568   EXPECT_TRUE(DidRenderFrameHostRequestCommit(speculative_rfh));
 569   EXPECT_FALSE(DidRenderFrameHostRequestCommit(main_test_rfh()));
 570
 571   // Commit the navigation.
 572   speculative_rfh->SendNavigate(0, entry_id, true, kUrl2);
 573
 574   // Confirm that the commit corresponds to the new request.
 575   ASSERT_TRUE(main_test_rfh());
 576   EXPECT_EQ(kUrl2_site, main_test_rfh()->GetSiteInstance()->GetSiteURL());
 577   EXPECT_EQ(kUrl2, contents()->GetLastCommittedURL());
 578
 579   // Confirm that the committed RenderFrameHost is the latest speculative one.
 580   EXPECT_EQ(site_instance_id_2, main_test_rfh()->GetSiteInstance()->GetId());
 581 }
 582
 583 // PlzNavigate: Test that a browser-initiated navigation is canceled if a
 584 // renderer-initiated user-initiated request has been issued in the meantime.
 585 TEST_F(NavigatorTestWithBrowserSideNavigation,
 586        RendererUserInitiatedNavigationCancel) {
 587   const GURL kUrl0("http://www.wikipedia.org/");
 588   const GURL kUrl1("http://www.chromium.org/");
 589   const GURL kUrl2("http://www.google.com/");
 590
 591   // Initialization.
 592   contents()->NavigateAndCommit(kUrl0);
 593   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 594
 595   // Start a browser-initiated navigation to the 1st URL and receive its
 596   // beforeUnload ACK.
 597   process()->sink().ClearMessages();
 598   RequestNavigation(node, kUrl1);
 599   main_test_rfh()->SendBeforeUnloadACK(true);
 600   NavigationRequest* request1 = node->navigation_request();
 601   ASSERT_TRUE(request1);
 602   EXPECT_EQ(kUrl1, request1->common_params().url);
 603   EXPECT_TRUE(request1->browser_initiated());
 604   base::WeakPtr<TestNavigationURLLoader> loader1 =
 605       GetLoaderForNavigationRequest(request1)->AsWeakPtr();
 606   EXPECT_TRUE(loader1);
 607
 608   // Confirm that a speculative RenderFrameHost was created.
 609   ASSERT_TRUE(GetSpeculativeRenderFrameHost(node));
 610
 611   // Now receive a renderer-initiated user-initiated request. It should replace
 612   // the current NavigationRequest.
 613   main_test_rfh()->SendRendererInitiatedNavigationRequest(kUrl2, true);
 614   NavigationRequest* request2 = node->navigation_request();
 615   ASSERT_TRUE(request2);
 616   EXPECT_EQ(kUrl2, request2->common_params().url);
 617   EXPECT_FALSE(request2->browser_initiated());
 618   EXPECT_TRUE(request2->begin_params().has_user_gesture);
 619
 620   // Confirm that the first loader got destroyed.
 621   EXPECT_FALSE(loader1);
 622
 623   // Confirm that the speculative RenderFrameHost was destroyed.
 624   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 625
 626   // Have the RenderFrameHost commit the navigation.
 627   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 628   GetLoaderForNavigationRequest(request2)
 629       ->CallOnResponseStarted(response, MakeEmptyStream());
 630   EXPECT_TRUE(DidRenderFrameHostRequestCommit(main_test_rfh()));
 631
 632   // Commit the navigation.
 633   main_test_rfh()->SendNavigate(1, 0, true, kUrl2);
 634
 635   // Confirm that the commit corresponds to the new request.
 636   ASSERT_TRUE(main_test_rfh());
 637   EXPECT_EQ(kUrl2, contents()->GetLastCommittedURL());
 638 }
 639
 640 // PlzNavigate: Test that a renderer-initiated user-initiated navigation is NOT
 641 // canceled if a renderer-initiated non-user-initiated request is issued in the
 642 // meantime.
 643 TEST_F(NavigatorTestWithBrowserSideNavigation,
 644        RendererNonUserInitiatedNavigationDoesntCancelRendererUserInitiated) {
 645   const GURL kUrl0("http://www.wikipedia.org/");
 646   const GURL kUrl1("http://www.chromium.org/");
 647   const GURL kUrl2("http://www.google.com/");
 648
 649   // Initialization.
 650   contents()->NavigateAndCommit(kUrl0);
 651   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 652
 653   // Start a renderer-initiated user-initiated navigation to the 1st URL.
 654   process()->sink().ClearMessages();
 655   main_test_rfh()->SendRendererInitiatedNavigationRequest(kUrl1, true);
 656   NavigationRequest* request1 = node->navigation_request();
 657   ASSERT_TRUE(request1);
 658   EXPECT_EQ(kUrl1, request1->common_params().url);
 659   EXPECT_FALSE(request1->browser_initiated());
 660   EXPECT_TRUE(request1->begin_params().has_user_gesture);
 661   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 662
 663   // Now receive a renderer-initiated non-user-initiated request. Nothing should
 664   // change.
 665   main_test_rfh()->SendRendererInitiatedNavigationRequest(kUrl2, false);
 666   NavigationRequest* request2 = node->navigation_request();
 667   ASSERT_TRUE(request2);
 668   EXPECT_EQ(request1, request2);
 669   EXPECT_EQ(kUrl1, request2->common_params().url);
 670   EXPECT_FALSE(request2->browser_initiated());
 671   EXPECT_TRUE(request2->begin_params().has_user_gesture);
 672   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 673
 674   // Have the RenderFrameHost commit the navigation.
 675   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 676   GetLoaderForNavigationRequest(request2)
 677       ->CallOnResponseStarted(response, MakeEmptyStream());
 678   EXPECT_TRUE(DidRenderFrameHostRequestCommit(main_test_rfh()));
 679
 680   // Commit the navigation.
 681   main_test_rfh()->SendNavigate(1, 0, true, kUrl1);
 682   EXPECT_EQ(kUrl1, contents()->GetLastCommittedURL());
 683 }
 684
 685 // PlzNavigate: Test that a browser-initiated navigation is NOT canceled if a
 686 // renderer-initiated non-user-initiated request is issued in the meantime.
 687 TEST_F(NavigatorTestWithBrowserSideNavigation,
 688        RendererNonUserInitiatedNavigationDoesntCancelBrowserInitiated) {
 689   const GURL kUrl0("http://www.wikipedia.org/");
 690   const GURL kUrl1("http://www.chromium.org/");
 691   const GURL kUrl2("http://www.google.com/");
 692
 693   // Initialization.
 694   contents()->NavigateAndCommit(kUrl0);
 695   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 696
 697   // Start a browser-initiated navigation to the 1st URL.
 698   process()->sink().ClearMessages();
 699   int entry_id = RequestNavigation(node, kUrl1);
 700   NavigationRequest* request1 = node->navigation_request();
 701   ASSERT_TRUE(request1);
 702   EXPECT_EQ(kUrl1, request1->common_params().url);
 703   EXPECT_TRUE(request1->browser_initiated());
 704   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 705
 706   // Now receive a renderer-initiated non-user-initiated request. Nothing should
 707   // change.
 708   main_test_rfh()->SendRendererInitiatedNavigationRequest(kUrl2, false);
 709   NavigationRequest* request2 = node->navigation_request();
 710   ASSERT_TRUE(request2);
 711   EXPECT_EQ(request1, request2);
 712   EXPECT_EQ(kUrl1, request2->common_params().url);
 713   EXPECT_TRUE(request2->browser_initiated());
 714   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 715
 716   // Now receive the beforeUnload ACK from the still ongoing navigation.
 717   main_test_rfh()->SendBeforeUnloadACK(true);
 718   TestRenderFrameHost* speculative_rfh = GetSpeculativeRenderFrameHost(node);
 719   ASSERT_TRUE(speculative_rfh);
 720
 721   // Have the RenderFrameHost commit the navigation.
 722   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 723   GetLoaderForNavigationRequest(request2)
 724       ->CallOnResponseStarted(response, MakeEmptyStream());
 725   EXPECT_TRUE(DidRenderFrameHostRequestCommit(speculative_rfh));
 726   EXPECT_FALSE(DidRenderFrameHostRequestCommit(main_test_rfh()));
 727
 728   // Commit the navigation.
 729   speculative_rfh->SendNavigate(0, entry_id, true, kUrl1);
 730   EXPECT_EQ(kUrl1, contents()->GetLastCommittedURL());
 731 }
 732
 733 // PlzNavigate: Test that a renderer-initiated non-user-initiated navigation is
 734 // canceled if a another similar request is issued in the meantime.
 735 TEST_F(NavigatorTestWithBrowserSideNavigation,
 736        RendererNonUserInitiatedNavigationCancelSimilarNavigation) {
 737   const GURL kUrl0("http://www.wikipedia.org/");
 738   const GURL kUrl1("http://www.chromium.org/");
 739   const GURL kUrl2("http://www.google.com/");
 740
 741   // Initialization.
 742   contents()->NavigateAndCommit(kUrl0);
 743   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 744   int32 site_instance_id_0 = main_test_rfh()->GetSiteInstance()->GetId();
 745
 746   // Start a renderer-initiated non-user-initiated navigation to the 1st URL.
 747   process()->sink().ClearMessages();
 748   main_test_rfh()->SendRendererInitiatedNavigationRequest(kUrl1, false);
 749   NavigationRequest* request1 = node->navigation_request();
 750   ASSERT_TRUE(request1);
 751   EXPECT_EQ(kUrl1, request1->common_params().url);
 752   EXPECT_FALSE(request1->browser_initiated());
 753   EXPECT_FALSE(request1->begin_params().has_user_gesture);
 754   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 755   base::WeakPtr<TestNavigationURLLoader> loader1 =
 756       GetLoaderForNavigationRequest(request1)->AsWeakPtr();
 757   EXPECT_TRUE(loader1);
 758
 759   // Now receive a 2nd similar request that should replace the current one.
 760   main_test_rfh()->SendRendererInitiatedNavigationRequest(kUrl2, false);
 761   NavigationRequest* request2 = node->navigation_request();
 762   EXPECT_EQ(kUrl2, request2->common_params().url);
 763   EXPECT_FALSE(request2->browser_initiated());
 764   EXPECT_FALSE(request2->begin_params().has_user_gesture);
 765   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 766
 767   // Confirm that the first loader got destroyed.
 768   EXPECT_FALSE(loader1);
 769
 770   // Have the RenderFrameHost commit the navigation.
 771   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 772   GetLoaderForNavigationRequest(request2)
 773       ->CallOnResponseStarted(response, MakeEmptyStream());
 774   EXPECT_TRUE(DidRenderFrameHostRequestCommit(main_test_rfh()));
 775
 776   // Commit the navigation.
 777   main_test_rfh()->SendNavigate(1, 0, true, kUrl2);
 778   EXPECT_EQ(kUrl2, contents()->GetLastCommittedURL());
 779
 780   // The SiteInstance did not change.
 781   EXPECT_EQ(site_instance_id_0, main_test_rfh()->GetSiteInstance()->GetId());
 782 }
 783
 784 // PlzNavigate: Test that a reload navigation is properly signaled to the
 785 // RenderFrame when the navigation can commit. A speculative RenderFrameHost
 786 // should not be created at any step.
 787 TEST_F(NavigatorTestWithBrowserSideNavigation, Reload) {
 788   const GURL kUrl("http://www.google.com/");
 789   contents()->NavigateAndCommit(kUrl);
 790
 791   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 792   controller().Reload(false);
 793   int entry_id = controller().GetPendingEntry()->GetUniqueID();
 794   // A NavigationRequest should have been generated.
 795   NavigationRequest* main_request = node->navigation_request();
 796   ASSERT_TRUE(main_request != NULL);
 797   EXPECT_EQ(FrameMsg_Navigate_Type::RELOAD,
 798             main_request->common_params().navigation_type);
 799   main_test_rfh()->PrepareForCommit();
 800   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 801
 802   main_test_rfh()->SendNavigate(0, entry_id, false, kUrl);
 803   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 804
 805   // Now do a shift+reload.
 806   controller().ReloadIgnoringCache(false);
 807   // A NavigationRequest should have been generated.
 808   main_request = node->navigation_request();
 809   ASSERT_TRUE(main_request != NULL);
 810   EXPECT_EQ(FrameMsg_Navigate_Type::RELOAD_IGNORING_CACHE,
 811             main_request->common_params().navigation_type);
 812   main_test_rfh()->PrepareForCommit();
 813   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 814 }
 815
 816 // PlzNavigate: Confirm that a speculative RenderFrameHost is used when
 817 // navigating from one site to another.
 818 TEST_F(NavigatorTestWithBrowserSideNavigation,
 819        SpeculativeRendererWorksBaseCase) {
 820   // Navigate to an initial site.
 821   const GURL kUrlInit("http://wikipedia.org/");
 822   contents()->NavigateAndCommit(kUrlInit);
 823   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 824
 825   // Begin navigating to another site.
 826   const GURL kUrl("http://google.com/");
 827   process()->sink().ClearMessages();
 828   int entry_id = RequestNavigation(node, kUrl);
 829   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 830
 831   // Receive the beforeUnload ACK.
 832   main_test_rfh()->SendBeforeUnloadACK(true);
 833   TestRenderFrameHost* speculative_rfh = GetSpeculativeRenderFrameHost(node);
 834   ASSERT_TRUE(speculative_rfh);
 835   EXPECT_NE(speculative_rfh, main_test_rfh());
 836   EXPECT_EQ(SiteInstanceImpl::GetSiteForURL(browser_context(), kUrl),
 837             speculative_rfh->GetSiteInstance()->GetSiteURL());
 838   EXPECT_FALSE(node->render_manager()->pending_frame_host());
 839   int32 site_instance_id = speculative_rfh->GetSiteInstance()->GetId();
 840
 841   // Ask Navigator to commit the navigation by simulating a call to
 842   // OnResponseStarted.
 843   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 844   GetLoaderForNavigationRequest(node->navigation_request())
 845       ->CallOnResponseStarted(response, MakeEmptyStream());
 846   speculative_rfh = GetSpeculativeRenderFrameHost(node);
 847   ASSERT_TRUE(speculative_rfh);
 848   EXPECT_TRUE(DidRenderFrameHostRequestCommit(speculative_rfh));
 849   EXPECT_EQ(site_instance_id, speculative_rfh->GetSiteInstance()->GetId());
 850   EXPECT_FALSE(node->render_manager()->pending_frame_host());
 851
 852   // Invoke OnDidCommitProvisionalLoad.
 853   speculative_rfh->SendNavigate(0, entry_id, true, kUrl);
 854   EXPECT_EQ(site_instance_id, main_test_rfh()->GetSiteInstance()->GetId());
 855   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 856   EXPECT_FALSE(node->render_manager()->pending_frame_host());
 857 }
 858
 859 // PlzNavigate: Confirm that a speculative RenderFrameHost is thrown away when
 860 // the final URL's site differs from the initial one due to redirects.
 861 TEST_F(NavigatorTestWithBrowserSideNavigation,
 862        SpeculativeRendererDiscardedAfterRedirectToAnotherSite) {
 863   // Navigate to an initial site.
 864   const GURL kUrlInit("http://wikipedia.org/");
 865   contents()->NavigateAndCommit(kUrlInit);
 866   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 867   int32 init_site_instance_id = main_test_rfh()->GetSiteInstance()->GetId();
 868
 869   // Begin navigating to another site.
 870   const GURL kUrl("http://google.com/");
 871   process()->sink().ClearMessages();
 872   int entry_id = RequestNavigation(node, kUrl);
 873   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 874
 875   // Receive the beforeUnload ACK.
 876   main_test_rfh()->SendBeforeUnloadACK(true);
 877   TestRenderFrameHost* speculative_rfh = GetSpeculativeRenderFrameHost(node);
 878   int32 site_instance_id = speculative_rfh->GetSiteInstance()->GetId();
 879   EXPECT_NE(init_site_instance_id, site_instance_id);
 880   EXPECT_EQ(init_site_instance_id, main_test_rfh()->GetSiteInstance()->GetId());
 881   ASSERT_TRUE(speculative_rfh);
 882   EXPECT_NE(speculative_rfh, main_test_rfh());
 883   EXPECT_EQ(SiteInstanceImpl::GetSiteForURL(browser_context(), kUrl),
 884             speculative_rfh->GetSiteInstance()->GetSiteURL());
 885
 886   // It then redirects to yet another site.
 887   NavigationRequest* main_request = node->navigation_request();
 888   ASSERT_TRUE(main_request);
 889   const GURL kUrlRedirect("https://www.google.com/");
 890   GetLoaderForNavigationRequest(main_request)
 891       ->SimulateServerRedirect(kUrlRedirect);
 892   EXPECT_EQ(init_site_instance_id, main_test_rfh()->GetSiteInstance()->GetId());
 893   speculative_rfh = GetSpeculativeRenderFrameHost(node);
 894   ASSERT_TRUE(speculative_rfh);
 895
 896   // For now, ensure that the speculative RenderFrameHost does not change after
 897   // the redirect.
 898   // TODO(carlosk): once the speculative RenderFrameHost updates with redirects
 899   // this next check will be changed to verify that it actually happens.
 900   EXPECT_EQ(site_instance_id, speculative_rfh->GetSiteInstance()->GetId());
 901
 902   // Commit the navigation with Navigator by simulating the call to
 903   // OnResponseStarted.
 904   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 905   GetLoaderForNavigationRequest(main_request)
 906       ->CallOnResponseStarted(response, MakeEmptyStream());
 907   speculative_rfh = GetSpeculativeRenderFrameHost(node);
 908   EXPECT_TRUE(DidRenderFrameHostRequestCommit(speculative_rfh));
 909   EXPECT_EQ(init_site_instance_id, main_test_rfh()->GetSiteInstance()->GetId());
 910
 911   // Once commit happens the speculative RenderFrameHost is updated to match the
 912   // known final SiteInstance.
 913   ASSERT_TRUE(speculative_rfh);
 914   EXPECT_EQ(SiteInstanceImpl::GetSiteForURL(browser_context(), kUrlRedirect),
 915             speculative_rfh->GetSiteInstance()->GetSiteURL());
 916   int32 redirect_site_instance_id = speculative_rfh->GetSiteInstance()->GetId();
 917   EXPECT_NE(init_site_instance_id, redirect_site_instance_id);
 918   EXPECT_NE(site_instance_id, redirect_site_instance_id);
 919
 920   // Invoke OnDidCommitProvisionalLoad.
 921   speculative_rfh->SendNavigate(0, entry_id, true, kUrlRedirect);
 922
 923   // Check that the speculative RenderFrameHost was swapped in.
 924   EXPECT_EQ(redirect_site_instance_id,
 925             main_test_rfh()->GetSiteInstance()->GetId());
 926   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 927 }
 928
 929 // PlzNavigate: Verify that a previously swapped out RenderFrameHost is
 930 // correctly reused when spawning a speculative RenderFrameHost in a navigation
 931 // using the same SiteInstance.
 932 TEST_F(NavigatorTestWithBrowserSideNavigation,
 933        SpeculativeRendererReuseSwappedOutRFH) {
 934   // This test doesn't make sense in --site-per-process where swapped out
 935   // RenderFrameHost is no longer used.
 936   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
 937           switches::kSitePerProcess)) {
 938     return;
 939   }
 940
 941   // Navigate to an initial site.
 942   const GURL kUrl1("http://wikipedia.org/");
 943   contents()->NavigateAndCommit(kUrl1);
 944   TestRenderFrameHost* rfh1 = main_test_rfh();
 945   FrameTreeNode* node = rfh1->frame_tree_node();
 946   RenderFrameHostManager* rfhm = node->render_manager();
 947
 948   // Increment active frame count to cause the RenderFrameHost to be swapped out
 949   // (instead of immediately destroyed).
 950   rfh1->GetSiteInstance()->increment_active_frame_count();
 951
 952   // Navigate to another site to swap out the initial RenderFrameHost.
 953   const GURL kUrl2("http://chromium.org/");
 954   contents()->NavigateAndCommit(kUrl2);
 955   ASSERT_NE(rfh1, main_test_rfh());
 956   EXPECT_NE(RenderFrameHostImpl::STATE_DEFAULT, rfh1->rfh_state());
 957   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, main_test_rfh()->rfh_state());
 958   EXPECT_TRUE(rfhm->IsOnSwappedOutList(rfh1));
 959
 960   // Now go back to the initial site so that the swapped out RenderFrameHost
 961   // should be reused.
 962   process()->sink().ClearMessages();
 963   rfh1->GetProcess()->sink().ClearMessages();
 964   int entry_id = RequestNavigation(node, kUrl1);
 965   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
 966
 967   main_test_rfh()->SendBeforeUnloadACK(true);
 968   EXPECT_EQ(rfh1, GetSpeculativeRenderFrameHost(node));
 969   EXPECT_NE(RenderFrameHostImpl::STATE_DEFAULT,
 970             GetSpeculativeRenderFrameHost(node)->rfh_state());
 971
 972   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 973   GetLoaderForNavigationRequest(node->navigation_request())
 974       ->CallOnResponseStarted(response, MakeEmptyStream());
 975   EXPECT_EQ(rfh1, GetSpeculativeRenderFrameHost(node));
 976   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT,
 977             GetSpeculativeRenderFrameHost(node)->rfh_state());
 978   EXPECT_TRUE(DidRenderFrameHostRequestCommit(rfh1));
 979   EXPECT_FALSE(DidRenderFrameHostRequestCommit(main_test_rfh()));
 980
 981   rfh1->SendNavigate(1, entry_id, true, kUrl1);
 982   EXPECT_EQ(rfh1, main_test_rfh());
 983   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, rfh1->rfh_state());
 984   EXPECT_FALSE(rfhm->IsOnSwappedOutList(rfh1));
 985 }
 986
 987 // PlzNavigate: Verify that data urls are properly handled.
 988 TEST_F(NavigatorTestWithBrowserSideNavigation, DataUrls) {
 989   const GURL kUrl1("http://wikipedia.org/");
 990   const GURL kUrl2("data:text/html,test");
 991
 992   // Navigate to an initial site.
 993   contents()->NavigateAndCommit(kUrl1);
 994   FrameTreeNode* node = main_test_rfh()->frame_tree_node();
 995
 996   // Navigate to a data url. The request should not have been sent to the IO
 997   // thread but committed immediately.
 998   int entry_id = RequestNavigation(node, kUrl2);
 999   NavigationRequest* navigation_request = node->navigation_request();
1000   ASSERT_TRUE(navigation_request);
1001   EXPECT_EQ(NavigationRequest::RESPONSE_STARTED,
1002             navigation_request->state());
1003   EXPECT_FALSE(navigation_request->loader_for_testing());
1004   TestRenderFrameHost* speculative_rfh = GetSpeculativeRenderFrameHost(node);
1005   ASSERT_TRUE(speculative_rfh);
1006   speculative_rfh->SendNavigate(0, entry_id, true, kUrl2);
1007   EXPECT_EQ(main_test_rfh(), speculative_rfh);
1008
1009   // Go back to the initial site.
1010   contents()->NavigateAndCommit(kUrl1);
1011
1012   // Do a renderer-initiated navigation to a data url. The request should not be
1013   // sent to the IO thread, nor committed.
1014   TestRenderFrameHost* main_rfh = main_test_rfh();
1015   main_rfh->SendRendererInitiatedNavigationRequest(kUrl2, true);
1016   navigation_request = node->navigation_request();
1017   ASSERT_TRUE(navigation_request);
1018   EXPECT_EQ(NavigationRequest::RESPONSE_STARTED,
1019             navigation_request->state());
1020   EXPECT_FALSE(navigation_request->loader_for_testing());
1021   EXPECT_FALSE(GetSpeculativeRenderFrameHost(node));
1022 }
1023
1024 // Tests several cases for converting SiteInstanceDescriptors into
1025 // SiteInstances:
1026 // 1) Pointer to the current SiteInstance.
1027 // 2) Pointer to an unrelated SiteInstance.
1028 // 3) Same-site URL, related.
1029 // 4) Cross-site URL, related.
1030 // 5) Same-site URL, unrelated (with and without candidate SiteInstances).
1031 // 6) Cross-site URL, unrelated (with candidate SiteInstance).
1032 TEST_F(NavigatorTestWithBrowserSideNavigation,
1033        SiteInstanceDescriptionConversion) {
1034   // Navigate to set a current SiteInstance on the RenderFrameHost.
1035   GURL kUrl1("http://a.com");
1036   contents()->NavigateAndCommit(kUrl1);
1037   SiteInstance* current_instance = main_test_rfh()->GetSiteInstance();
1038   ASSERT_TRUE(current_instance);
1039
1040   // 1) Convert a descriptor pointing to the current instance.
1041   RenderFrameHostManager* rfhm =
1042       main_test_rfh()->frame_tree_node()->render_manager();
1043   {
1044     SiteInstanceDescriptor descriptor(current_instance);
1045     SiteInstance* converted_instance =
1046         ConvertToSiteInstance(rfhm, descriptor, nullptr);
1047     EXPECT_EQ(current_instance, converted_instance);
1048   }
1049
1050   // 2) Convert a descriptor pointing an instance unrelated to the current one,
1051   // with a different site.
1052   GURL kUrl2("http://b.com");
1053   scoped_refptr<SiteInstance> unrelated_instance(
1054       SiteInstance::CreateForURL(browser_context(), kUrl2));
1055   EXPECT_FALSE(
1056       current_instance->IsRelatedSiteInstance(unrelated_instance.get()));
1057   {
1058     SiteInstanceDescriptor descriptor(unrelated_instance.get());
1059     SiteInstance* converted_instance =
1060         ConvertToSiteInstance(rfhm, descriptor, nullptr);
1061     EXPECT_EQ(unrelated_instance.get(), converted_instance);
1062   }
1063
1064   // 3) Convert a descriptor of a related instance with the same site as the
1065   // current one.
1066   GURL kUrlSameSiteAs1("http://www.a.com/foo");
1067   {
1068     SiteInstanceDescriptor descriptor(browser_context(), kUrlSameSiteAs1, true);
1069     SiteInstance* converted_instance =
1070         ConvertToSiteInstance(rfhm, descriptor, nullptr);
1071     EXPECT_EQ(current_instance, converted_instance);
1072   }
1073
1074   // 4) Convert a descriptor of a related instance with a site different from
1075   // the current one.
1076   GURL kUrlSameSiteAs2("http://www.b.com/foo");
1077   scoped_refptr<SiteInstance> related_instance;
1078   {
1079     SiteInstanceDescriptor descriptor(browser_context(), kUrlSameSiteAs2, true);
1080     related_instance = ConvertToSiteInstance(rfhm, descriptor, nullptr);
1081     // Should return a new instance, related to the current, set to the new site
1082     // URL.
1083     EXPECT_TRUE(
1084         current_instance->IsRelatedSiteInstance(related_instance.get()));
1085     EXPECT_NE(current_instance, related_instance.get());
1086     EXPECT_NE(unrelated_instance.get(), related_instance.get());
1087     EXPECT_EQ(SiteInstance::GetSiteForURL(browser_context(), kUrlSameSiteAs2),
1088               related_instance->GetSiteURL());
1089   }
1090
1091   // 5) Convert a descriptor of an unrelated instance with the same site as the
1092   // current one, several times, with and without candidate sites.
1093   {
1094     SiteInstanceDescriptor descriptor(browser_context(), kUrlSameSiteAs1,
1095                                       false);
1096     scoped_refptr<SiteInstance> converted_instance_1 =
1097         ConvertToSiteInstance(rfhm, descriptor, nullptr);
1098     // Should return a new instance, unrelated to the current one, set to the
1099     // provided site URL.
1100     EXPECT_FALSE(
1101         current_instance->IsRelatedSiteInstance(converted_instance_1.get()));
1102     EXPECT_NE(current_instance, converted_instance_1.get());
1103     EXPECT_NE(unrelated_instance.get(), converted_instance_1.get());
1104     EXPECT_EQ(SiteInstance::GetSiteForURL(browser_context(), kUrlSameSiteAs1),
1105               converted_instance_1->GetSiteURL());
1106
1107     // Does the same but this time using unrelated_instance as a candidate,
1108     // which has a different site.
1109     scoped_refptr<SiteInstance> converted_instance_2 =
1110         ConvertToSiteInstance(rfhm, descriptor, unrelated_instance.get());
1111     // Should return yet another new instance, unrelated to the current one, set
1112     // to the same site URL.
1113     EXPECT_FALSE(
1114         current_instance->IsRelatedSiteInstance(converted_instance_2.get()));
1115     EXPECT_NE(current_instance, converted_instance_2.get());
1116     EXPECT_NE(unrelated_instance.get(), converted_instance_2.get());
1117     EXPECT_NE(converted_instance_1.get(), converted_instance_2.get());
1118     EXPECT_EQ(SiteInstance::GetSiteForURL(browser_context(), kUrlSameSiteAs1),
1119               converted_instance_2->GetSiteURL());
1120
1121     // Converts once more but with |converted_instance_1| as a candidate.
1122     SiteInstance* converted_instance_3 =
1123         ConvertToSiteInstance(rfhm, descriptor, converted_instance_1.get());
1124     // Should return |converted_instance_1| because its site matches and it is
1125     // unrelated to the current SiteInstance.
1126     EXPECT_EQ(converted_instance_1.get(), converted_instance_3);
1127   }
1128
1129   // 6) Convert a descriptor of an unrelated instance with the same site of
1130   // related_instance and using it as a candidate.
1131   {
1132     SiteInstanceDescriptor descriptor(browser_context(), kUrlSameSiteAs2,
1133                                       false);
1134     scoped_refptr<SiteInstance> converted_instance_1 =
1135         ConvertToSiteInstance(rfhm, descriptor, related_instance.get());
1136     // Should return a new instance, unrelated to the current, set to the
1137     // provided site URL.
1138     EXPECT_FALSE(
1139         current_instance->IsRelatedSiteInstance(converted_instance_1.get()));
1140     EXPECT_NE(related_instance.get(), converted_instance_1.get());
1141     EXPECT_NE(unrelated_instance.get(), converted_instance_1.get());
1142     EXPECT_EQ(SiteInstance::GetSiteForURL(browser_context(), kUrlSameSiteAs2),
1143               converted_instance_1->GetSiteURL());
1144
1145     SiteInstance* converted_instance_2 =
1146         ConvertToSiteInstance(rfhm, descriptor, unrelated_instance.get());
1147     // Should return |unrelated_instance| because its site matches and it is
1148     // unrelated to the current SiteInstance.
1149     EXPECT_EQ(unrelated_instance.get(), converted_instance_2);
1150   }
1151 }
1152
1153 }  // namespace content