Simplify ExecuteJavaScript* functions.

chrome/browser/ssl/ssl_browser_tests.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 "base/command_line.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
@@ skipping 162 matching lines @@
   void CheckWorkerLoadResult(WebContents* tab, bool expectLoaded) {
     // Workers are async and we don't have notifications for them passing
     // messages since they do it between renderer and worker processes.
     // So have a polling loop, check every 200ms, timeout at 30s.
     const int timeout_ms = 200;
     base::Time timeToQuit = base::Time::Now() +
         base::TimeDelta::FromMilliseconds(30000);
 
     while (base::Time::Now() < timeToQuit) {
       bool workerFinished = false;
-      ASSERT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-          tab->GetRenderViewHost(),
-          "",
+      ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
+          tab,
           "window.domAutomationController.send(IsWorkerFinished());",
           &workerFinished));
 
       if (workerFinished)
         break;
 
       // Wait a bit.
       MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
           MessageLoop::QuitClosure(),
           base::TimeDelta::FromMilliseconds(timeout_ms));
       content::RunMessageLoop();
     }
 
     bool actuallyLoadedContent = false;
-    ASSERT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-        tab->GetRenderViewHost(),
-        "",
+    ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
+        tab,
         "window.domAutomationController.send(IsContentLoaded());",
         &actuallyLoadedContent));
     EXPECT_EQ(expectLoaded, actuallyLoadedContent);
   }
 
   void ProceedThroughInterstitial(WebContents* tab) {
     InterstitialPage* interstitial_page = tab->GetInterstitialPage();
     ASSERT_TRUE(interstitial_page);
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
@@ skipping 641 matching lines @@
   CheckAuthenticatedState(tab, false);
 
   // Because of cross-frame scripting restrictions, we cannot access the iframe
   // content.  So to know if the frame was loaded, we just check if a popup was
   // opened (the iframe content opens one).
   // Note: because of bug 1115868, no constrained window is opened right now.
   //       Once the bug is fixed, this will do the real check.
   EXPECT_EQ(0U, GetConstrainedWindowCount());
 
   int img_width;
-  EXPECT_TRUE(content::ExecuteJavaScriptAndExtractInt(
-      tab->GetRenderViewHost(),
-      "",
+  EXPECT_TRUE(content::ExecuteScriptAndExtractInt(
+      tab,
       "window.domAutomationController.send(ImageWidth());",
       &img_width));
   // In order to check that the image was not loaded, we check its width.
   // The actual image (Google logo) is 114 pixels wide, we assume the broken
   // image is less than 100.
   EXPECT_LT(img_width, 100);
 
   bool js_result = false;
-  EXPECT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-      tab->GetRenderViewHost(),
-      "",
+  EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
+      tab,
       "window.domAutomationController.send(IsFooSet());",
       &js_result));
   EXPECT_FALSE(js_result);
 }
 
 // Visits a page with insecure content loaded by JS (after the initial page
 // load).
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestDisplaysInsecureContentLoadedFromJS) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_.Start());
 
   std::string replacement_path;
   ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_with_dynamic_insecure_content.html",
       test_server()->host_port_pair(),
       &replacement_path));
   ui_test_utils::NavigateToURL(browser(), https_server_.GetURL(
       replacement_path));
 
   WebContents* tab = chrome::GetActiveWebContents(browser());
   CheckAuthenticatedState(tab, false);
 
   // Load the insecure image.
   bool js_result = false;
-  EXPECT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-      tab->GetRenderViewHost(),
-      "",
+  EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
+      tab,
       "loadBadImage();",
       &js_result));
   EXPECT_TRUE(js_result);
 
   // We should now have insecure content.
   CheckAuthenticatedState(tab, true);
 }
 
 // Visits two pages from the same origin: one that displays insecure content and
 // one that doesn't.  The test checks that we do not propagate the insecure
@@ skipping 381 matching lines @@
                                https_server_.GetURL(top_frame_path));
 
   CheckAuthenticatedState(tab, false);
 
   bool success = false;
   // Now navigate inside the frame.
   {
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(&tab->GetController()));
-    EXPECT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-        tab->GetRenderViewHost(),
-        "",
+    EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
+        tab,
         "window.domAutomationController.send(clickLink('goodHTTPSLink'));",
         &success));
     ASSERT_TRUE(success);
     observer.Wait();
   }
 
   // We should still be fine.
   CheckAuthenticatedState(tab, false);
 
   // Now let's hit a bad page.
   {
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(&tab->GetController()));
-    EXPECT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-        tab->GetRenderViewHost(),
-        "",
+    EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
+        tab,
         "window.domAutomationController.send(clickLink('badHTTPSLink'));",
         &success));
     ASSERT_TRUE(success);
     observer.Wait();
   }
 
   // The security style should still be secure.
   CheckAuthenticatedState(tab, false);
 
   // And the frame should be blocked.
   bool is_content_evil = true;
   std::string content_frame_xpath("html/frameset/frame[2]");
   std::string is_evil_js("window.domAutomationController.send("
                          "document.getElementById('evilDiv') != null);");
-  EXPECT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-      tab->GetRenderViewHost(),
+  EXPECT_TRUE(content::ExecuteScriptInFrameAndExtractBool(
+      tab,
       content_frame_xpath,
       is_evil_js,
       &is_content_evil));
   EXPECT_FALSE(is_content_evil);
 
   // Now go back, our state should still be OK.
   {
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(&tab->GetController()));
     tab->GetController().GoBack();
     observer.Wait();
   }
   CheckAuthenticatedState(tab, false);
 
   // Navigate to a page served over HTTP.
   {
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(&tab->GetController()));
-    EXPECT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-        tab->GetRenderViewHost(),
-        "",
+    EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
+        tab,
         "window.domAutomationController.send(clickLink('HTTPLink'));",
         &success));
     ASSERT_TRUE(success);
     observer.Wait();
   }
 
   // Our state should be insecure.
   CheckAuthenticatedState(tab, true);
 
   // Go back, our state should be unchanged.
@@ skipping 25 matching lines @@
   CheckAuthenticationBrokenState(tab, net::CERT_STATUS_DATE_INVALID, false,
                                  true);  // Interstitial showing
 
   ProceedThroughInterstitial(tab);
 
   // Navigate to a good frame.
   bool success = false;
   content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(&tab->GetController()));
-  EXPECT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-      tab->GetRenderViewHost(),
-      "",
+  EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
+      tab,
       "window.domAutomationController.send(clickLink('goodHTTPSLink'));",
       &success));
   ASSERT_TRUE(success);
   observer.Wait();
 
   // We should still be authentication broken.
   CheckAuthenticationBrokenState(tab, net::CERT_STATUS_DATE_INVALID, false,
                                  false);
 }
 
@@ skipping 15 matching lines @@
   ui_test_utils::NavigateToURL(browser(),
                                test_server()->GetURL(top_frame_path));
   CheckUnauthenticatedState(tab);
 
   // Now navigate inside the frame to a secure HTTPS frame.
   {
     bool success = false;
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(&tab->GetController()));
-    EXPECT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-        tab->GetRenderViewHost(),
-        "",
+    EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
+        tab,
         "window.domAutomationController.send(clickLink('goodHTTPSLink'));",
         &success));
     ASSERT_TRUE(success);
     observer.Wait();
   }
 
   // We should still be unauthenticated.
   CheckUnauthenticatedState(tab);
 
   // Now navigate to a bad HTTPS frame.
   {
     bool success = false;
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(&tab->GetController()));
-    EXPECT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-        tab->GetRenderViewHost(),
-        "",
+    EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
+        tab,
         "window.domAutomationController.send(clickLink('badHTTPSLink'));",
         &success));
     ASSERT_TRUE(success);
     observer.Wait();
   }
 
   // State should not have changed.
   CheckUnauthenticatedState(tab);
 
   // And the frame should have been blocked (see bug #2316).
   bool is_content_evil = true;
   std::string content_frame_xpath("html/frameset/frame[2]");
   std::string is_evil_js("window.domAutomationController.send("
                          "document.getElementById('evilDiv') != null);");
-  EXPECT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-      tab->GetRenderViewHost(),
+  EXPECT_TRUE(content::ExecuteScriptInFrameAndExtractBool(
+      tab,
       content_frame_xpath,
       is_evil_js,
       &is_content_evil));
   EXPECT_FALSE(is_content_evil);
 }
 
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestUnsafeContentsInWorkerFiltered) {
   ASSERT_TRUE(https_server_.Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
@@ skipping 129 matching lines @@
 
 // Visit a page over https that contains a frame with a redirect.
 
 // XMLHttpRequest insecure content in synchronous mode.
 
 // XMLHttpRequest insecure content in asynchronous mode.
 
 // XMLHttpRequest over bad ssl in synchronous mode.
 
 // XMLHttpRequest over OK ssl in synchronous mode.