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

chrome/browser/policy/policy_prefs_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 <algorithm>
 #include <map>
 #include <sstream>
 #include <string>
 #include <vector>
 
@@ skipping 63 matching lines @@
 // Contains the testing details for a single pref affected by a policy. This is
 // part of the data loaded from chrome/test/data/policy/policy_test_cases.json.
 class PrefMapping {
  public:
   PrefMapping(const std::string& pref,
               bool is_local_state,
               const std::string& indicator_test_setup_js,
               const std::string& indicator_selector)
       : pref_(pref),
         is_local_state_(is_local_state),
+        indicator_test_setup_js_(indicator_test_setup_js),
         indicator_selector_(indicator_selector) {
-    indicator_test_setup_js_ = ASCIIToWide(indicator_test_setup_js);
   }
   ~PrefMapping() {}
 
   const std::string& pref() const { return pref_; }
 
   bool is_local_state() const { return is_local_state_; }
 
-  const std::wstring& indicator_test_setup_js() const {
+  const std::string& indicator_test_setup_js() const {
     return indicator_test_setup_js_;
   }
 
   const std::string& indicator_selector() const {
     return indicator_selector_;
   }
 
   const ScopedVector<IndicatorTestCase>& indicator_test_cases() const {
     return indicator_test_cases_;
   }
   void AddIndicatorTestCase(IndicatorTestCase* test_case) {
     indicator_test_cases_.push_back(test_case);
   }
 
  private:
   std::string pref_;
   bool is_local_state_;
-  std::wstring indicator_test_setup_js_;
+  std::string indicator_test_setup_js_;
   std::string indicator_selector_;
   ScopedVector<IndicatorTestCase> indicator_test_cases_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefMapping);
 };
 
 // Contains the testing details for a single policy. This is part of the data
 // loaded from chrome/test/data/policy/policy_test_cases.json.
 class PolicyTestCase {
  public:
@@ skipping 182 matching lines @@
   PolicyTestCaseMap* policy_test_cases_;
 
   DISALLOW_COPY_AND_ASSIGN(PolicyTestCases);
 };
 
 void VerifyControlledSettingIndicators(Browser* browser,
                                        const std::string& selector,
                                        const std::string& value,
                                        const std::string& controlled_by,
                                        bool readonly) {
-  std::wstringstream javascript;
+  std::stringstream javascript;
   javascript << "var nodes = document.querySelectorAll("
              << "    'span.controlled-setting-indicator"
              <<          selector.c_str() << "');"
              << "var indicators = [];"
              << "for (var i = 0; i < nodes.length; i++) {"
              << "  var node = nodes[i];"
              << "  var indicator = {};"
              << "  indicator.value = node.value || '';"
              << "  indicator.controlledBy = node.controlledBy || '';"
              << "  indicator.readOnly = node.readOnly || false;"
              << "  indicator.visible ="
              << "      window.getComputedStyle(node).display != 'none';"
              << "  indicators.push(indicator)"
              << "}"
              << "domAutomationController.send(JSON.stringify(indicators));";
   content::WebContents* contents = chrome::GetActiveWebContents(browser);
   std::string json;
   // Retrieve the state of all controlled setting indicators matching the
   // |selector| as JSON.
   ASSERT_TRUE(content::ExecuteJavaScriptAndExtractString(
-      contents->GetRenderViewHost(), L"", javascript.str(), &json));
+      contents->GetRenderViewHost(), "", javascript.str(), &json));
   scoped_ptr<base::Value> value_ptr(base::JSONReader::Read(json));
   const base::ListValue* indicators = NULL;
   ASSERT_TRUE(value_ptr.get());
   ASSERT_TRUE(value_ptr->GetAsList(&indicators));
   // Verify that controlled setting indicators representing |value| are visible
   // and have the correct state while those not representing |value| are
   // invisible.
   if (!controlled_by.empty()) {
     EXPECT_GT(indicators->GetSize(), 0u)
         << "Expected to find at least one controlled setting indicator.";
@@ skipping 139 matching lines @@
        pref_mapping != pref_mappings.end();
        ++pref_mapping) {
     const ScopedVector<IndicatorTestCase>&
         indicator_test_cases = (*pref_mapping)->indicator_test_cases();
     if (indicator_test_cases.empty())
       continue;
 
     ui_test_utils::NavigateToURL(browser(), GURL(kMainSettingsPage));
     if (!(*pref_mapping)->indicator_test_setup_js().empty()) {
       ASSERT_TRUE(content::ExecuteJavaScript(
-          chrome::GetActiveWebContents(browser())->GetRenderViewHost(), L"",
+          chrome::GetActiveWebContents(browser())->GetRenderViewHost(),
+          "",
           (*pref_mapping)->indicator_test_setup_js()));
     }
 
     std::string indicator_selector = (*pref_mapping)->indicator_selector();
     if (indicator_selector.empty())
       indicator_selector = "[pref=\"" + (*pref_mapping)->pref() + "\"]";
     for (ScopedVector<IndicatorTestCase>::const_iterator
              indicator_test_case = indicator_test_cases.begin();
          indicator_test_case != indicator_test_cases.end();
          ++indicator_test_case) {
@@ skipping 48 matching lines @@
   }
 }
 
 INSTANTIATE_TEST_CASE_P(
     PolicyPrefsTestInstance,
     PolicyPrefsTest,
     testing::ValuesIn(GetChromePolicyDefinitionList()->begin,
                       GetChromePolicyDefinitionList()->end));
 
 }  // namespace policy