Simplify ExecuteJavaScript* functions.

chrome/browser/prerender/prerender_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 <deque>
 
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 764 matching lines @@
 
   // Called after the prerendered page has been navigated to and then away from.
   // Navigates back through the history to the prerendered page.
   void GoBackToPrerender() {
     content::WindowedNotificationObserver back_nav_observer(
         content::NOTIFICATION_NAV_ENTRY_COMMITTED,
         content::NotificationService::AllSources());
     chrome::GoBack(current_browser(), CURRENT_TAB);
     back_nav_observer.Wait();
     bool original_prerender_page = false;
-    ASSERT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-        chrome::GetActiveWebContents(current_browser())->GetRenderViewHost(),
-        "",
+    ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
+        chrome::GetActiveWebContents(current_browser()),
         "window.domAutomationController.send(IsOriginalPrerenderPage())",
         &original_prerender_page));
     EXPECT_TRUE(original_prerender_page);
   }
 
   // Goes back to the page that was active before the prerender was swapped
   // in. This must be called when the prerendered page is the current page
   // in the active tab.
   void GoBackToPageBeforePrerender() {
     WebContents* tab = chrome::GetActiveWebContents(current_browser());
     ASSERT_TRUE(tab);
     EXPECT_FALSE(tab->IsLoading());
     content::WindowedNotificationObserver back_nav_observer(
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(&tab->GetController()));
     chrome::GoBack(current_browser(), CURRENT_TAB);
     back_nav_observer.Wait();
     bool js_result;
-    ASSERT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-        tab->GetRenderViewHost(),
-        "",
+    ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
+        tab,
         "window.domAutomationController.send(DidBackToOriginalPagePass())",
         &js_result));
     EXPECT_TRUE(js_result);
   }
 
   void NavigateToURL(const std::string& dest_html_file) const {
     GURL dest_url = test_server()->GetURL(dest_html_file);
     NavigateToURLImpl(dest_url, CURRENT_TAB);
   }
 
@@ skipping 30 matching lines @@
             current_browser()->profile());
     return prerender_link_manager;
   }
 
   bool DidReceivePrerenderStartEventForLinkNumber(int index) const {
     bool received_prerender_started;
     std::string expression = base::StringPrintf(
         "window.domAutomationController.send(Boolean("
             "receivedPrerenderStartEvents[%d]))", index);
 
-    CHECK(content::ExecuteJavaScriptAndExtractBool(
-        chrome::GetActiveWebContents(current_browser())->GetRenderViewHost(),
-        "",
+    CHECK(content::ExecuteScriptAndExtractBool(
+        chrome::GetActiveWebContents(current_browser()),
         expression,
         &received_prerender_started));
     return received_prerender_started;
   }
 
   bool DidReceivePrerenderLoadEventForLinkNumber(int index) const {
     bool received_prerender_loaded;
     std::string expression = base::StringPrintf(
         "window.domAutomationController.send(Boolean("
             "receivedPrerenderLoadEvents[%d]))", index);
 
-    CHECK(content::ExecuteJavaScriptAndExtractBool(
-        chrome::GetActiveWebContents(current_browser())->GetRenderViewHost(),
-        "", expression,
+    CHECK(content::ExecuteScriptAndExtractBool(
+        chrome::GetActiveWebContents(current_browser()),
+        expression,
         &received_prerender_loaded));
     return received_prerender_loaded;
   }
 
   bool DidReceivePrerenderStopEventForLinkNumber(int index) const {
     bool received_prerender_stopped;
     std::string expression = base::StringPrintf(
         "window.domAutomationController.send(Boolean("
             "receivedPrerenderStopEvents[%d]))", index);
 
-    CHECK(content::ExecuteJavaScriptAndExtractBool(
-        chrome::GetActiveWebContents(current_browser())->GetRenderViewHost(),
-        "",
+    CHECK(content::ExecuteScriptAndExtractBool(
+        chrome::GetActiveWebContents(current_browser()),
         expression,
         &received_prerender_stopped));
     return received_prerender_stopped;
   }
 
   bool HadPrerenderEventErrors() const {
     bool had_prerender_event_errors;
-    CHECK(content::ExecuteJavaScriptAndExtractBool(
-        chrome::GetActiveWebContents(current_browser())->GetRenderViewHost(),
-        "", "window.domAutomationController.send(Boolean("
-            "hadPrerenderEventErrors))", &had_prerender_event_errors));
+    CHECK(content::ExecuteScriptAndExtractBool(
+        chrome::GetActiveWebContents(current_browser()),
+        "window.domAutomationController.send(Boolean("
+        "    hadPrerenderEventErrors))",
+        &had_prerender_event_errors));
     return had_prerender_event_errors;
   }
 
   // Asserting on this can result in flaky tests.  PrerenderHandles are
   // removed from the PrerenderLinkManager when the prerender is canceled from
   // the browser, when the prerenders are cancelled from the renderer process,
   // or the channel for the renderer process is closed on the IO thread.  In the
   // last case, the code must be careful to wait for the channel to close, as it
   // is done asynchronously after swapping out the old process.  See
   // ChannelDestructionWatcher.
@@ skipping 142 matching lines @@
       ASSERT_NE(static_cast<PrerenderContents*>(NULL), prerender_contents);
       EXPECT_EQ(FINAL_STATUS_MAX, prerender_contents->final_status());
 
       if (call_javascript_ && expected_number_of_loads > 0) {
         // Wait for the prerendered page to change title to signal it is ready
         // if required.
         prerender_contents->WaitForPrerenderToHaveReadyTitleIfRequired();
 
         // Check if page behaves as expected while in prerendered state.
         bool prerender_test_result = false;
-        ASSERT_TRUE(content::ExecuteJavaScriptAndExtractBool(
+        ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
             prerender_contents->GetRenderViewHostMutable(),
-            "",
             "window.domAutomationController.send(DidPrerenderPass())",
             &prerender_test_result));
         EXPECT_TRUE(prerender_test_result);
       }
     } else {
       // In the failure case, we should have removed |dest_url_| from the
       // prerender_manager.  We ignore dummy PrerenderContents (as indicated
       // by not having started), and PrerenderContents that are expected to
       // be left in the manager until the test finishes.
       EXPECT_TRUE(prerender_contents == NULL ||
@@ skipping 36 matching lines @@
         ui_test_utils::BROWSER_TEST_NONE);
 
     // Make sure the PrerenderContents found earlier was used or removed.
     EXPECT_EQ(static_cast<PrerenderContents*>(NULL), GetPrerenderContents());
 
     if (call_javascript_ && web_contents) {
       if (page_load_observer.get())
         page_load_observer->Wait();
 
       bool display_test_result = false;
-      ASSERT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-          web_contents->GetRenderViewHost(),
-          "",
+      ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
+          web_contents,
           "window.domAutomationController.send(DidDisplayPass())",
           &display_test_result));
       EXPECT_TRUE(display_test_result);
     }
   }
 
   // Opens the prerendered page using javascript functions in the
   // loader page. |javascript_function_name| should be a 0 argument function
   // which is invoked.
   void OpenDestURLWithJSImpl(const std::string& javascript_function_name)
@@ skipping 291 matching lines @@
 
   // Run this check again.  When we try to load aa ppapi plugin, the
   // "loadstart" event is asynchronously posted to a message loop.
   // It's possible that earlier call could have been run before the
   // the "loadstart" event was posted.
   // TODO(mmenke):  While this should reliably fail on regressions, the
   //                reliability depends on the specifics of ppapi plugin
   //                loading.  It would be great if we could avoid that.
   WebContents* web_contents = chrome::GetActiveWebContents(browser());
   bool display_test_result = false;
-  ASSERT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-      web_contents->GetRenderViewHost(),
-      "",
+  ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
+      web_contents,
       "window.domAutomationController.send(DidDisplayPass())",
       &display_test_result));
   EXPECT_TRUE(display_test_result);
 }
 
 // Checks that plugins in an iframe are not loaded while a page is
 // being preloaded, but are loaded when the page is displayed.
 #if defined(USE_AURA)
 // http://crbug.com/103496
 #define MAYBE_PrerenderIframeDelayLoadPlugin \
@@ skipping 1160 matching lines @@
                        PrerenderNaClPluginEnabled) {
   PrerenderTestURL("files/prerender/prerender_plugin_nacl_enabled.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 
   // To avoid any chance of a race, we have to let the script send its response
   // asynchronously.
   WebContents* web_contents = chrome::GetActiveWebContents(browser());
   bool display_test_result = false;
-  ASSERT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-      web_contents->GetRenderViewHost(),
-      "",
-      "DidDisplayReallyPass()",
-      &display_test_result));
+  ASSERT_TRUE(content::ExecuteScriptAndExtractBool(web_contents,
+                                                   "DidDisplayReallyPass()",
+                                                   &display_test_result));
   ASSERT_TRUE(display_test_result);
 }
 
 // Checks that the referrer policy is used when prerendering.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderReferrerPolicy) {
   set_loader_path("files/prerender/prerender_loader_with_referrer_policy.html");
   PrerenderTestURL("files/prerender/prerender_referrer_policy.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
@@ skipping 58 matching lines @@
   channel_close_watcher.WatchChannel(
       chrome::GetActiveWebContents(browser())->GetRenderProcessHost());
   NavigateToDestURL();
   channel_close_watcher.WaitForChannelClose();
 
   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 }  // namespace prerender