Initial PlzNavigate RDH-side logic.

content/browser/frame_host/render_frame_host_manager_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/command_line.h"
 #include "base/files/file_path.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_before_commit_info.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_request.h"
 #include "content/browser/frame_host/navigator.h"
 #include "content/browser/frame_host/navigator_impl.h"
 #include "content/browser/frame_host/render_frame_host_manager.h"
+#include "content/browser/loader/navigation_url_loader.h"
+#include "content/browser/loader/navigation_url_loader_factory.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/browser/webui/web_ui_controller_factory_registry.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host_iterator.h"
+#include "content/public/browser/stream_handle.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_ui_controller.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/javascript_message_type.h"
 #include "content/public/common/page_transition_types.h"
+#include "content/public/common/resource_response.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/url_utils.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_notification_tracker.h"
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_content_client.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 "testing/gtest/include/gtest/gtest.h"
@@ skipping 203 matching lines @@
     return base::StringPrintf(
         "(%d, %d -> %s )",
         render_frame_host->GetProcess()->GetID(),
         render_frame_host->GetRoutingID(),
         render_frame_host->GetSiteInstance()->GetSiteURL().spec().c_str());
   }
   std::set<std::pair<int, int> > live_routes_;
   std::set<std::pair<int, int> > deleted_routes_;
 };
 
+class TestNavigationURLLoader : public NavigationURLLoader {
+ public:
+  TestNavigationURLLoader(BrowserContext* browser_context,
+                          int64 frame_tree_node_id,
+                          const NavigationRequestInfo& request_info,
+                          ResourceRequestBody* request_body,
+                          NavigationURLLoader::Delegate* delegate)
+      : delegate_(delegate) {
+  }
+
+  virtual ~TestNavigationURLLoader() {
+    // Record the number of times a loader was canceled before ResponseStarted
+    // or RequestFailed was returned.
+    if (delegate_)
+      cancel_count_++;
+  }
+
+  // NavigationURLLoader implementation.
+  virtual void FollowRedirect() OVERRIDE { }
+
+  void CallOnResponseStarted(ResourceResponse* response,
+                             scoped_ptr<StreamHandle> body) {
+    delegate_->OnResponseStarted(response, body.Pass());
+    delegate_ = NULL;
+  }
+
+  static int cancel_count() { return cancel_count_; }
+
+ private:
+  static int cancel_count_;
+  NavigationURLLoader::Delegate* delegate_;
+};
+
+int TestNavigationURLLoader::cancel_count_ = 0;
+
+class TestNavigationURLLoaderFactory : public NavigationURLLoaderFactory {
+ public:
+  // NavigationURLLoaderFactory implementation.
+  virtual NavigationURLLoader* CreateLoader(
+      BrowserContext* browser_context,
+      int64 frame_tree_node_id,
+      const NavigationRequestInfo& request_info,
+      ResourceRequestBody* request_body,
+      NavigationURLLoader::Delegate* delegate) OVERRIDE {
+    return new TestNavigationURLLoader(
+        browser_context, frame_tree_node_id, request_info, request_body,
+        delegate);
+  }
+};
+
 }  // namespace
 
 class RenderFrameHostManagerTest
     : public RenderViewHostImplTestHarness {
  public:
   virtual void SetUp() OVERRIDE {
     RenderViewHostImplTestHarness::SetUp();
     WebUIControllerFactory::RegisterFactory(&factory_);
     lifetime_checker_.reset(new FrameLifetimeConsistencyChecker(contents()));
+    loader_factory_.reset(new TestNavigationURLLoaderFactory);
+    NavigationURLLoader::SetFactoryForTesting(loader_factory_.get());
   }
 
   virtual void TearDown() OVERRIDE {
+    NavigationURLLoader::SetFactoryForTesting(NULL);
+    loader_factory_.reset();
     lifetime_checker_.reset();
     RenderViewHostImplTestHarness::TearDown();
     WebUIControllerFactory::UnregisterFactoryForTesting(&factory_);
   }
 
   void set_should_create_webui(bool should_create_webui) {
     factory_.set_should_create_webui(should_create_webui);
   }
 
   void NavigateActiveAndCommit(const GURL& url) {
@@ skipping 98 matching lines @@
 
     EXPECT_TRUE(ntp_rfh->GetRenderViewHost()->IsSwappedOut());
     return ntp_rfh->GetRenderViewHost();
   }
 
   NavigationRequest* GetNavigationRequestForRenderFrameManager(
       RenderFrameHostManager* manager) const {
     return manager->navigation_request_for_testing();
   }
 
+  TestNavigationURLLoader* GetLoaderForNavigationRequest(
+      NavigationRequest* request) const {
+    return static_cast<TestNavigationURLLoader*>(request->loader_for_testing());
+  }
+
   void EnableBrowserSideNavigation() {
     CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kEnableBrowserSideNavigation);
   }
  private:
   RenderFrameHostManagerTestWebUIControllerFactory factory_;
   scoped_ptr<FrameLifetimeConsistencyChecker> lifetime_checker_;
+  scoped_ptr<TestNavigationURLLoaderFactory> loader_factory_;
 };
 
 // Tests that when you navigate from a chrome:// url to another page, and
 // then do that same thing in another tab, that the two resulting pages have
 // different SiteInstances, BrowsingInstances, and RenderProcessHosts. This is
 // a regression test for bug 9364.
 TEST_F(RenderFrameHostManagerTest, NewTabPageProcesses) {
   set_should_create_webui(true);
   const GURL kChromeUrl("chrome://foo");
   const GURL kDestUrl("http://www.google.com/");
@@ skipping 1288 matching lines @@
     EXPECT_FALSE(rvh_deleted_observer.deleted());
   }
 }
 
 // PlzNavigate: Test that a proper NavigationRequest is created by
 // BeginNavigation.
 TEST_F(RenderFrameHostManagerTest, BrowserSideNavigationBeginNavigation) {
   const GURL kUrl1("http://www.google.com/");
   const GURL kUrl2("http://www.chromium.org/");
   const GURL kUrl3("http://www.gmail.com/");
-  const int64 kFirstNavRequestID = 1;
 
   // TODO(clamy): we should be enabling browser side navigations here
   // when CommitNavigation is properly implemented.
   // Navigate to the first page.
   contents()->NavigateAndCommit(kUrl1);
 
   EnableBrowserSideNavigation();
   // Add a subframe.
   TestRenderFrameHost* subframe_rfh = static_cast<TestRenderFrameHost*>(
       contents()->GetFrameTree()->AddFrame(
           contents()->GetFrameTree()->root(), 14, "Child"));
 
   // Simulate a BeginNavigation IPC on the subframe.
   subframe_rfh->SendBeginNavigationWithURL(kUrl2);
   NavigationRequest* subframe_request =
       GetNavigationRequestForRenderFrameManager(
           subframe_rfh->frame_tree_node()->render_manager());
   ASSERT_TRUE(subframe_request);
   EXPECT_EQ(kUrl2, subframe_request->info().navigation_params.url);
   // First party for cookies url should be that of the main frame.
   EXPECT_EQ(
       kUrl1, subframe_request->info().first_party_for_cookies);
   EXPECT_FALSE(subframe_request->info().is_main_frame);
   EXPECT_TRUE(subframe_request->info().parent_is_main_frame);
-  EXPECT_EQ(kFirstNavRequestID, subframe_request->navigation_request_id());
 
   // Simulate a BeginNavigation IPC on the main frame.
   contents()->GetMainFrame()->SendBeginNavigationWithURL(kUrl3);
   NavigationRequest* main_request = GetNavigationRequestForRenderFrameManager(
       contents()->GetMainFrame()->frame_tree_node()->render_manager());
   ASSERT_TRUE(main_request);
   EXPECT_EQ(kUrl3, main_request->info().navigation_params.url);
   EXPECT_EQ(kUrl3, main_request->info().first_party_for_cookies);
   EXPECT_TRUE(main_request->info().is_main_frame);
   EXPECT_FALSE(main_request->info().parent_is_main_frame);
-  EXPECT_EQ(kFirstNavRequestID + 1, main_request->navigation_request_id());
 }
 
 // PlzNavigate: Test that RequestNavigation creates a NavigationRequest and that
 // RenderFrameHost is not modified when the navigation commits.
 TEST_F(RenderFrameHostManagerTest,
        BrowserSideNavigationRequestNavigationNoLiveRenderer) {
   const GURL kUrl("http://www.google.com/");
 
   EnableBrowserSideNavigation();
   EXPECT_FALSE(main_test_rfh()->render_view_host()->IsRenderViewLive());
   contents()->GetController().LoadURL(
       kUrl, Referrer(), PAGE_TRANSITION_LINK, std::string());
   RenderFrameHostManager* render_manager =
       main_test_rfh()->frame_tree_node()->render_manager();
   NavigationRequest* main_request =
       GetNavigationRequestForRenderFrameManager(render_manager);
   // A NavigationRequest should have been generated.
   EXPECT_TRUE(main_request != NULL);
   RenderFrameHostImpl* rfh = main_test_rfh();
 
   // Now commit the same url.
-  NavigationBeforeCommitInfo commit_info;
-  commit_info.navigation_url = kUrl;
-  commit_info.navigation_request_id = main_request->navigation_request_id();
-  render_manager->CommitNavigation(commit_info);
-  main_request = GetNavigationRequestForRenderFrameManager(render_manager);
+  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  GetLoaderForNavigationRequest(main_request)->CallOnResponseStarted(
+      response.get(), scoped_ptr<StreamHandle>());
 
   // The main RFH should not have been changed, and the renderer should have
   // been initialized.
   EXPECT_EQ(rfh, main_test_rfh());
   EXPECT_TRUE(main_test_rfh()->render_view_host()->IsRenderViewLive());
 }
 
 // PlzNavigate: Test that a new RenderFrameHost is created when doing a cross
 // site navigation.
 TEST_F(RenderFrameHostManagerTest,
@@ skipping 11 matching lines @@
   RenderFrameHostManager* render_manager =
       main_test_rfh()->frame_tree_node()->render_manager();
 
   EnableBrowserSideNavigation();
   // Navigate to a different site.
   main_test_rfh()->SendBeginNavigationWithURL(kUrl2);
   NavigationRequest* main_request =
       GetNavigationRequestForRenderFrameManager(render_manager);
   ASSERT_TRUE(main_request);
 
-  NavigationBeforeCommitInfo commit_info;
-  commit_info.navigation_url = kUrl2;
-  commit_info.navigation_request_id = main_request->navigation_request_id();
-  render_manager->CommitNavigation(commit_info);
+  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  GetLoaderForNavigationRequest(main_request)->CallOnResponseStarted(
+      response.get(), scoped_ptr<StreamHandle>());
   EXPECT_NE(main_test_rfh(), rfh);
   EXPECT_TRUE(main_test_rfh()->render_view_host()->IsRenderViewLive());
 }
 
-// PlzNavigate: Test that a navigation commit is ignored if another request has
-// been issued in the meantime.
-// TODO(carlosk): add checks to assert that the cancel call was sent to
-// ResourceDispatcherHost in the IO thread by extending
-// ResourceDispatcherHostDelegate (like in cross_site_transfer_browsertest.cc
-// and plugin_browsertest.cc).
+// PlzNavigate: Test that a navigation is cancelled if another request has been
+// issued in the meantime.
 TEST_F(RenderFrameHostManagerTest,
-       BrowserSideNavigationIgnoreStaleNavigationCommit) {
+       BrowserSideNavigationReplacePendingNavigation) {
   const GURL kUrl0("http://www.wikipedia.org/");
   const GURL kUrl0_site = SiteInstance::GetSiteForURL(browser_context(), kUrl0);
   const GURL kUrl1("http://www.chromium.org/");
   const GURL kUrl2("http://www.google.com/");
   const GURL kUrl2_site = SiteInstance::GetSiteForURL(browser_context(), kUrl2);
 
   // Initialization.
   contents()->NavigateAndCommit(kUrl0);
   RenderFrameHostManager* render_manager =
       main_test_rfh()->frame_tree_node()->render_manager();
   EnableBrowserSideNavigation();
   EXPECT_EQ(kUrl0_site, main_test_rfh()->GetSiteInstance()->GetSiteURL());
 
   // Request navigation to the 1st URL and gather data.
   main_test_rfh()->SendBeginNavigationWithURL(kUrl1);
   NavigationRequest* request1 =
       GetNavigationRequestForRenderFrameManager(render_manager);
   ASSERT_TRUE(request1);
-  int64 request_id1 = request1->navigation_request_id();
+  int cancel_count = TestNavigationURLLoader::cancel_count();
 
   // Request navigation to the 2nd URL and gather more data.
   main_test_rfh()->SendBeginNavigationWithURL(kUrl2);
   NavigationRequest* request2 =
       GetNavigationRequestForRenderFrameManager(render_manager);
   ASSERT_TRUE(request2);
-  int64 request_id2 = request2->navigation_request_id();
-  EXPECT_NE(request_id1, request_id2);
 
-  // Confirms that a stale commit is ignored by the RHFM.
-  NavigationBeforeCommitInfo nbc_info;
-  nbc_info.navigation_url = kUrl1;
-  nbc_info.navigation_request_id = request_id1;
-  render_manager->CommitNavigation(nbc_info);
-  EXPECT_EQ(kUrl0_site, main_test_rfh()->GetSiteInstance()->GetSiteURL());
+  // Confirm that the first request got canceled.
+  EXPECT_EQ(cancel_count + 1, TestNavigationURLLoader::cancel_count());

[clamy, 2014/09/12 20:51:25]

We do not test anymore that a call to OnResponseStarted on the old
NavigationURLLoader will not lead to a commit in RenderFrameHostManager. This is
mainly what we were trying to test here (to avoid the Cancelation-Commit race
between the UI and the IO thread).

[davidben, 2014/09/19 18:30:49]

That's true. It got split over two tests. This tests that we cancel the loader
on the UI thread. The loader tests assert that loader cancel stops calls on the
delegate. I've added a test to test the race that may happen.

 
   // Confirms that a valid, request-matching commit is correctly processed.
-  nbc_info.navigation_url = kUrl2;
-  nbc_info.navigation_request_id = request_id2;
-  render_manager->CommitNavigation(nbc_info);
+  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  GetLoaderForNavigationRequest(request2)->CallOnResponseStarted(
+      response.get(), scoped_ptr<StreamHandle>());
   EXPECT_EQ(kUrl2_site, main_test_rfh()->GetSiteInstance()->GetSiteURL());
 }
 
 }  // namespace content