Extend the ToRenderFrameHost magic to FrameTreeNode* and Shell*

content/browser/frame_host/navigation_controller_impl_browsertest.cc

 // Copyright 2014 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 "content/browser/frame_host/navigation_controller_impl.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 175 matching lines @@
 
   // TODO(boliu): Add test for in-page fragment navigation. See
   // crbug.com/561034.
 
   // Navigate with Javascript.
   {
     GURL navigate_url = embedded_test_server()->base_url();
     std::string script = "document.location = '" +
                          navigate_url.spec() + "';";
     TestNavigationObserver same_tab_observer(shell()->web_contents(), 1);
-    EXPECT_TRUE(ExecuteScript(shell()->web_contents(), script));
+    EXPECT_TRUE(ExecuteScript(shell(), script));
     same_tab_observer.Wait();
     EXPECT_EQ(2, controller.GetEntryCount());
     NavigationEntryImpl* entry = controller.GetLastCommittedEntry();
     EXPECT_TRUE(entry->GetBaseURLForDataURL().is_empty());
     EXPECT_TRUE(entry->GetHistoryURLForDataURL().is_empty());
     EXPECT_EQ(navigate_url, entry->GetVirtualURL());
     EXPECT_EQ(navigate_url, entry->GetURL());
   }
 }
 
@@ skipping 26 matching lines @@
   NavigateToURL(shell(), js_url);
   EXPECT_EQ(2, controller.GetEntryCount());
   NavigationEntryImpl* entry = controller.GetLastCommittedEntry();
   // TODO(boliu): These expectations maybe incorrect due to crbug.com/561034.
   EXPECT_TRUE(entry->GetBaseURLForDataURL().is_empty());
   EXPECT_TRUE(entry->GetHistoryURLForDataURL().is_empty());
   EXPECT_EQ(data_url, entry->GetVirtualURL());
   EXPECT_EQ(data_url, entry->GetURL());
 
   // Passes if renderer is still alive.
-  EXPECT_TRUE(
-      ExecuteScript(shell()->web_contents(), "console.log('Success');"));
+  EXPECT_TRUE(ExecuteScript(shell(), "console.log('Success');"));
 }
 
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest, UniqueIDs) {
   const NavigationControllerImpl& controller =
       static_cast<const NavigationControllerImpl&>(
           shell()->web_contents()->GetController());
 
   GURL main_url(embedded_test_server()->GetURL(
       "/navigation_controller/page_with_link_to_load_iframe.html"));
   NavigateToURL(shell(), main_url);
   ASSERT_EQ(1, controller.GetEntryCount());
 
   // Use JavaScript to click the link and load the iframe.
   std::string script = "document.getElementById('link').click()";
-  EXPECT_TRUE(ExecuteScript(shell()->web_contents(), script));
+  EXPECT_TRUE(ExecuteScript(shell(), script));
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
   ASSERT_EQ(2, controller.GetEntryCount());
 
   // Unique IDs should... um... be unique.
   ASSERT_NE(controller.GetEntryAtIndex(0)->GetUniqueID(),
             controller.GetEntryAtIndex(1)->GetUniqueID());
 }
 
 // Ensures that RenderFrameHosts end up with the correct nav_entry_id() after
 // navigations.
@@ skipping 84 matching lines @@
   // This should have successfully gone back.
   EXPECT_EQ(GURL(base::StringPrintf("data:text/html,page%d", kMaxEntryCount)),
             controller.GetLastCommittedEntry()->GetURL());
 }
 
 namespace {
 
 int RendererHistoryLength(Shell* shell) {
   int value = 0;
   EXPECT_TRUE(ExecuteScriptAndExtractInt(
-      shell->web_contents(),
-      "domAutomationController.send(history.length)",
-      &value));
+      shell, "domAutomationController.send(history.length)", &value));
   return value;
 }
 
 // Similar to the ones from content_browser_test_utils.
 bool NavigateToURLAndReplace(Shell* shell, const GURL& url) {
   WebContents* web_contents = shell->web_contents();
   WaitForLoadStop(web_contents);
   TestNavigationObserver same_tab_observer(web_contents, 1);
   NavigationController::LoadURLParams params(url);
   params.should_replace_current_entry = true;
@@ skipping 56 matching lines @@
                        CorrectLengthWithNewTabNavigatingFromWebUI) {
   GURL web_ui_page(std::string(kChromeUIScheme) + "://" +
                    std::string(kChromeUIGpuHost));
   EXPECT_TRUE(NavigateToURL(shell(), web_ui_page));
   EXPECT_EQ(BINDINGS_POLICY_WEB_UI,
       shell()->web_contents()->GetRenderViewHost()->GetEnabledBindings());
 
   ShellAddedObserver observer;
   std::string page_url = embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_1.html").spec();
-  EXPECT_TRUE(ExecuteScript(shell()->web_contents(),
-                            "window.open('" + page_url + "', '_blank')"));
+  EXPECT_TRUE(
+      ExecuteScript(shell(), "window.open('" + page_url + "', '_blank')"));
   Shell* shell2 = observer.GetShell();
   EXPECT_TRUE(WaitForLoadStop(shell2->web_contents()));
 
   EXPECT_EQ(1, shell2->web_contents()->GetController().GetEntryCount());
   EXPECT_EQ(1, RendererHistoryLength(shell2));
 
   // Again, as above, there's no way to access the renderer's notion of the
   // history offset via JavaScript. Checking just the history length, again,
   // will have to suffice.
 }
@@ skipping 215 matching lines @@
   // Navigate to a page to force the renderer process to start.
   EXPECT_TRUE(NavigateToURL(shell(), GURL(url::kAboutBlankURL)));
   FrameTreeNode* root = static_cast<WebContentsImpl*>(shell()->web_contents())
                             ->GetFrameTree()
                             ->root();
 
   // Pop open a new window with no last committed entry.
   ShellAddedObserver new_shell_observer;
   {
     std::string script = "window.open()";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
   }
   Shell* new_shell = new_shell_observer.GetShell();
   ASSERT_NE(new_shell->web_contents(), shell()->web_contents());
   FrameTreeNode* new_root =
       static_cast<WebContentsImpl*>(new_shell->web_contents())
           ->GetFrameTree()
           ->root();
   EXPECT_FALSE(
       new_shell->web_contents()->GetController().GetLastCommittedEntry());
 
   // Make a new iframe in it.
   NoNavigationsObserver observer(new_shell->web_contents());
   {
     LoadCommittedCapturer capturer(new_shell->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = 'data:text/html,<p>some page</p>';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(new_root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(new_root, script));
     capturer.Wait();
   }
   ASSERT_EQ(1U, new_root->child_count());
   ASSERT_NE(nullptr, new_root->child_at(0));
 
   // Navigate it cross-site.
   GURL frame_url = embedded_test_server()->GetURL(
       "foo.com", "/navigation_controller/simple_page_2.html");
   {
     LoadCommittedCapturer capturer(new_shell->web_contents());
     std::string script = "location.assign('" + frame_url.spec() + "')";
-    EXPECT_TRUE(
-        ExecuteScript(new_root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(new_root->child_at(0), script));
     capturer.Wait();
   }
 
   // Success is not crashing, and not navigating.
   EXPECT_EQ(nullptr,
             new_shell->web_contents()->GetController().GetLastCommittedEntry());
 
   // A nested iframe with a cross-site URL should also be able to commit.
   GURL grandchild_url(embedded_test_server()->GetURL(
       "bar.com", "/navigation_controller/simple_page_1.html"));
   {
     LoadCommittedCapturer capturer(new_shell->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + grandchild_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(
-        ExecuteScript(new_root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(new_root->child_at(0), script));
     capturer.Wait();
   }
   ASSERT_EQ(1U, new_root->child_at(0)->child_count());
   EXPECT_EQ(grandchild_url, new_root->child_at(0)->child_at(0)->current_url());
 }
 
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        ErrorPageReplacement) {
   NavigationController& controller = shell()->web_contents()->GetController();
   GURL error_url(
@@ skipping 96 matching lines @@
     // transition? Lots of these transitions should be cleaned up.
     EXPECT_EQ(ui::PAGE_TRANSITION_LINK, capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
     EXPECT_FALSE(capturer.details().is_in_page);
   }
 
   {
     // Load via a fragment link click.
     FrameNavigateParamsCapturer capturer(root);
     std::string script = "document.getElementById('fraglink').click()";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_LINK, capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
     EXPECT_TRUE(capturer.details().is_in_page);
   }
 
   {
     // Load via link click.
     FrameNavigateParamsCapturer capturer(root);
     std::string script = "document.getElementById('thelink').click()";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_LINK, capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
     EXPECT_FALSE(capturer.details().is_in_page);
   }
 
   {
     // location.assign().
     FrameNavigateParamsCapturer capturer(root);
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/simple_page_2.html"));
     std::string script = "location.assign('" + frame_url.spec() + "')";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_LINK | ui::PAGE_TRANSITION_CLIENT_REDIRECT,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
     EXPECT_FALSE(capturer.details().is_in_page);
   }
 
   {
     // history.pushState().
     FrameNavigateParamsCapturer capturer(root);
     std::string script =
         "history.pushState({}, 'page 1', 'simple_page_1.html')";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_LINK | ui::PAGE_TRANSITION_CLIENT_REDIRECT,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
     EXPECT_TRUE(capturer.details().is_in_page);
   }
 
   if (AreAllSitesIsolatedForTesting()) {
     // Cross-process location.replace().
     FrameNavigateParamsCapturer capturer(root);
     GURL frame_url(embedded_test_server()->GetURL(
         "foo.com", "/navigation_controller/simple_page_1.html"));
     std::string script = "location.replace('" + frame_url.spec() + "')";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_LINK | ui::PAGE_TRANSITION_CLIENT_REDIRECT,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
     EXPECT_FALSE(capturer.details().is_in_page);
   }
 }
 
 // Verify that navigations for NAVIGATION_TYPE_EXISTING_PAGE are correctly
 // classified.
@@ skipping 32 matching lines @@
               | ui::PAGE_TRANSITION_FORWARD_BACK
               | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
     EXPECT_FALSE(capturer.details().is_in_page);
   }
 
   {
     // Back from the renderer side.
     FrameNavigateParamsCapturer capturer(root);
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), "history.back()"));
+    EXPECT_TRUE(ExecuteScript(root, "history.back()"));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_TYPED
               | ui::PAGE_TRANSITION_FORWARD_BACK
               | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
     EXPECT_FALSE(capturer.details().is_in_page);
   }
 
   {
     // Forward from the renderer side.
     FrameNavigateParamsCapturer capturer(root);
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), "history.forward()"));
+    EXPECT_TRUE(ExecuteScript(root, "history.forward()"));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_TYPED
               | ui::PAGE_TRANSITION_FORWARD_BACK
               | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
     EXPECT_FALSE(capturer.details().is_in_page);
   }
 
   {
     // Back from the renderer side via history.go().
     FrameNavigateParamsCapturer capturer(root);
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), "history.go(-1)"));
+    EXPECT_TRUE(ExecuteScript(root, "history.go(-1)"));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_TYPED
               | ui::PAGE_TRANSITION_FORWARD_BACK
               | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
     EXPECT_FALSE(capturer.details().is_in_page);
   }
 
   {
     // Forward from the renderer side via history.go().
     FrameNavigateParamsCapturer capturer(root);
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), "history.go(1)"));
+    EXPECT_TRUE(ExecuteScript(root, "history.go(1)"));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_TYPED
               | ui::PAGE_TRANSITION_FORWARD_BACK
               | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
     EXPECT_FALSE(capturer.details().is_in_page);
   }
 
   {
     // Reload from the browser side.
     FrameNavigateParamsCapturer capturer(root);
     shell()->web_contents()->GetController().Reload(false);
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_RELOAD, capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
     EXPECT_FALSE(capturer.details().is_in_page);
   }
 
   {
     // Reload from the renderer side.
     FrameNavigateParamsCapturer capturer(root);
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), "location.reload()"));
+    EXPECT_TRUE(ExecuteScript(root, "location.reload()"));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_LINK | ui::PAGE_TRANSITION_CLIENT_REDIRECT,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
     EXPECT_FALSE(capturer.details().is_in_page);
   }
 
   {
     // location.replace().
     // TODO(creis): Change this to be NEW_PAGE with replacement in
     // https://crbug.com/596707.
     FrameNavigateParamsCapturer capturer(root);
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/simple_page_1.html"));
     std::string script = "location.replace('" + frame_url.spec() + "')";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_LINK | ui::PAGE_TRANSITION_CLIENT_REDIRECT,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
     EXPECT_FALSE(capturer.details().is_in_page);
   }
 
   // Now, various in-page navigations.
 
   {
     // history.replaceState().
     FrameNavigateParamsCapturer capturer(root);
     std::string script =
         "history.replaceState({}, 'page 2', 'simple_page_2.html')";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_LINK | ui::PAGE_TRANSITION_CLIENT_REDIRECT,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
     EXPECT_TRUE(capturer.details().is_in_page);
   }
 
   // Back and forward across a fragment navigation.
 
   GURL url_links(embedded_test_server()->GetURL(
       "/navigation_controller/page_with_links.html"));
   NavigateToURL(shell(), url_links);
   std::string script = "document.getElementById('fraglink').click()";
-  EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+  EXPECT_TRUE(ExecuteScript(root, script));
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
 
   {
     // Back.
     FrameNavigateParamsCapturer capturer(root);
     shell()->web_contents()->GetController().GoBack();
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_TYPED
               | ui::PAGE_TRANSITION_FORWARD_BACK
               | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR,
@@ skipping 10 matching lines @@
     EXPECT_EQ(ui::PAGE_TRANSITION_LINK | ui::PAGE_TRANSITION_FORWARD_BACK,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
     EXPECT_TRUE(capturer.details().is_in_page);
   }
 
   // Back and forward across a pushState-created navigation.
 
   NavigateToURL(shell(), url1);
   script = "history.pushState({}, 'page 2', 'simple_page_2.html')";
-  EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+  EXPECT_TRUE(ExecuteScript(root, script));
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
 
   {
     // Back.
     FrameNavigateParamsCapturer capturer(root);
     shell()->web_contents()->GetController().GoBack();
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_TYPED
               | ui::PAGE_TRANSITION_FORWARD_BACK
               | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR,
@@ skipping 126 matching lines @@
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_MANUAL_SUBFRAME,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
   }
 
   {
     // Load via a fragment link click.
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     std::string script = "document.getElementById('fraglink').click()";
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_MANUAL_SUBFRAME,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
   }
 
   {
     // location.assign().
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/simple_page_1.html"));
     std::string script = "location.assign('" + frame_url.spec() + "')";
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_MANUAL_SUBFRAME,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
   }
 
   {
     // location.replace().
     LoadCommittedCapturer capturer(root->child_at(0));
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/simple_page_2.html"));
     std::string script = "location.replace('" + frame_url.spec() + "')";
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   {
     // history.pushState().
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     std::string script =
         "history.pushState({}, 'page 1', 'simple_page_1.html')";
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_MANUAL_SUBFRAME,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
   }
 
   {
     // history.replaceState().
     LoadCommittedCapturer capturer(root->child_at(0));
     std::string script =
         "history.replaceState({}, 'page 2', 'simple_page_2.html')";
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   {
     // Reload.
     LoadCommittedCapturer capturer(root->child_at(0));
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(),
-                              "location.reload()"));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), "location.reload()"));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   {
     // Create an iframe.
     LoadCommittedCapturer capturer(shell()->web_contents());
     GURL frame_url(embedded_test_server()->GetURL(
         "/navigation_controller/simple_page_1.html"));
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + frame_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 }
 
 // Verify that navigations caused by client-side redirects are correctly
 // classified.
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        NavigationTypeClassification_ClientSideRedirect) {
   NavigateToURL(shell(), GURL(url::kAboutBlankURL));
@@ skipping 35 matching lines @@
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
 
   FrameTreeNode* root =
       static_cast<WebContentsImpl*>(shell()->web_contents())->
           GetFrameTree()->root();
 
   {
     // Do a fragment link click.
     FrameNavigateParamsCapturer capturer(root);
     std::string script = "document.getElementById('fraglink').click()";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_LINK, capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
     EXPECT_TRUE(capturer.details().is_in_page);
   }
 
   {
     // Do a non-fragment link click.
     FrameNavigateParamsCapturer capturer(root);
     std::string script = "document.getElementById('thelink').click()";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_LINK, capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
     EXPECT_FALSE(capturer.details().is_in_page);
   }
 
   // Second verse, same as the first. (But in a subframe.)
 
   GURL iframe_url(embedded_test_server()->GetURL(
       "/navigation_controller/page_with_iframe.html"));
   NavigateToURL(shell(), iframe_url);
 
   root = static_cast<WebContentsImpl*>(shell()->web_contents())->
       GetFrameTree()->root();
 
   ASSERT_EQ(1U, root->child_count());
   ASSERT_NE(nullptr, root->child_at(0));
 
   NavigateFrameToURL(root->child_at(0), links_url);
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
 
   {
     // Do a fragment link click.
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     std::string script = "document.getElementById('fraglink').click()";
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_MANUAL_SUBFRAME,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
     EXPECT_TRUE(capturer.details().is_in_page);
   }
 
   {
     // Do a non-fragment link click.
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     std::string script = "document.getElementById('thelink').click()";
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_MANUAL_SUBFRAME,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
     EXPECT_FALSE(capturer.details().is_in_page);
   }
 }
 
 // Verify the tree of FrameNavigationEntries after initial about:blank commits
 // in subframes, which should not count as real committed loads.
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        FrameNavigationEntry_BlankAutoSubframe) {
   GURL about_blank_url(url::kAboutBlankURL);
   GURL main_url(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_1.html"));
   NavigateToURL(shell(), main_url);
   const NavigationControllerImpl& controller =
       static_cast<const NavigationControllerImpl&>(
           shell()->web_contents()->GetController());
   FrameTreeNode* root =
       static_cast<WebContentsImpl*>(shell()->web_contents())->
           GetFrameTree()->root();
 
   // 1. Create a iframe with no URL.
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // Check last committed NavigationEntry.
   EXPECT_EQ(1, controller.GetEntryCount());
   NavigationEntryImpl* entry = controller.GetLastCommittedEntry();
   EXPECT_EQ(main_url, entry->GetURL());
   FrameNavigationEntry* root_entry = entry->root_node()->frame_entry.get();
   EXPECT_EQ(main_url, root_entry->url());
@@ skipping 11 matching lines @@
     EXPECT_EQ(0U, entry->root_node()->children.size());
   }
   EXPECT_FALSE(root->child_at(0)->has_committed_real_load());
 
   // 1a. A nested iframe with no URL should also create a subframe entry but not
   // count as a real load.
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // Verify subframe entries if they're enabled (e.g. in --site-per-process).
   if (SiteIsolationPolicy::UseSubframeNavigationEntries()) {
     // The nested entry should have one blank subframe FrameNavigationEntry, but
     // this does not count as committing a real load.
     ASSERT_EQ(1U, entry->root_node()->children[0]->children.size());
     FrameNavigationEntry* frame_entry =
         entry->root_node()->children[0]->children[0]->frame_entry.get();
     EXPECT_EQ(about_blank_url, frame_entry->url());
   } else {
     // There are no subframe FrameNavigationEntries by default.
     EXPECT_EQ(0U, entry->root_node()->children.size());
   }
   EXPECT_FALSE(root->child_at(0)->child_at(0)->has_committed_real_load());
 
   // 2. Create another iframe with an explicit about:blank URL.
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = 'about:blank';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // Check last committed NavigationEntry.
   EXPECT_EQ(1, controller.GetEntryCount());
   EXPECT_EQ(entry, controller.GetLastCommittedEntry());
 
   // Verify subframe entries if they're enabled (e.g. in --site-per-process).
   if (SiteIsolationPolicy::UseSubframeNavigationEntries()) {
     // The new entry should have one blank subframe FrameNavigationEntry, but
     // this does not count as committing a real load.
     ASSERT_EQ(2U, entry->root_node()->children.size());
     FrameNavigationEntry* frame_entry =
         entry->root_node()->children[1]->frame_entry.get();
     EXPECT_EQ(about_blank_url, frame_entry->url());
   } else {
     // There are no subframe FrameNavigationEntries by default.
     EXPECT_EQ(0U, entry->root_node()->children.size());
   }
   EXPECT_FALSE(root->child_at(1)->has_committed_real_load());
 
   // 3. A real same-site navigation in the nested iframe should be AUTO.
   GURL frame_url(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_1.html"));
   {
     LoadCommittedCapturer capturer(root->child_at(0)->child_at(0));
     std::string script = "var frames = document.getElementsByTagName('iframe');"
                          "frames[0].src = '" + frame_url.spec() + "';";
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // Check last committed NavigationEntry.  It should have replaced the previous
   // frame entry in the original NavigationEntry.
   EXPECT_EQ(1, controller.GetEntryCount());
   EXPECT_EQ(entry, controller.GetLastCommittedEntry());
 
   // Verify subframe entries if they're enabled (e.g. in --site-per-process).
@@ skipping 11 matching lines @@
   EXPECT_TRUE(root->child_at(0)->child_at(0)->has_committed_real_load());
   EXPECT_FALSE(root->child_at(1)->has_committed_real_load());
 
   // 4. A real cross-site navigation in the second iframe should be AUTO.
   GURL foo_url(embedded_test_server()->GetURL(
       "foo.com", "/navigation_controller/simple_page_2.html"));
   {
     LoadCommittedCapturer capturer(root->child_at(1));
     std::string script = "var frames = document.getElementsByTagName('iframe');"
                          "frames[1].src = '" + foo_url.spec() + "';";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // Check last committed NavigationEntry.
   EXPECT_EQ(1, controller.GetEntryCount());
   EXPECT_EQ(entry, controller.GetLastCommittedEntry());
 
   // Verify subframe entries if they're enabled (e.g. in --site-per-process).
   if (SiteIsolationPolicy::UseSubframeNavigationEntries()) {
@@ skipping 10 matching lines @@
   EXPECT_TRUE(root->child_at(0)->child_at(0)->has_committed_real_load());
   EXPECT_TRUE(root->child_at(1)->has_committed_real_load());
 
   // 5. A new navigation to about:blank in the nested frame should count as a
   // real load, since that frame has already committed a real load and this is
   // not the initial blank page.
   {
     LoadCommittedCapturer capturer(root->child_at(0)->child_at(0));
     std::string script = "var frames = document.getElementsByTagName('iframe');"
                          "frames[0].src = 'about:blank';";
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_MANUAL_SUBFRAME, capturer.transition_type());
   }
 
   // This should have created a new NavigationEntry.
   EXPECT_EQ(2, controller.GetEntryCount());
   EXPECT_NE(entry, controller.GetLastCommittedEntry());
   NavigationEntryImpl* entry2 = controller.GetLastCommittedEntry();
 
   // Verify subframe entries if they're enabled (e.g. in --site-per-process).
@@ skipping 37 matching lines @@
                             ->root();
 
   // 1. Create a iframe with a URL that doesn't commit.
   GURL slow_url(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_2.html"));
   TestNavigationManager subframe_delayer(shell()->web_contents(), slow_url);
   {
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + slow_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
   }
   subframe_delayer.WaitForWillStartRequest();
 
   // Stop the request so that we can wait for load stop below, without ending up
   // with a commit for this frame.
   shell()->web_contents()->Stop();
 
   // 2. A nested iframe with a cross-site URL should be able to commit.
   GURL foo_url(embedded_test_server()->GetURL(
       "foo.com", "/navigation_controller/simple_page_1.html"));
   {
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + foo_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     WaitForLoadStopWithoutSuccessCheck(shell()->web_contents());
   }
 
   // TODO(creis): Check subframe entries once we create them in this case.
   // See https://crbug.com/608402.
   EXPECT_EQ(foo_url, root->child_at(0)->child_at(0)->current_url());
 }
 
 // Verify the tree of FrameNavigationEntries when a nested iframe commits inside
 // the initial blank page of an iframe with no committed entry.  Prevents
 // regression of https://crbug.com/600743.
 // Flaky test: See https://crbug.com/610801
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        DISABLED_FrameNavigationEntry_NoCommitNestedAutoSubframe) {
   GURL main_url(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_1.html"));
   EXPECT_TRUE(NavigateToURL(shell(), main_url));
   FrameTreeNode* root = static_cast<WebContentsImpl*>(shell()->web_contents())
                             ->GetFrameTree()
                             ->root();
 
   // 1. Create a iframe with a URL that doesn't commit.
   GURL no_commit_url(embedded_test_server()->GetURL("/nocontent"));
   {
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + no_commit_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
   }
   EXPECT_EQ(GURL(), root->child_at(0)->current_url());
 
   // 2. A nested iframe with a cross-site URL should be able to commit.
   GURL foo_url(embedded_test_server()->GetURL(
       "foo.com", "/navigation_controller/simple_page_1.html"));
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + foo_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // TODO(creis): Check subframe entries once we create them in this case.
   // See https://crbug.com/608402.
   EXPECT_EQ(foo_url, root->child_at(0)->child_at(0)->current_url());
 }
 
 // Verify the tree of FrameNavigationEntries when a nested iframe commits after
 // going back in-page, in which case its parent might not have been in the
 // NavigationEntry.  Prevents regression of https://crbug.com/600743.
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        FrameNavigationEntry_BackNestedAutoSubframe) {
   GURL main_url(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_1.html"));
   EXPECT_TRUE(NavigateToURL(shell(), main_url));
   FrameTreeNode* root = static_cast<WebContentsImpl*>(shell()->web_contents())
                             ->GetFrameTree()
                             ->root();
 
   // 1. Navigate in-page.
   {
     FrameNavigateParamsCapturer capturer(root);
     std::string script = "history.pushState({}, 'foo', 'foo')";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
     EXPECT_TRUE(capturer.details().is_in_page);
   }
 
   // 2. Create an iframe.
   GURL child_url(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_2.html"));
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + child_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // 3. Go back in-page.
   {
     TestNavigationObserver back_load_observer(shell()->web_contents());
     shell()->web_contents()->GetController().GoBack();
     back_load_observer.Wait();
   }
 
   // 4. A nested iframe with a cross-site URL should be able to commit.
   GURL grandchild_url(embedded_test_server()->GetURL(
       "foo.com", "/navigation_controller/simple_page_1.html"));
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + grandchild_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // TODO(creis): Check subframe entries once we create them in this case.
   // See https://crbug.com/608402.
   EXPECT_EQ(grandchild_url, root->child_at(0)->child_at(0)->current_url());
 }
 
 // Verify the tree of FrameNavigationEntries when a nested iframe commits after
 // its parent changes its name, in which case we might not find the parent
 // FrameNavigationEntry.  Prevents regression of https://crbug.com/600743.
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        FrameNavigationEntry_RenameNestedAutoSubframe) {
   GURL main_url(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_1.html"));
   EXPECT_TRUE(NavigateToURL(shell(), main_url));
   FrameTreeNode* root = static_cast<WebContentsImpl*>(shell()->web_contents())
                             ->GetFrameTree()
                             ->root();
 
   // 1. Create an iframe.
   GURL child_url(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_2.html"));
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + child_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // 2. Change the iframe's name.
-  EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(),
-                            "window.name = 'foo';"));
+  EXPECT_TRUE(ExecuteScript(root->child_at(0), "window.name = 'foo';"));
 
   // 3. A nested iframe with a cross-site URL should be able to commit.
   GURL bar_url(embedded_test_server()->GetURL(
       "bar.com", "/navigation_controller/simple_page_1.html"));
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + bar_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
 
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // TODO(creis): Check subframe entries once we create them in this case.
   // See https://crbug.com/608402.
   EXPECT_EQ(bar_url, root->child_at(0)->child_at(0)->current_url());
 }
 
@@ skipping 13 matching lines @@
           GetFrameTree()->root();
 
   // 1. Create a same-site iframe.
   GURL frame_url(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_2.html"));
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + frame_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // Check last committed NavigationEntry.
   EXPECT_EQ(1, controller.GetEntryCount());
   NavigationEntryImpl* entry = controller.GetLastCommittedEntry();
   EXPECT_EQ(main_url, entry->GetURL());
   FrameNavigationEntry* root_entry = entry->root_node()->frame_entry.get();
   EXPECT_EQ(main_url, root_entry->url());
@@ skipping 13 matching lines @@
   }
 
   // 2. Create a second, initially cross-site iframe.
   GURL foo_url(embedded_test_server()->GetURL(
       "foo.com", "/navigation_controller/simple_page_1.html"));
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + foo_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // The last committed NavigationEntry shouldn't have changed.
   EXPECT_EQ(1, controller.GetEntryCount());
   entry = controller.GetLastCommittedEntry();
   EXPECT_EQ(main_url, entry->GetURL());
   root_entry = entry->root_node()->frame_entry.get();
   EXPECT_EQ(main_url, root_entry->url());
@@ skipping 11 matching lines @@
     // There are no subframe FrameNavigationEntries by default.
     EXPECT_EQ(0U, entry->root_node()->children.size());
   }
 
   // 3. Create a nested iframe in the second subframe.
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + foo_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->child_at(1)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(1), script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // The last committed NavigationEntry shouldn't have changed.
   EXPECT_EQ(1, controller.GetEntryCount());
   entry = controller.GetLastCommittedEntry();
   EXPECT_EQ(main_url, entry->GetURL());
   root_entry = entry->root_node()->frame_entry.get();
   EXPECT_EQ(main_url, root_entry->url());
@@ skipping 11 matching lines @@
     EXPECT_EQ(0U, entry->root_node()->children.size());
   }
 
   // 4. Create a third iframe on the same site as the second.  This ensures that
   // the commit type is correct even when the subframe process already exists.
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + foo_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // The last committed NavigationEntry shouldn't have changed.
   EXPECT_EQ(1, controller.GetEntryCount());
   entry = controller.GetLastCommittedEntry();
   EXPECT_EQ(main_url, entry->GetURL());
   root_entry = entry->root_node()->frame_entry.get();
   EXPECT_EQ(main_url, root_entry->url());
@@ skipping 10 matching lines @@
     EXPECT_EQ(0U, entry->root_node()->children.size());
   }
 
   // 5. Create a nested iframe on the original site (A-B-A).
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + frame_url.spec() + "';"
                          "document.body.appendChild(iframe);";
     FrameTreeNode* child = root->child_at(2);
-    EXPECT_TRUE(ExecuteScript(child->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(child, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // The last committed NavigationEntry shouldn't have changed.
   EXPECT_EQ(1, controller.GetEntryCount());
   entry = controller.GetLastCommittedEntry();
   EXPECT_EQ(main_url, entry->GetURL());
   root_entry = entry->root_node()->frame_entry.get();
   EXPECT_EQ(main_url, root_entry->url());
@@ skipping 41 matching lines @@
           GetFrameTree()->root();
 
   // 1. Create a same-site iframe.
   GURL frame_url(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_2.html"));
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + frame_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
   }
   NavigationEntryImpl* entry = controller.GetLastCommittedEntry();
 
   // 2. Navigate in the subframe same-site.
   GURL frame_url2(embedded_test_server()->GetURL(
       "/navigation_controller/page_with_links.html"));
   {
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     NavigateFrameToURL(root->child_at(0), frame_url2);
@@ skipping 23 matching lines @@
   }
 
   // 3. Create a second, initially cross-site iframe.
   GURL foo_url(embedded_test_server()->GetURL(
       "foo.com", "/navigation_controller/simple_page_1.html"));
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + foo_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
   }
 
   // 4. Create a nested same-site iframe in the second subframe, wait for it to
   // commit, then navigate it again.
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + foo_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->child_at(1)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(1), script));
     capturer.Wait();
   }
   GURL bar_url(embedded_test_server()->GetURL(
       "bar.com", "/navigation_controller/simple_page_1.html"));
   {
     FrameNavigateParamsCapturer capturer(root->child_at(1)->child_at(0));
     NavigateFrameToURL(root->child_at(1)->child_at(0), bar_url);
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_MANUAL_SUBFRAME,
               capturer.params().transition);
@@ skipping 24 matching lines @@
     EXPECT_EQ(0U, entry3->root_node()->children.size());
   }
 
   // 6. Navigate the second subframe cross-site, clearing its existing subtree.
   GURL baz_url(embedded_test_server()->GetURL(
       "baz.com", "/navigation_controller/simple_page_1.html"));
   {
     FrameNavigateParamsCapturer capturer(root->child_at(1));
     std::string script = "var frames = document.getElementsByTagName('iframe');"
                          "frames[1].src = '" + baz_url.spec() + "';";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_MANUAL_SUBFRAME,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
   }
 
   // We should have created a new NavigationEntry with the same main frame URL.
   EXPECT_EQ(4, controller.GetEntryCount());
   EXPECT_EQ(3, controller.GetLastCommittedEntryIndex());
   NavigationEntryImpl* entry4 = controller.GetLastCommittedEntry();
@@ skipping 48 matching lines @@
       "/navigation_controller/simple_page_1.html"));
   {
     LoadCommittedCapturer capturer(root->child_at(0));
     NavigateFrameToURL(root->child_at(0), subframe_url);
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // 2. In-page navigation in the main frame.
   std::string push_script = "history.pushState({}, 'page 2', 'page_2.html')";
-  EXPECT_TRUE(ExecuteScript(root->current_frame_host(), push_script));
+  EXPECT_TRUE(ExecuteScript(root, push_script));
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
 
   // TODO(creis): Verify subframe entries.  https://crbug.com/522193.
 
   // 3. Add a nested subframe.
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + subframe_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->child_at(0)->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root->child_at(0), script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // TODO(creis): Verify subframe entries.  https://crbug.com/522193.
 }
 
 // Verify the tree of FrameNavigationEntries after back/forward navigations in a
 // cross-site subframe.
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        FrameNavigationEntry_SubframeBackForward) {
   GURL main_url(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_1.html"));
   NavigateToURL(shell(), main_url);
   const NavigationControllerImpl& controller =
       static_cast<const NavigationControllerImpl&>(
           shell()->web_contents()->GetController());
   FrameTreeNode* root = static_cast<WebContentsImpl*>(shell()->web_contents())
                             ->GetFrameTree()
                             ->root();
 
   // 1. Create a same-site iframe.
   GURL frame_url(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_2.html"));
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + frame_url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
   }
   NavigationEntryImpl* entry1 = controller.GetLastCommittedEntry();
 
   // 2. Navigate in the subframe cross-site.
   GURL frame_url2(embedded_test_server()->GetURL(
       "foo.com", "/navigation_controller/page_with_links.html"));
   {
     FrameNavigateParamsCapturer capturer(root->child_at(0));
     NavigateFrameToURL(root->child_at(0), frame_url2);
@@ skipping 252 matching lines @@
               entry4->root_node()->children[0]->frame_entry->url());
     EXPECT_EQ(
         frame_url_c,
         entry4->root_node()->children[0]->children[0]->frame_entry->url());
   } else {
     // There are no subframe FrameNavigationEntries by default.
     EXPECT_EQ(0U, entry4->root_node()->children.size());
   }
 
   // Inject a JS value so that we can check for it later.
-  EXPECT_TRUE(content::ExecuteScript(root->current_frame_host(), "foo=3;"));
+  EXPECT_TRUE(content::ExecuteScript(root, "foo=3;"));
 
   // 7. Go back again, to the data URL in the nested iframe.
   {
     TestNavigationObserver back_load_observer(shell()->web_contents());
     shell()->web_contents()->GetController().GoBack();
     back_load_observer.Wait();
   }
   ASSERT_EQ(1U, root->child_count());
   ASSERT_EQ(1U, root->child_at(0)->child_count());
   EXPECT_EQ(main_url_a, root->current_url());
@@ skipping 15 matching lines @@
         data_url,
         entry3->root_node()->children[0]->children[0]->frame_entry->url());
   } else {
     // There are no subframe FrameNavigationEntries by default.
     EXPECT_EQ(0U, entry3->root_node()->children.size());
   }
 
   // Verify that we did not reload the main frame. See https://crbug.com/586234.
   {
     int value = 0;
-    EXPECT_TRUE(ExecuteScriptAndExtractInt(root->current_frame_host(),
-                                           "domAutomationController.send(foo)",
-                                           &value));
+    EXPECT_TRUE(ExecuteScriptAndExtractInt(
+        root, "domAutomationController.send(foo)", &value));
     EXPECT_EQ(3, value);
   }
 
   // 8. Go back again, to the data URL in the first subframe.
   {
     TestNavigationObserver back_load_observer(shell()->web_contents());
     shell()->web_contents()->GetController().GoBack();
     back_load_observer.Wait();
   }
   ASSERT_EQ(1U, root->child_count());
@@ skipping 314 matching lines @@
   // Test subframe unique names only if enabled, e.g. in --site-per-process.
   if (!SiteIsolationPolicy::UseSubframeNavigationEntries())
     return;
 
   // 2. Add an unnamed subframe, which does an AUTO_SUBFRAME navigation.
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + url.spec() + "';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // The root FrameNavigationEntry hasn't changed.
   EXPECT_EQ(frame_entry,
             controller.GetLastCommittedEntry()->GetFrameEntry(root));
 
   // The subframe should have a generated name.
   FrameTreeNode* subframe = root->child_at(0);
   EXPECT_EQ(main_site_instance,
             subframe->current_frame_host()->GetSiteInstance());
   FrameNavigationEntry* subframe_entry =
       controller.GetLastCommittedEntry()->GetFrameEntry(subframe);
   std::string unnamed_subframe_name = "<!--framePath //<!--frame0-->-->";
   EXPECT_EQ(unnamed_subframe_name, subframe_entry->frame_unique_name());
 
   // 3. Add a named subframe.
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string script = "var iframe = document.createElement('iframe');"
                          "iframe.src = '" + url.spec() + "';"
                          "iframe.name = 'foo';"
                          "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // The new subframe should have the specified name.
   EXPECT_EQ(frame_entry,
             controller.GetLastCommittedEntry()->GetFrameEntry(root));
   FrameTreeNode* foo_subframe = root->child_at(1);
   EXPECT_EQ(main_site_instance,
             foo_subframe->current_frame_host()->GetSiteInstance());
@@ skipping 28 matching lines @@
 // Ensure we don't crash when cloning a named window.  This happened in
 // https://crbug.com/603245 because neither the FrameTreeNode ID nor the name of
 // the cloned window matched the root FrameNavigationEntry.
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest, CloneNamedWindow) {
   // Start on an initial page.
   GURL url_1(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_1.html"));
   EXPECT_TRUE(NavigateToURL(shell(), url_1));
 
   // Name the window.
-  EXPECT_TRUE(ExecuteScript(shell()->web_contents(), "window.name = 'foo';"));
+  EXPECT_TRUE(ExecuteScript(shell(), "window.name = 'foo';"));
 
   // Navigate it.
   GURL url_2(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_2.html"));
   EXPECT_TRUE(NavigateToURL(shell(), url_2));
 
   // Clone the tab and load the page.
   std::unique_ptr<WebContentsImpl> new_tab(
       static_cast<WebContentsImpl*>(shell()->web_contents()->Clone()));
   NavigationController& new_controller = new_tab->GetController();
@@ skipping 10 matching lines @@
 // happened in https://crbug.com/603245 because neither the FrameTreeNode ID nor
 // the name of the cloned window matched the root FrameNavigationEntry.
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
                        CloneAndGoBackWithNamedWindow) {
   // Start on an initial page.
   GURL url_1(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_1.html"));
   EXPECT_TRUE(NavigateToURL(shell(), url_1));
 
   // Name the window.
-  EXPECT_TRUE(ExecuteScript(shell()->web_contents(), "window.name = 'foo';"));
+  EXPECT_TRUE(ExecuteScript(shell(), "window.name = 'foo';"));
 
   // Navigate it.
   GURL url_2(embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_2.html"));
   EXPECT_TRUE(NavigateToURL(shell(), url_2));
 
   // Clear the name.
-  EXPECT_TRUE(ExecuteScript(shell()->web_contents(), "window.name = '';"));
+  EXPECT_TRUE(ExecuteScript(shell(), "window.name = '';"));
 
   // Navigate it again.
   EXPECT_TRUE(NavigateToURL(shell(), url_1));
 
   // Clone the tab and load the page.
   std::unique_ptr<WebContentsImpl> new_tab(
       static_cast<WebContentsImpl*>(shell()->web_contents()->Clone()));
   NavigationController& new_controller = new_tab->GetController();
   EXPECT_TRUE(new_controller.IsInitialNavigation());
   EXPECT_TRUE(new_controller.NeedsReload());
@@ skipping 35 matching lines @@
       root->current_frame_host()->GetSiteInstance();
 
   // 2. Add a cross-site subframe.
   GURL frame_url(embedded_test_server()->GetURL(
       "foo.com", "/navigation_controller/simple_page_1.html"));
   std::string script = "var iframe = document.createElement('iframe');"
                        "iframe.src = '" + frame_url.spec() + "';"
                        "document.body.appendChild(iframe);";
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   FrameTreeNode* subframe = root->child_at(0);
   if (AreAllSitesIsolatedForTesting()) {
     EXPECT_NE(main_site_instance,
               subframe->current_frame_host()->GetSiteInstance());
   }
   if (SiteIsolationPolicy::UseSubframeNavigationEntries()) {
     FrameNavigationEntry* subframe_entry =
         controller.GetLastCommittedEntry()->GetFrameEntry(subframe);
     EXPECT_EQ(frame_url, subframe_entry->url());
   }
 
   // 3. Reload the main frame.
   {
     FrameNavigateParamsCapturer capturer(root);
     controller.Reload(false);
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_RELOAD, capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
     EXPECT_FALSE(capturer.details().is_in_page);
   }
 
   // 4. Add the iframe again.
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
   if (AreAllSitesIsolatedForTesting()) {
     EXPECT_NE(main_site_instance,
               root->child_at(0)->current_frame_host()->GetSiteInstance());
   }
 }
 
 // Verifies that item sequence numbers and document sequence numbers update
@@ skipping 14 matching lines @@
 
   FrameNavigationEntry* frame_entry =
       controller.GetLastCommittedEntry()->GetFrameEntry(root);
   int64_t isn_1 = frame_entry->item_sequence_number();
   int64_t dsn_1 = frame_entry->document_sequence_number();
   EXPECT_NE(-1, isn_1);
   EXPECT_NE(-1, dsn_1);
 
   // 2. Do an in-page fragment navigation.
   std::string script = "document.getElementById('fraglink').click()";
-  EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+  EXPECT_TRUE(ExecuteScript(root, script));
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
 
   frame_entry = controller.GetLastCommittedEntry()->GetFrameEntry(root);
   int64_t isn_2 = frame_entry->item_sequence_number();
   int64_t dsn_2 = frame_entry->document_sequence_number();
   EXPECT_NE(-1, isn_2);
   EXPECT_NE(isn_1, isn_2);
   EXPECT_EQ(dsn_1, dsn_2);
 
   // Test subframe sequence numbers only if enabled, e.g. in --site-per-process.
   if (!SiteIsolationPolicy::UseSubframeNavigationEntries())
     return;
 
   // 3. Add a subframe, which does an AUTO_SUBFRAME navigation.
   {
     LoadCommittedCapturer capturer(shell()->web_contents());
     std::string add_script = "var iframe = document.createElement('iframe');"
                              "iframe.src = '" + url.spec() + "';"
                              "document.body.appendChild(iframe);";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), add_script));
+    EXPECT_TRUE(ExecuteScript(root, add_script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_SUBFRAME, capturer.transition_type());
   }
 
   // The root FrameNavigationEntry hasn't changed.
   EXPECT_EQ(frame_entry,
             controller.GetLastCommittedEntry()->GetFrameEntry(root));
 
   // We should have a unique ISN and DSN for the subframe entry.
   FrameTreeNode* subframe = root->child_at(0);
   FrameNavigationEntry* subframe_entry =
       controller.GetLastCommittedEntry()->GetFrameEntry(subframe);
   int64_t isn_3 = subframe_entry->item_sequence_number();
   int64_t dsn_3 = subframe_entry->document_sequence_number();
   EXPECT_NE(-1, isn_2);
   EXPECT_NE(isn_2, isn_3);
   EXPECT_NE(dsn_2, dsn_3);
 
   // 4. Do an in-page fragment navigation in the subframe.
-  EXPECT_TRUE(ExecuteScript(subframe->current_frame_host(), script));
+  EXPECT_TRUE(ExecuteScript(subframe, script));
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
 
   subframe_entry = controller.GetLastCommittedEntry()->GetFrameEntry(subframe);
   int64_t isn_4 = subframe_entry->item_sequence_number();
   int64_t dsn_4 = subframe_entry->document_sequence_number();
   EXPECT_NE(-1, isn_4);
   EXPECT_NE(isn_3, isn_4);
   EXPECT_EQ(dsn_3, dsn_4);
 }
 
@@ skipping 126 matching lines @@
   NavigationEntryImpl* entry = controller.GetPendingEntry();
   ASSERT_NE(nullptr, entry);
   EXPECT_EQ(stalled_url, entry->GetURL());
 
   {
     // Now the existing page uses history.replaceState().
     FrameNavigateParamsCapturer capturer(root);
     capturer.set_wait_for_load(false);
     std::string script =
         "history.replaceState({}, '', '" + replace_state_filename + "')";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
 
     // The fact that there was a pending entry shouldn't interfere with the
     // classification.
     EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
     EXPECT_TRUE(capturer.details().is_in_page);
   }
 
   ResourceDispatcherHost::Get()->SetDelegate(nullptr);
 }
@@ skipping 68 matching lines @@
   ASSERT_NE(nullptr, entry);
   EXPECT_EQ(foo_url, entry->GetURL());
   EXPECT_EQ(entry_count, controller.GetEntryCount());
 
   {
     // Now the existing page uses history.pushState() while the pending entry
     // for the other navigation still exists.
     FrameNavigateParamsCapturer capturer(root);
     capturer.set_wait_for_load(false);
     std::string script = "history.pushState({}, '', 'pushed')";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
     EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, capturer.details().type);
     EXPECT_TRUE(capturer.details().is_in_page);
   }
 
   // The in-page navigation should not have replaced the previous entry.
   GURL push_state_url(
       embedded_test_server()->GetURL("/navigation_controller/pushed"));
   EXPECT_EQ(entry_count + 1, controller.GetEntryCount());
   EXPECT_EQ(push_state_url, controller.GetLastCommittedEntry()->GetURL());
@@ skipping 16 matching lines @@
 
   // Load an initial page.
   GURL start_url(embedded_test_server()->GetURL(
       "/navigation_controller/beforeunload_replacestate_1.html"));
   EXPECT_TRUE(NavigateToURL(shell(), start_url));
   EXPECT_EQ(1, controller.GetEntryCount());
   EXPECT_EQ(start_url, controller.GetLastCommittedEntry()->GetURL());
 
   // Go to the second page.
   std::string script = "document.getElementById('thelink').click()";
-  EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+  EXPECT_TRUE(ExecuteScript(root, script));
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
   EXPECT_EQ(2, controller.GetEntryCount());
   EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
 
   // Go back to the first page, which never completes. The attempt to unload the
   // second page, though, causes it to do a replaceState().
   TestNavigationManager manager(shell()->web_contents(), start_url);
   controller.GoBack();
   manager.WaitForWillStartRequest();
 
@@ skipping 48 matching lines @@
     shell()->web_contents()->GetController().GoForward();
     forward_load_observer.Wait();
   }
 
   GURL url3(embedded_test_server()->GetURL(
       "/navigation_controller/page_with_iframe.html"));
   {
     // location.replace() to cause an inert commit.
     TestNavigationObserver replace_load_observer(shell()->web_contents());
     std::string script = "location.replace('" + url3.spec() + "')";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     replace_load_observer.Wait();
   }
 
   {
     // Go back to url2.
     TestNavigationObserver back_load_observer(shell()->web_contents());
     shell()->web_contents()->GetController().GoBack();
     back_load_observer.Wait();
 
     // Make sure the URL is correct for both the entry and the main frame, and
@@ skipping 61 matching lines @@
     NavigateFrameToURL(root->child_at(0), frame_url);
     capturer.Wait();
     EXPECT_EQ(NAVIGATION_TYPE_NEW_SUBFRAME, capturer.details().type);
   }
 
   {
     // history.replaceState().
     FrameNavigateParamsCapturer capturer(root);
     std::string script =
         "history.replaceState({}, 'replaced', 'replaced')";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     capturer.Wait();
   }
 
   {
     // Go back in the iframe.
     TestNavigationObserver back_load_observer(shell()->web_contents());
     shell()->web_contents()->GetController().GoBack();
     back_load_observer.Wait();
   }
 
@@ skipping 136 matching lines @@
                             ->GetFrameTree()
                             ->root();
   RenderProcessKilledObserver kill_observer(shell()->web_contents());
 
   // Redirect so that we can use ReloadOriginalRequest.
   GURL redirect_url(embedded_test_server()->GetURL(
       "foo.com", "/navigation_controller/simple_page_1.html"));
   {
     std::string script = "location.replace('" + redirect_url.spec() + "');";
     FrameNavigateParamsCapturer capturer(root);
-    EXPECT_TRUE(ExecuteScript(shell()->web_contents(), script));
+    EXPECT_TRUE(ExecuteScript(shell(), script));
     capturer.Wait();
     EXPECT_EQ(ui::PAGE_TRANSITION_LINK | ui::PAGE_TRANSITION_CLIENT_REDIRECT,
               capturer.params().transition);
     EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, capturer.details().type);
   }
 
   // Modify an entry in the session history and reload the original request.
   {
     // We first send a replaceState() to the renderer, which will cause the
     // renderer to send back a DidCommitProvisionalLoad. Immediately after,
@@ skipping 17 matching lines @@
     capturer.set_wait_for_load(false);
     capturer.set_navigations_remaining(2);
     capturer.Wait();
     EXPECT_EQ(2U, capturer.all_details().size());
     EXPECT_EQ(modified_url, capturer.all_params()[0].url);
     EXPECT_EQ(original_url, capturer.all_params()[1].url);
     EXPECT_EQ(original_url, shell()->web_contents()->GetLastCommittedURL());
   }
 
   // Make sure the renderer is still alive.
-  EXPECT_TRUE(
-      ExecuteScript(shell()->web_contents(), "console.log('Success');"));
+  EXPECT_TRUE(ExecuteScript(shell(), "console.log('Success');"));
 }
 
 // This test shows that the initial "about:blank" URL is elided from the
 // navigation history of a subframe when it is loaded.
 //
 // It also prevents regression for an in-page navigation renderer kill when
 // going back after an in-page navigation in the main frame is followed by an
 // auto subframe navigation, due to a bug in HistoryEntry::CloneAndReplace.
 // See https://crbug.com/612713.
 IN_PROC_BROWSER_TEST_F(NavigationControllerBrowserTest,
@@ skipping 10 matching lines @@
 
   EXPECT_EQ(1, controller.GetEntryCount());
   EXPECT_EQ(1, RendererHistoryLength(shell()));
 
   // Add an iframe with no 'src'.
 
   std::string script =
       "var iframe = document.createElement('iframe');"
       "iframe.id = 'frame';"
       "document.body.appendChild(iframe);";
-  EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+  EXPECT_TRUE(ExecuteScript(root, script));
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
 
   EXPECT_EQ(1, controller.GetEntryCount());
   EXPECT_EQ(1, RendererHistoryLength(shell()));
   EXPECT_EQ(0, controller.GetLastCommittedEntryIndex());
 
   ASSERT_EQ(1U, root->child_count());
   FrameTreeNode* frame = root->child_at(0);
   ASSERT_NE(nullptr, frame);
 
   GURL blank_url(url::kAboutBlankURL);
   EXPECT_EQ(blank_url, frame->current_url());
 
   // Now create a new navigation entry. Note that the old navigation entry has
   // "about:blank" as the URL in the iframe.
 
   script = "history.pushState({}, '', 'notarealurl.html')";
-  EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+  EXPECT_TRUE(ExecuteScript(root, script));
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
 
   EXPECT_EQ(2, controller.GetEntryCount());
   EXPECT_EQ(2, RendererHistoryLength(shell()));
   EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
 
   // Load the iframe; the initial "about:blank" URL should be elided and thus we
   // shouldn't get a new navigation entry.
 
   GURL frame_url = embedded_test_server()->GetURL(
@@ skipping 91 matching lines @@
 
   // Add an iframe with a 'src'.
 
   GURL frame_url_1 = embedded_test_server()->GetURL(
       "/navigation_controller/simple_page_1.html");
   std::string script =
       "var iframe = document.createElement('iframe');"
       "iframe.src = '" + frame_url_1.spec() + "';"
       "iframe.id = 'frame';"
       "document.body.appendChild(iframe);";
-  EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+  EXPECT_TRUE(ExecuteScript(root, script));
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
 
   EXPECT_EQ(1, controller.GetEntryCount());
   EXPECT_EQ(1, RendererHistoryLength(shell()));
   EXPECT_EQ(0, controller.GetLastCommittedEntryIndex());
 
   ASSERT_EQ(1U, root->child_count());
   FrameTreeNode* frame = root->child_at(0);
   ASSERT_NE(nullptr, frame);
 
   EXPECT_EQ(frame_url_1, frame->current_url());
 
   // Do a fragment navigation, creating a new navigation entry. Note that the
   // old navigation entry has frame_url_1 as the URL in the iframe.
 
   script = "document.getElementById('fraglink').click()";
-  EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+  EXPECT_TRUE(ExecuteScript(root, script));
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
 
   EXPECT_EQ(2, controller.GetEntryCount());
   EXPECT_EQ(2, RendererHistoryLength(shell()));
   EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
 
   EXPECT_EQ(frame_url_1, frame->current_url());
 
   // Navigate the iframe; unlike the test "BackToAboutBlankIframe" above, this
   // _will_ create a new navigation entry.
@@ skipping 442 matching lines @@
   EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
 
   // Do a replaceState to a URL that will redirect when we come back to it via
   // session history.
   GURL url_3(embedded_test_server()->GetURL(
       "foo.com", "/navigation_controller/page_with_links.html"));
   {
     TestNavigationObserver observer(shell()->web_contents());
     std::string script =
         "history.replaceState({}, '', '/server-redirect?" + url_3.spec() + "')";
-    EXPECT_TRUE(ExecuteScript(root->current_frame_host(), script));
+    EXPECT_TRUE(ExecuteScript(root, script));
     observer.Wait();
   }
 
   // Go back.
   controller.GoBack();
   EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
   EXPECT_EQ(0, controller.GetLastCommittedEntryIndex());
   EXPECT_EQ(url_1, root->current_url());
 
   // Clone the tab without navigating it.
@@ skipping 43 matching lines @@
     EXPECT_EQ(-1, root_entry->post_id());
     EXPECT_EQ("GET", frame_entry->method());
     EXPECT_EQ(-1, frame_entry->post_id());
     EXPECT_FALSE(entry->GetHasPostData());
     EXPECT_EQ(-1, entry->GetPostID());
   }
 
   // Submit the form.
   TestNavigationObserver observer(shell()->web_contents(), 1);
   EXPECT_TRUE(ExecuteScript(
-      shell()->web_contents(),
-      "window.domAutomationController.send(submitForm('isubmit'))"));
+      shell(), "window.domAutomationController.send(submitForm('isubmit'))"));
   observer.Wait();
 
   EXPECT_EQ(2, controller.GetEntryCount());
   {
     NavigationEntryImpl* entry = controller.GetLastCommittedEntry();
     FrameNavigationEntry* root_entry = entry->GetFrameEntry(root);
     FrameNavigationEntry* frame_entry = entry->GetFrameEntry(frame);
     EXPECT_NE(nullptr, root_entry);
     EXPECT_NE(nullptr, frame_entry);
     EXPECT_EQ("GET", root_entry->method());
     EXPECT_EQ(-1, root_entry->post_id());
     EXPECT_EQ("POST", frame_entry->method());
     // TODO(clamy): Check the post id as well when PlzNavigate handles it
     // properly.
     if (!IsBrowserSideNavigationEnabled())
       EXPECT_NE(-1, frame_entry->post_id());
     EXPECT_FALSE(entry->GetHasPostData());
     EXPECT_EQ(-1, entry->GetPostID());
   }
 }
 
 }  // namespace content