Simplify ExecuteJavaScript* functions.

chrome/browser/ui/webui/options/preferences_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 "chrome/browser/ui/webui/options/preferences_browsertest.h"
 
 #include <iostream>
 #include <sstream>
 
 #include "base/json/json_reader.h"
@@ skipping 63 matching lines @@
 void PreferencesBrowserTest::SetUpOnMainThread() {
   ui_test_utils::NavigateToURL(browser(),
                                GURL(chrome::kChromeUISettingsFrameURL));
   content::WebContents* web_contents = chrome::GetActiveWebContents(browser());
   ASSERT_TRUE(web_contents);
   render_view_host_ = web_contents->GetRenderViewHost();
   ASSERT_TRUE(render_view_host_);
   pref_change_registrar_.Init(
       PrefServiceBase::FromBrowserContext(browser()->profile()));
   pref_service_ = browser()->profile()->GetPrefs();
-  ASSERT_TRUE(content::ExecuteJavaScript(render_view_host_,
-      "",
+  ASSERT_TRUE(content::ExecuteScript(render_view_host_,
       "function TestEnv() {"
       "  this.sentinelName_ = 'download.prompt_for_download';"
       "  this.prefs_ = [];"
       "  TestEnv.instance_ = this;"
       "}"
       ""
       "TestEnv.handleEvent = function(event) {"
       "  var env = TestEnv.instance_;"
       "  var name = event.type;"
       "  env.removePrefListener_(name);"
@@ skipping 210 matching lines @@
     std::string* observed_json) const {
   std::stringstream javascript;
   javascript << "var testEnv = new TestEnv();";
   for (std::vector<std::string>::const_iterator name = pref_names.begin();
        name != pref_names.end(); ++name)
     javascript << "testEnv.addPref('" << name->c_str() << "');";
   javascript << "testEnv.setupAndReply();";
   std::string temp_observed_json;
   if (!observed_json)
     observed_json = &temp_observed_json;
-  ASSERT_TRUE(content::ExecuteJavaScriptAndExtractString(
-      render_view_host_, "", javascript.str(), observed_json));
+  ASSERT_TRUE(content::ExecuteScriptAndExtractString(
+      render_view_host_, javascript.str(), observed_json));
 }
 
 void PreferencesBrowserTest::VerifySetPref(const std::string& name,
                                            const std::string& type,
                                            const base::Value* value,
                                            bool commit) {
   if (commit)
     ExpectSetCommit(name, value);
   else
     ExpectNoCommit(name);
   scoped_ptr<base::Value> commit_ptr(new base::FundamentalValue(commit));
   std::string value_json;
   std::string commit_json;
   base::JSONWriter::Write(value, &value_json);
   base::JSONWriter::Write(commit_ptr.get(), &commit_json);
   std::stringstream javascript;
   javascript << "testEnv.runAndReply(function() {"
              << "    Preferences.set" << type.c_str() << "Pref("
              << "      '" << name.c_str() << "',"
              << "      " << value_json.c_str() << ","
              << "      " << commit_json.c_str() << ");});";
   std::string observed_json;
-  ASSERT_TRUE(content::ExecuteJavaScriptAndExtractString(
-      render_view_host_, "", javascript.str(), &observed_json));
+  ASSERT_TRUE(content::ExecuteScriptAndExtractString(
+      render_view_host_, javascript.str(), &observed_json));
   VerifyObservedPref(observed_json, name, value, "", false, !commit);
   VerifyAndClearExpectations();
 }
 
 void PreferencesBrowserTest::VerifyClearPref(const std::string& name,
                                              const base::Value* value,
                                              bool commit) {
   if (commit)
     ExpectClearCommit(name);
   else
     ExpectNoCommit(name);
   scoped_ptr<base::Value> commit_ptr(new base::FundamentalValue(commit));
   std::string commit_json;
   base::JSONWriter::Write(commit_ptr.get(), &commit_json);
   std::stringstream javascript;
   javascript << "testEnv.runAndReply(function() {"
              << "    Preferences.clearPref("
              << "      '" << name.c_str() << "',"
              << "      " << commit_json.c_str() << ");});";
   std::string observed_json;
-  ASSERT_TRUE(content::ExecuteJavaScriptAndExtractString(
-      render_view_host_, "", javascript.str(), &observed_json));
+  ASSERT_TRUE(content::ExecuteScriptAndExtractString(
+      render_view_host_, javascript.str(), &observed_json));
   VerifyObservedPref(observed_json, name, value, "recommended", false, !commit);
   VerifyAndClearExpectations();
 }
 
 void PreferencesBrowserTest::VerifyCommit(const std::string& name,
                                           const base::Value* value,
                                           const std::string& controlledBy) {
   std::stringstream javascript;
   javascript << "testEnv.runAndReply(function() {"
              << "    Preferences.getInstance().commitPref("
              << "        '" << name.c_str() << "');});";
   std::string observed_json;
-  ASSERT_TRUE(content::ExecuteJavaScriptAndExtractString(
-      render_view_host_, "", javascript.str(), &observed_json));
+  ASSERT_TRUE(content::ExecuteScriptAndExtractString(
+      render_view_host_, javascript.str(), &observed_json));
   VerifyObservedPref(observed_json, name, value, controlledBy, false, false);
 }
 
 void PreferencesBrowserTest::VerifySetCommit(const std::string& name,
                                              const base::Value* value) {
   ExpectSetCommit(name, value);
   VerifyCommit(name, value, "");
   VerifyAndClearExpectations();
 }
 
 void PreferencesBrowserTest::VerifyClearCommit(const std::string& name,
                                                const base::Value* value) {
   ExpectClearCommit(name);
   VerifyCommit(name, value, "recommended");
   VerifyAndClearExpectations();
 }
 
 void PreferencesBrowserTest::VerifyRollback(const std::string& name,
                                             const base::Value* value,
                                             const std::string& controlledBy) {
   ExpectNoCommit(name);
   std::stringstream javascript;
   javascript << "testEnv.runAndReply(function() {"
              << "    Preferences.getInstance().rollbackPref("
              << "        '" << name.c_str() << "');});";
   std::string observed_json;
-  ASSERT_TRUE(content::ExecuteJavaScriptAndExtractString(
-      render_view_host_, "", javascript.str(), &observed_json));
+  ASSERT_TRUE(content::ExecuteScriptAndExtractString(
+      render_view_host_, javascript.str(), &observed_json));
   VerifyObservedPref(observed_json, name, value, controlledBy, false, true);
   VerifyAndClearExpectations();
 }
 
 void PreferencesBrowserTest::StartObserving() {
-  ASSERT_TRUE(content::ExecuteJavaScript(
-      render_view_host_, "", "testEnv.startObserving();"));
+  ASSERT_TRUE(content::ExecuteScript(
+      render_view_host_, "testEnv.startObserving();"));
 }
 
 void PreferencesBrowserTest::FinishObserving(std::string* observed_json) {
-  ASSERT_TRUE(content::ExecuteJavaScriptAndExtractString(
+  ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       render_view_host_,
-      "",
       "testEnv.finishObservingAndReply();",
       observed_json));
 }
 
 void PreferencesBrowserTest::UseDefaultTestPrefs(bool includeListPref) {
   // Boolean pref.
   types_.push_back("Boolean");
   pref_names_.push_back(prefs::kAlternateErrorPagesEnabled);
   policy_names_.push_back(policy::key::kAlternateErrorPagesEnabled);
   non_default_values_.push_back(new base::FundamentalValue(false));
@@ skipping 306 matching lines @@
   // Do not set the Boolean pref. It will toogle automatically.
   for (size_t i = 1; i < pref_names_.size(); ++i)
     chromeos::proxy_cros_settings_parser::SetProxyPrefValue(
         profile, pref_names_[i], non_default_values_[i]->DeepCopy());
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, non_default_values_,
                       "", false, false);
 }
 
 #endif