Adding the ability to pass arguments to JS tests from the C++ side. This enables us to easily pass suppression lists to the bidi checker (another CL will follow for that).

BUG=NONE
TEST=NONE


Review URL: http://codereview.chromium.org/6854021

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@83333 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 113 insertions, 18 deletions

diff --git a/content/browser/webui/web_ui.cc b/content/browser/webui/web_ui.cc
index 995a229..bc3abc7 100644
--- a/content/browser/webui/web_ui.cc
+++ b/content/browser/webui/web_ui.cc
@@ -22,10 +22,10 @@
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 
-namespace {
-
-string16 GetJavascript(const std::string& function_name,
-                       const std::vector<const Value*>& arg_list) {
+// static
+string16 WebUI::GetJavascriptCall(
+    const std::string& function_name,
+    const std::vector<const Value*>& arg_list) {
   string16 parameters;
   std::string json;
   for (size_t i = 0; i < arg_list.size(); ++i) {
@@ -39,8 +39,6 @@ string16 GetJavascript(const std::string& function_name,
       char16('(') + parameters + char16(')') + char16(';');
 }
 
-}  // namespace
-
 WebUI::WebUI(TabContents* contents)
     : hide_favicon_(false),
       force_bookmark_bar_visible_(false),
@@ -103,7 +101,7 @@ void WebUI::CallJavascriptFunction(const std::string& function_name,
   DCHECK(IsStringASCII(function_name));
   std::vector<const Value*> args;
   args.push_back(&arg);
-  ExecuteJavascript(GetJavascript(function_name, args));
+  ExecuteJavascript(WebUI::GetJavascriptCall(function_name, args));
 }
 
 void WebUI::CallJavascriptFunction(
@@ -113,7 +111,7 @@ void WebUI::CallJavascriptFunction(
   std::vector<const Value*> args;
   args.push_back(&arg1);
   args.push_back(&arg2);
-  ExecuteJavascript(GetJavascript(function_name, args));
+  ExecuteJavascript(WebUI::GetJavascriptCall(function_name, args));
 }
 
 void WebUI::CallJavascriptFunction(
@@ -124,7 +122,7 @@ void WebUI::CallJavascriptFunction(
   args.push_back(&arg1);
   args.push_back(&arg2);
   args.push_back(&arg3);
-  ExecuteJavascript(GetJavascript(function_name, args));
+  ExecuteJavascript(WebUI::GetJavascriptCall(function_name, args));
 }
 
 void WebUI::CallJavascriptFunction(
@@ -139,14 +137,14 @@ void WebUI::CallJavascriptFunction(
   args.push_back(&arg2);
   args.push_back(&arg3);
   args.push_back(&arg4);
-  ExecuteJavascript(GetJavascript(function_name, args));
+  ExecuteJavascript(WebUI::GetJavascriptCall(function_name, args));
 }
 
 void WebUI::CallJavascriptFunction(
     const std::string& function_name,
     const std::vector<const Value*>& args) {
   DCHECK(IsStringASCII(function_name));
-  ExecuteJavascript(GetJavascript(function_name, args));
+  ExecuteJavascript(WebUI::GetJavascriptCall(function_name, args));
 }
 
 void WebUI::RegisterMessageCallback(const std::string &message,
diff --git a/content/browser/webui/web_ui.h b/content/browser/webui/web_ui.h
index e44f1bd..910fc5c 100644
--- a/content/browser/webui/web_ui.h
+++ b/content/browser/webui/web_ui.h
@@ -157,6 +157,11 @@ class WebUI : public IPC::Channel::Listener {
   // Web UI system.
   static const TypeID kNoWebUI;
 
+  // Returns JavaScript code that, when executed, calls the function specified
+  // by |function_name| with the arguments specified in |arg_list|.
+  static string16 GetJavascriptCall(const std::string& function_name,
+                                    const std::vector<const Value*>& arg_list);
+
  protected:
   void AddMessageHandler(WebUIMessageHandler* handler);
 
diff --git a/content/browser/webui/web_ui_browsertest.cc b/content/browser/webui/web_ui_browsertest.cc
index be72c48..23448ee 100644
--- a/content/browser/webui/web_ui_browsertest.cc
+++ b/content/browser/webui/web_ui_browsertest.cc
@@ -1,18 +1,19 @@
 // Copyright (c) 2011 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 "content/browser/webui/web_ui_browsertest.h"
 
 #include <string>
 #include <vector>
 
 #include "base/path_service.h"
+#include "base/values.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/ui_test_utils.h"
 #include "content/browser/tab_contents/tab_contents.h"
+#include "content/browser/webui/web_ui.h"
 #include "ui/base/resource/resource_bundle.h"
 
 static const FilePath::CharType* kWebUILibraryJS =
@@ -34,11 +35,55 @@ bool LogHandler(int severity,
 WebUIBrowserTest::~WebUIBrowserTest() {}
 
 bool WebUIBrowserTest::RunJavascriptFunction(const std::string& function_name) {
-  return RunJavascriptUsingHandler(function_name, false);
+  return RunJavascriptFunction(function_name, ConstValueVector());
+}
+
+bool WebUIBrowserTest::RunJavascriptFunction(const std::string& function_name,
+                                             const Value& arg) {
+  ConstValueVector args;
+  args.push_back(&arg);
+  return RunJavascriptFunction(function_name, args);
+}
+
+bool WebUIBrowserTest::RunJavascriptFunction(const std::string& function_name,
+                                             const Value& arg1,
+                                             const Value& arg2) {
+  ConstValueVector args;
+  args.push_back(&arg1);
+  args.push_back(&arg2);
+  return RunJavascriptFunction(function_name, args);
+}
+
+bool WebUIBrowserTest::RunJavascriptFunction(
+    const std::string& function_name,
+    const ConstValueVector& function_arguments) {
+  return RunJavascriptUsingHandler(function_name, function_arguments, false);
 }
 
 bool WebUIBrowserTest::RunJavascriptTest(const std::string& test_name) {
-  return RunJavascriptUsingHandler(test_name, true);
+  return RunJavascriptTest(test_name, ConstValueVector());
+}
+
+bool WebUIBrowserTest::RunJavascriptTest(const std::string& test_name,
+                                         const Value& arg) {
+  ConstValueVector args;
+  args.push_back(&arg);
+  return RunJavascriptTest(test_name, args);
+}
+
+bool WebUIBrowserTest::RunJavascriptTest(const std::string& test_name,
+                                         const Value& arg1,
+                                         const Value& arg2) {
+  ConstValueVector args;
+  args.push_back(&arg1);
+  args.push_back(&arg2);
+  return RunJavascriptTest(test_name, args);
+}
+
+bool WebUIBrowserTest::RunJavascriptTest(
+    const std::string& test_name,
+    const ConstValueVector& test_arguments) {
+  return RunJavascriptUsingHandler(test_name, test_arguments, true);
 }
 
 WebUIBrowserTest::WebUIBrowserTest()
@@ -76,15 +121,39 @@ void WebUIBrowserTest::BuildJavascriptLibraries(std::string* content) {
   }
 }
 
+string16 WebUIBrowserTest::BuildRunTestJSCall(
+    const std::string& function_name,
+    const WebUIBrowserTest::ConstValueVector& test_func_args) {
+  WebUIBrowserTest::ConstValueVector arguments;
+  StringValue function_name_arg(function_name);
+  arguments.push_back(&function_name_arg);
+  ListValue baked_argument_list;
+  WebUIBrowserTest::ConstValueVector::const_iterator arguments_iterator;
+  for (arguments_iterator = test_func_args.begin();
+       arguments_iterator != test_func_args.end();
+       ++arguments_iterator) {
+    baked_argument_list.Append((Value *)*arguments_iterator);
+  }
+  arguments.push_back(&baked_argument_list);
+  return WebUI::GetJavascriptCall(std::string("runTest"), arguments);
+}
+
 bool WebUIBrowserTest::RunJavascriptUsingHandler(
-    const std::string& function_name, bool is_test) {
+    const std::string& function_name,
+    const ConstValueVector& function_arguments,
+    bool is_test) {
   std::string content;
   BuildJavascriptLibraries(&content);
 
   if (!function_name.empty()) {
-    std::string called_function = is_test ? "runTest(" + function_name + ");" :
-                                            function_name + "()";
-    content.append(called_function);
+    string16 called_function;
+    if (is_test) {
+      called_function = BuildRunTestJSCall(function_name, function_arguments);
+    } else {
+      called_function = WebUI::GetJavascriptCall(function_name,
+                                                 function_arguments);
+    }
+    content.append(UTF16ToUTF8(called_function));
   }
   SetupHandlers();
   logging::SetLogMessageHandler(&LogHandler);
diff --git a/content/browser/webui/web_ui_browsertest.h b/content/browser/webui/web_ui_browsertest.h
index bc1f313..5569cdc 100644
--- a/content/browser/webui/web_ui_browsertest.h
+++ b/content/browser/webui/web_ui_browsertest.h
@@ -12,6 +12,7 @@
 #include "chrome/test/in_process_browser_test.h"
 #include "content/browser/webui/web_ui_test_handler.h"
 
+class Value;
 class WebUIMessageHandler;
 
 // The runner of WebUI javascript based tests.
@@ -22,6 +23,7 @@ class WebUIMessageHandler;
 // and the lone test within this class.
 class WebUIBrowserTest : public InProcessBrowserTest {
  public:
+  typedef std::vector<const Value*> ConstValueVector;
   virtual ~WebUIBrowserTest();
 
   // Add a custom helper JS library for your test.
@@ -30,9 +32,23 @@ class WebUIBrowserTest : public InProcessBrowserTest {
   // Runs a javascript function in the context of all libraries.
   // Note that calls to functions in test_api.js are not supported.
   bool RunJavascriptFunction(const std::string& function_name);
+  bool RunJavascriptFunction(const std::string& function_name,
+                             const Value& arg);
+  bool RunJavascriptFunction(const std::string& function_name,
+                             const Value& arg1,
+                             const Value& arg2);
+  bool RunJavascriptFunction(const std::string& function_name,
+                             const ConstValueVector& function_arguments);
 
   // Runs a test that may include calls to functions in test_api.js.
   bool RunJavascriptTest(const std::string& test_name);
+  bool RunJavascriptTest(const std::string& test_name,
+                         const Value& arg);
+  bool RunJavascriptTest(const std::string& test_name,
+                         const Value& arg1,
+                         const Value& arg2);
+  bool RunJavascriptTest(const std::string& test_name,
+                         const ConstValueVector& test_arguments);
 
  protected:
   WebUIBrowserTest();
@@ -47,9 +63,16 @@ class WebUIBrowserTest : public InProcessBrowserTest {
   // Builds a string containing all added javascript libraries.
   void BuildJavascriptLibraries(std::string* content);
 
+  // Builds a string with a call to the runTest JS function, passing the
+  // given test and its arguments.
+  string16 BuildRunTestJSCall(const std::string& test_name,
+                              const WebUIBrowserTest::ConstValueVector& args);
+
   // Calls the specified function with all libraries available. If |is_test|
   // is true, the framework listens for pass fail messages from javascript.
+  // The provided arguments vector is passed to |function_name|.
   bool RunJavascriptUsingHandler(const std::string& function_name,
+                                 const ConstValueVector& function_arguments,
                                  bool is_test);
 
   // Attaches mock and test handlers.