PlzNavigate: implement CommitNavigation on the browser side

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/test/histogram_tester.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/navigation_request_info.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/frame_host/render_frame_proxy_host.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/browser/webui/web_ui_controller_factory_registry.h"
+#include "content/common/navigation_params.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/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/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 "net/base/load_flags.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/page_transition_types.h"
 
 namespace content {
 namespace {
 
 class RenderFrameHostManagerTestWebUIControllerFactory
     : public WebUIControllerFactory {
  public:
   RenderFrameHostManagerTestWebUIControllerFactory()
@@ skipping 334 matching lines @@
 
   NavigationRequest* GetNavigationRequestForRenderFrameManager(
       RenderFrameHostManager* manager) const {
     return manager->navigation_request_for_testing();
   }
 
   void EnableBrowserSideNavigation() {
     CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kEnableBrowserSideNavigation);
   }
+
+  void SendRequestNavigation(FrameTreeNode* node,
+                             const GURL& url) {
+    SendRequestNavigationWithParameters(
+        node, url, Referrer(), ui::PAGE_TRANSITION_LINK,
+        FrameMsg_Navigate_Type::NORMAL);
+  }
+
+  void SendRequestNavigationWithParameters(
+      FrameTreeNode* node,
+      const GURL& url,
+      const Referrer& referrer,
+      ui::PageTransition transition_type,
+      FrameMsg_Navigate_Type::Value navigation_type) {
+    scoped_ptr<NavigationEntryImpl> entry(
+        NavigationEntryImpl::FromNavigationEntry(
+            NavigationController::CreateNavigationEntry(
+                url,
+                referrer,
+                transition_type,
+                false,
+                std::string(),
+                controller().GetBrowserContext())));
+    scoped_ptr<NavigationRequest> navigation_request(new NavigationRequest(
+        node->frame_tree_node_id(),
+        CommonNavigationParams(entry->GetURL(),
+                               entry->GetReferrer(),
+                               entry->GetTransitionType(),
+                               navigation_type,
+                               !entry->IsViewSourceMode()),
+        CommitNavigationParams(entry->GetPageState(),
+                               entry->GetIsOverridingUserAgent(),
+                               base::TimeTicks::Now())));
+    RequestNavigationParams request_params(
+        entry->GetHasPostData(),
+        entry->extra_headers(),
+        entry->GetBrowserInitiatedPostData());
+    node->render_manager()->RequestNavigation(navigation_request.Pass(),
+                                              request_params);
+  }
+
  private:
   RenderFrameHostManagerTestWebUIControllerFactory factory_;
   scoped_ptr<FrameLifetimeConsistencyChecker> lifetime_checker_;
 };
 
 // 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) {
@@ skipping 1294 matching lines @@
 
     contents()->GetMainFrame()->OnMessageReceived(
         FrameHostMsg_BeforeUnload_ACK(0, false, now, now));
     EXPECT_FALSE(contents()->cross_navigation_pending());
     EXPECT_FALSE(rfh_deleted_observer.deleted());
   }
 }
 
 // PlzNavigate: Test that a proper NavigationRequest is created by
 // BeginNavigation.
+// Note that all PlzNavigate methods on the browser side require the use of the
+// flag kEnableBrowserSideNavigation.
 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"));
 
+  RenderFrameHostManager* subframe_manager =
+      subframe_rfh->frame_tree_node()->render_manager();
+  SendRequestNavigation(subframe_rfh->frame_tree_node(), kUrl2);
   // Simulate a BeginNavigation IPC on the subframe.
   subframe_rfh->SendBeginNavigationWithURL(kUrl2);
   NavigationRequest* subframe_request =
-      GetNavigationRequestForRenderFrameManager(
-          subframe_rfh->frame_tree_node()->render_manager());
+      GetNavigationRequestForRenderFrameManager(subframe_manager);
   ASSERT_TRUE(subframe_request);
-  EXPECT_EQ(kUrl2, subframe_request->info().navigation_params.url);
+  EXPECT_EQ(kUrl2, subframe_request->common_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(kUrl1, subframe_request->info_for_test()->first_party_for_cookies);
+  EXPECT_FALSE(subframe_request->info_for_test()->is_main_frame);
+  EXPECT_TRUE(subframe_request->info_for_test()->parent_is_main_frame);
   EXPECT_EQ(kFirstNavRequestID, subframe_request->navigation_request_id());
 
+  RenderFrameHostManager* main_frame_manager =
+      contents()->GetMainFrame()->frame_tree_node()->render_manager();
+  SendRequestNavigation(contents()->GetMainFrame()->frame_tree_node(), kUrl3);
   // Simulate a BeginNavigation IPC on the main frame.
   contents()->GetMainFrame()->SendBeginNavigationWithURL(kUrl3);
-  NavigationRequest* main_request = GetNavigationRequestForRenderFrameManager(
-      contents()->GetMainFrame()->frame_tree_node()->render_manager());
+  NavigationRequest* main_request =
+      GetNavigationRequestForRenderFrameManager(main_frame_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(kUrl3, main_request->common_params().url);
+  EXPECT_EQ(kUrl3, main_request->info_for_test()->first_party_for_cookies);
+  EXPECT_TRUE(main_request->info_for_test()->is_main_frame);
+  EXPECT_FALSE(main_request->info_for_test()->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(), ui::PAGE_TRANSITION_LINK, std::string());
   RenderFrameHostManager* render_manager =
       main_test_rfh()->frame_tree_node()->render_manager();
+  SendRequestNavigation(main_test_rfh()->frame_tree_node(), kUrl);
   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();
@@ skipping 18 matching lines @@
   // when CommitNavigation is properly implemented.
   // Navigate to the first page.
   contents()->NavigateAndCommit(kUrl1);
   RenderFrameHostImpl* rfh = main_test_rfh();
   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, rfh->rfh_state());
   RenderFrameHostManager* render_manager =
       main_test_rfh()->frame_tree_node()->render_manager();
 
   EnableBrowserSideNavigation();
   // Navigate to a different site.
+  SendRequestNavigation(main_test_rfh()->frame_tree_node(), kUrl2);
   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);
   EXPECT_NE(main_test_rfh(), rfh);
@@ skipping 16 matching lines @@
   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.
+  SendRequestNavigation(main_test_rfh()->frame_tree_node(), kUrl1);
   main_test_rfh()->SendBeginNavigationWithURL(kUrl1);
   NavigationRequest* request1 =
       GetNavigationRequestForRenderFrameManager(render_manager);
   ASSERT_TRUE(request1);
   int64 request_id1 = request1->navigation_request_id();
 
   // Request navigation to the 2nd URL and gather more data.
+  SendRequestNavigation(main_test_rfh()->frame_tree_node(), kUrl2);
   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;
@@ skipping 27 matching lines @@
       main_test_rfh()->GetSiteInstance());
   main_test_rfh()->SendNavigate(new_page_id, kUrl0);
   histo_tester.ExpectTotalCount("Navigation.TimeToCommit", 1);
 
   // Performs a PlzNavigate navigation
   EnableBrowserSideNavigation();
   contents()->NavigateAndCommit(kUrl1);
   histo_tester.ExpectTotalCount("Navigation.TimeToCommit", 2);
 }
 
+// PlzNavigate: Test that a reload navigation is properly signaled to the
+// renderer when the navigation can commit.
+TEST_F(RenderFrameHostManagerTest, BrowserSideNavigationReload) {
+  const GURL kUrl("http://www.google.com/");
+  contents()->NavigateAndCommit(kUrl);
+
+  EnableBrowserSideNavigation();
+  RenderFrameHostManager* render_manager =
+      main_test_rfh()->frame_tree_node()->render_manager();
+  SendRequestNavigationWithParameters(
+      main_test_rfh()->frame_tree_node(), kUrl, Referrer(),
+      ui::PAGE_TRANSITION_LINK, FrameMsg_Navigate_Type::RELOAD);
+  contents()->GetMainFrame()->SendBeginNavigationWithURL(kUrl);
+  // A NavigationRequest should have been generated.
+  NavigationRequest* main_request =
+      GetNavigationRequestForRenderFrameManager(render_manager);
+  ASSERT_TRUE(main_request != NULL);
+  EXPECT_EQ(FrameMsg_Navigate_Type::RELOAD,
+            main_request->common_params().navigation_type);
+  int page_id = contents()->GetMaxPageIDForSiteInstance(
+                    main_test_rfh()->GetSiteInstance()) + 1;
+  main_test_rfh()->SendNavigate(page_id, kUrl);
+
+  // Now do a shift+reload.
+  SendRequestNavigationWithParameters(
+      main_test_rfh()->frame_tree_node(),
+      kUrl,
+      Referrer(),
+      ui::PAGE_TRANSITION_LINK,
+      FrameMsg_Navigate_Type::RELOAD_IGNORING_CACHE);
+  contents()->GetMainFrame()->SendBeginNavigationWithURL(kUrl);
+  // A NavigationRequest should have been generated.
+  main_request = GetNavigationRequestForRenderFrameManager(render_manager);
+  ASSERT_TRUE(main_request != NULL);
+  EXPECT_EQ(FrameMsg_Navigate_Type::RELOAD_IGNORING_CACHE,
+            main_request->common_params().navigation_type);
+}
+
 }  // namespace content