Convert HistoryTabHelper to use the new navigation callbacks.

content/renderer/render_view_browsertest.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 #include <tuple>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 1980 matching lines @@
 
 // Checks that when a navigation starts in the renderer, |navigation_start| is
 // recorded at an appropriate time and is passed in the corresponding message.
 TEST_F(RenderViewImplTest, RendererNavigationStartTransmittedToBrowser) {
   base::TimeTicks lower_bound_navigation_start(base::TimeTicks::Now());
   frame()->GetWebFrame()->loadHTMLString(
       "hello world", blink::WebURL(GURL("data:text/html,")));
 
   FrameHostMsg_DidStartProvisionalLoad::Param host_nav_params =
       ProcessAndReadIPC<FrameHostMsg_DidStartProvisionalLoad>();
-  base::TimeTicks transmitted_start = std::get<1>(host_nav_params);
+  base::TimeTicks transmitted_start = std::get<2>(host_nav_params);
   EXPECT_FALSE(transmitted_start.is_null());
   EXPECT_LE(lower_bound_navigation_start, transmitted_start);
 }
 
 // Checks that a browser-initiated navigation in an initial document that was
 // not accessed uses browser-side timestamp.
 // This test assumes that |frame()| contains an unaccessed initial document at
 // start.
 TEST_F(RenderViewImplTest, BrowserNavigationStart) {
   auto common_params = MakeCommonNavigationParams(-TimeDelta::FromSeconds(1));
 
   frame()->Navigate(common_params, StartNavigationParams(),
                     RequestNavigationParams());
   FrameHostMsg_DidStartProvisionalLoad::Param nav_params =
       ProcessAndReadIPC<FrameHostMsg_DidStartProvisionalLoad>();
-  EXPECT_EQ(common_params.navigation_start, std::get<1>(nav_params));
+  EXPECT_EQ(common_params.navigation_start, std::get<2>(nav_params));
 }
 
 // Sanity check for the Navigation Timing API |navigationStart| override. We
 // are asserting only most basic constraints, as TimeTicks (passed as the
 // override) are not comparable with the wall time (returned by the Blink API).
 TEST_F(RenderViewImplTest, BrowserNavigationStartSanitized) {
   // Verify that a navigation that claims to have started in the future - 42
   // days from now is *not* reported as one that starts in the future; as we
   // sanitize the override allowing a maximum of ::Now().
   auto late_common_params = MakeCommonNavigationParams(TimeDelta::FromDays(42));
@@ skipping 19 matching lines @@
   // Trigger a didAccessInitialDocument notification.
   ExecuteJavaScriptForTests("document.title = 'Hi!';");
 
   auto common_params = MakeCommonNavigationParams(-TimeDelta::FromSeconds(1));
   frame()->Navigate(common_params, StartNavigationParams(),
                     RequestNavigationParams());
 
   FrameHostMsg_DidStartProvisionalLoad::Param nav_params =
       ProcessAndReadIPC<FrameHostMsg_DidStartProvisionalLoad>();
   if (!IsBrowserSideNavigationEnabled())
-    EXPECT_GT(std::get<1>(nav_params), common_params.navigation_start);
+    EXPECT_GT(std::get<2>(nav_params), common_params.navigation_start);
   else
-    EXPECT_EQ(common_params.navigation_start, std::get<1>(nav_params));
+    EXPECT_EQ(common_params.navigation_start, std::get<2>(nav_params));
 }
 
 TEST_F(RenderViewImplTest, NavigationStartForReload) {
   const char url_string[] = "data:text/html,<div>Page</div>";
   // Navigate once, then reload.
   LoadHTML(url_string);
   ProcessPendingMessages();
   render_thread_->sink().ClearMessages();
 
   CommonNavigationParams common_params;
   common_params.url = GURL(url_string);
   common_params.navigation_type =
       FrameMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL;
   common_params.transition = ui::PAGE_TRANSITION_RELOAD;
 
   // The browser navigation_start should not be used because beforeunload will
   // be fired during Navigate.
   frame()->Navigate(common_params, StartNavigationParams(),
                     RequestNavigationParams());
 
   FrameHostMsg_DidStartProvisionalLoad::Param host_nav_params =
       ProcessAndReadIPC<FrameHostMsg_DidStartProvisionalLoad>();
 
   if (!IsBrowserSideNavigationEnabled()) {
     // The browser navigation_start should not be used because beforeunload was
     // fired during Navigate.
-    EXPECT_PRED2(TimeTicksGT, std::get<1>(host_nav_params),
+    EXPECT_PRED2(TimeTicksGT, std::get<2>(host_nav_params),
                  common_params.navigation_start);
   } else {
     // PlzNavigate: the browser navigation_start is always used.
-    EXPECT_EQ(common_params.navigation_start, std::get<1>(host_nav_params));
+    EXPECT_EQ(common_params.navigation_start, std::get<2>(host_nav_params));
   }
 }
 
 TEST_F(RenderViewImplTest, NavigationStartForSameProcessHistoryNavigation) {
   LoadHTML("<div id=pagename>Page A</div>");
   LoadHTML("<div id=pagename>Page B</div>");
   PageState back_state = GetCurrentPageState();
   LoadHTML("<div id=pagename>Page C</div>");
   PageState forward_state = GetCurrentPageState();
   ProcessPendingMessages();
   render_thread_->sink().ClearMessages();
 
   // Go back.
   CommonNavigationParams common_params_back;
   common_params_back.url =
       GURL("data:text/html;charset=utf-8,<div id=pagename>Page B</div>");
   common_params_back.transition = ui::PAGE_TRANSITION_FORWARD_BACK;
   GoToOffsetWithParams(-1, back_state, common_params_back,
                        StartNavigationParams(), RequestNavigationParams());
   FrameHostMsg_DidStartProvisionalLoad::Param host_nav_params =
       ProcessAndReadIPC<FrameHostMsg_DidStartProvisionalLoad>();
   if (!IsBrowserSideNavigationEnabled()) {
     // The browser navigation_start should not be used because beforeunload was
     // fired during GoToOffsetWithParams.
-    EXPECT_PRED2(TimeTicksGT, std::get<1>(host_nav_params),
+    EXPECT_PRED2(TimeTicksGT, std::get<2>(host_nav_params),
                  common_params_back.navigation_start);
   } else {
     // PlzNavigate: the browser navigation_start is always used.
     EXPECT_EQ(common_params_back.navigation_start,
-              std::get<1>(host_nav_params));
+              std::get<2>(host_nav_params));
   }
   render_thread_->sink().ClearMessages();
 
   // Go forward.
   CommonNavigationParams common_params_forward;
   common_params_forward.url =
       GURL("data:text/html;charset=utf-8,<div id=pagename>Page C</div>");
   common_params_forward.transition = ui::PAGE_TRANSITION_FORWARD_BACK;
   GoToOffsetWithParams(1, forward_state, common_params_forward,
                        StartNavigationParams(), RequestNavigationParams());
   FrameHostMsg_DidStartProvisionalLoad::Param host_nav_params2 =
       ProcessAndReadIPC<FrameHostMsg_DidStartProvisionalLoad>();
   if (!IsBrowserSideNavigationEnabled()) {
-    EXPECT_PRED2(TimeTicksGT, std::get<1>(host_nav_params2),
+    EXPECT_PRED2(TimeTicksGT, std::get<2>(host_nav_params2),
                  common_params_forward.navigation_start);
   } else {
     EXPECT_EQ(common_params_forward.navigation_start,
-              std::get<1>(host_nav_params2));
+              std::get<2>(host_nav_params2));
   }
 }
 
 TEST_F(RenderViewImplTest, NavigationStartForCrossProcessHistoryNavigation) {
   auto common_params = MakeCommonNavigationParams(-TimeDelta::FromSeconds(1));
   common_params.transition = ui::PAGE_TRANSITION_FORWARD_BACK;
 
   RequestNavigationParams request_params;
   request_params.page_state =
       PageState::CreateForTesting(common_params.url, false, nullptr, nullptr);
   request_params.nav_entry_id = 42;
   request_params.pending_history_list_offset = 1;
   request_params.current_history_list_offset = 0;
   request_params.current_history_list_length = 1;
   frame()->Navigate(common_params, StartNavigationParams(), request_params);
 
   FrameHostMsg_DidStartProvisionalLoad::Param host_nav_params =
       ProcessAndReadIPC<FrameHostMsg_DidStartProvisionalLoad>();
-  EXPECT_EQ(std::get<1>(host_nav_params), common_params.navigation_start);
+  EXPECT_EQ(std::get<2>(host_nav_params), common_params.navigation_start);
 }
 
 TEST_F(RenderViewImplTest, PreferredSizeZoomed) {
   LoadHTML("<body style='margin:0;'><div style='display:inline-block; "
            "width:400px; height:400px;'/></body>");
   view()->webview()->mainFrame()->setCanHaveScrollbars(false);
   EnablePreferredSizeMode();
 
   gfx::Size size = GetPreferredSize();
   EXPECT_EQ(gfx::Size(400, 400), size);
@@ skipping 389 matching lines @@
   ExpectPauseAndResume(3);
   blink::WebScriptSource source2(
       WebString::fromUTF8("function func2() { func1(); }; func2();"));
   frame()->GetWebFrame()->executeScriptInIsolatedWorld(17, &source2, 1);
 
   EXPECT_FALSE(IsPaused());
   Detach();
 }
 
 }  // namespace content