Change ExecuteJavaScript* helper functions in browser_test_utils.{h,cc}

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 766 matching lines @@
   // 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(),
-        L"", L"window.domAutomationController.send(IsOriginalPrerenderPage())",
+        "",
+        "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(), L"",
-        L"window.domAutomationController.send(DidBackToOriginalPagePass())",
+        tab->GetRenderViewHost(),
+        "",
+        "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);
   }
 
   bool UrlIsInPrerenderManager(const std::string& html_file) const {
@@ skipping 25 matching lines @@
 
   const PrerenderLinkManager* GetPrerenderLinkManager() const {
     PrerenderLinkManager* prerender_link_manager =
         PrerenderLinkManagerFactory::GetForProfile(
             current_browser()->profile());
     return prerender_link_manager;
   }
 
   bool DidReceivePrerenderStartEventForLinkNumber(int index) const {
     bool received_prerender_started;
-    std::wstring expression = base::StringPrintf(
-        L"window.domAutomationController.send(Boolean("
-            L"receivedPrerenderStartEvents[%d]))", index);
+    std::string expression = base::StringPrintf(
+        "window.domAutomationController.send(Boolean("
+            "receivedPrerenderStartEvents[%d]))", index);
 
     CHECK(content::ExecuteJavaScriptAndExtractBool(
         chrome::GetActiveWebContents(current_browser())->GetRenderViewHost(),
-        L"", expression,
+        "",
+        expression,
         &received_prerender_started));
     return received_prerender_started;
   }
 
   bool DidReceivePrerenderStopEventForLinkNumber(int index) const {
     bool received_prerender_stopped;
-    std::wstring expression = base::StringPrintf(
-        L"window.domAutomationController.send(Boolean("
-            L"receivedPrerenderStopEvents[%d]))", index);
+    std::string expression = base::StringPrintf(
+        "window.domAutomationController.send(Boolean("
+            "receivedPrerenderStopEvents[%d]))", index);
 
     CHECK(content::ExecuteJavaScriptAndExtractBool(
         chrome::GetActiveWebContents(current_browser())->GetRenderViewHost(),
-        L"", expression,
+        "",
+        expression,
         &received_prerender_stopped));
     return received_prerender_stopped;
   }
 
   // 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
@@ skipping 144 matching lines @@
       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(
-            prerender_contents->GetRenderViewHostMutable(), L"",
-            L"window.domAutomationController.send(DidPrerenderPass())",
+            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 ||
                   !prerender_contents->prerendering_has_started());
@@ skipping 36 matching lines @@
 
     // 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(), L"",
-          L"window.domAutomationController.send(DidDisplayPass())",
+          web_contents->GetRenderViewHost(),
+          "",
+          "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)
       const {
@@ skipping 286 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(), L"",
-      L"window.domAutomationController.send(DidDisplayPass())",
+      web_contents->GetRenderViewHost(),
+      "",
+      "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 \
         DISABLED_PrerenderIframeDelayLoadPlugin
@@ skipping 1145 matching lines @@
   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(), L"",
-      L"DidDisplayReallyPass()",
+      web_contents->GetRenderViewHost(),
+      "",
+      "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);
@@ skipping 59 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