Port aria_util_test.js to run as a WebUI test.

chrome/test/base/web_ui_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/test/base/web_ui_browsertest.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 93 matching lines @@
 };
 
 }  // namespace
 
 WebUIBrowserTest::~WebUIBrowserTest() {}
 
 void WebUIBrowserTest::AddLibrary(const base::FilePath& library_path) {
   user_libraries_.push_back(library_path);
 }
 
-// Add a helper JS library to the given WebUIBrowserTest from a path relative to
-// base::DIR_SOURCE_ROOT.
-// static
-void AddLibraryFromSourceRoot(WebUIBrowserTest* browser_test,
-                              const base::FilePath& path) {
-  base::FilePath filePath;
-  ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &filePath));
-  filePath = filePath.Append(path);
-  browser_test->AddLibrary(filePath);
-}
-
 bool WebUIBrowserTest::RunJavascriptFunction(const std::string& function_name) {
   ConstValueVector empty_args;
   return RunJavascriptFunction(function_name, empty_args);
 }
 
 bool WebUIBrowserTest::RunJavascriptFunction(const std::string& function_name,
                                              base::Value* arg) {
   ConstValueVector args;
   args.push_back(arg);
   return RunJavascriptFunction(function_name, args);
@@ skipping 270 matching lines @@
   content::WebUIControllerFactory::UnregisterFactoryForTesting(
       ChromeWebUIControllerFactory::GetInstance());
 
   test_factory_.reset(new TestChromeWebUIControllerFactory);
 
   content::WebUIControllerFactory::RegisterFactory(test_factory_.get());
 
   test_factory_->AddFactoryOverride(
       GURL(kDummyURL).host(), mock_provider_.Pointer());
 
-  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_directory_));
-  test_data_directory_ = test_data_directory_.Append(kWebUITestFolder);
+  base::FilePath test_data_directory;
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_directory));
+  test_data_directory = test_data_directory.Append(kWebUITestFolder);
+  library_search_paths_.push_back(test_data_directory);
+
+  base::FilePath gen_test_data_directory;
   ASSERT_TRUE(PathService::Get(chrome::DIR_GEN_TEST_DATA,
-                               &gen_test_data_directory_));
+                               &gen_test_data_directory));
+  library_search_paths_.push_back(gen_test_data_directory);
+
+  base::FilePath source_root_directory;
+  ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &source_root_directory));
+  library_search_paths_.push_back(source_root_directory);
 
   // TODO(dtseng): should this be part of every BrowserTest or just WebUI test.
   base::FilePath resources_pack_path;
   PathService::Get(chrome::FILE_RESOURCES_PACK, &resources_pack_path);
   ResourceBundle::GetSharedInstance().AddDataPackFromPath(
       resources_pack_path, ui::SCALE_FACTOR_NONE);
 
-  AddLibraryFromSourceRoot(this, base::FilePath(kA11yAuditLibraryJSPath));
-  AddLibraryFromSourceRoot(this, base::FilePath(kMockJSPath));
+  AddLibrary(base::FilePath(kA11yAuditLibraryJSPath));
+  AddLibrary(base::FilePath(kMockJSPath));
   AddLibrary(base::FilePath(kWebUILibraryJS));
 }
 
 void WebUIBrowserTest::CleanUpOnMainThread() {
   logging::SetLogMessageHandler(NULL);
 
   test_factory_->RemoveFactoryOverride(GURL(kDummyURL).host());
   content::WebUIControllerFactory::UnregisterFactoryForTesting(
       test_factory_.get());
 
@@ skipping 15 matching lines @@
 
 GURL WebUIBrowserTest::WebUITestDataPathToURL(
     const base::FilePath::StringType& path) {
   base::FilePath dir_test_data;
   EXPECT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &dir_test_data));
   base::FilePath test_path(dir_test_data.Append(kWebUITestFolder).Append(path));
   EXPECT_TRUE(base::PathExists(test_path));
   return net::FilePathToFileURL(test_path);
 }
 
-void WebUIBrowserTest::BuildJavascriptLibraries(base::string16* content) {
-  ASSERT_TRUE(content != NULL);
-  std::string utf8_content;
+void WebUIBrowserTest::BuildJavascriptLibraries(
+    std::vector<base::string16>* libraries) {
+  ASSERT_TRUE(libraries != NULL);
   std::vector<base::FilePath>::iterator user_libraries_iterator;
   for (user_libraries_iterator = user_libraries_.begin();
        user_libraries_iterator != user_libraries_.end();
        ++user_libraries_iterator) {
     std::string library_content;
     if (user_libraries_iterator->IsAbsolute()) {
       ASSERT_TRUE(base::ReadFileToString(*user_libraries_iterator,
                                               &library_content))
           << user_libraries_iterator->value();
     } else {
-      bool ok = base::ReadFileToString(
-          gen_test_data_directory_.Append(*user_libraries_iterator),
-          &library_content);
-      if (!ok) {
+      bool ok = false;
+      std::vector<base::FilePath>::iterator library_search_path_iterator;
+      for (library_search_path_iterator = library_search_paths_.begin();
+           library_search_path_iterator != library_search_paths_.end();
+           ++library_search_path_iterator) {
         ok = base::ReadFileToString(
-            test_data_directory_.Append(*user_libraries_iterator),
+            base::MakeAbsoluteFilePath(
+                library_search_path_iterator->Append(*user_libraries_iterator)),
             &library_content);
+        if (ok)
+          break;
       }
-      ASSERT_TRUE(ok) << user_libraries_iterator->value();
+      ASSERT_TRUE(ok) << "User library not found: "
+                      << user_libraries_iterator->value();
     }
-    utf8_content.append(library_content);
-    utf8_content.append(";\n");
+    library_content.append(";\n");
+
+    // This magic code puts filenames in stack traces.
+    library_content.append("//# sourceURL=");
+    library_content.append(user_libraries_iterator->BaseName().value());
+    library_content.append("\n");
+    libraries->push_back(base::UTF8ToUTF16(library_content));
   }
-  content->append(base::UTF8ToUTF16(utf8_content));
 }
 
 base::string16 WebUIBrowserTest::BuildRunTestJSCall(
     bool is_async,
     const std::string& function_name,
     const WebUIBrowserTest::ConstValueVector& test_func_args) {
   ConstValueVector arguments;
   base::FundamentalValue* is_async_arg = new base::FundamentalValue(is_async);
   arguments.push_back(is_async_arg);
   base::StringValue* function_name_arg = new base::StringValue(function_name);
@@ skipping 10 matching lines @@
                                            arguments.get());
 }
 
 bool WebUIBrowserTest::RunJavascriptUsingHandler(
     const std::string& function_name,
     const ConstValueVector& function_arguments,
     bool is_test,
     bool is_async,
     RenderViewHost* preload_host) {
 
+  std::vector<base::string16> libraries;
+  if (!libraries_preloaded_)
+    BuildJavascriptLibraries(&libraries);
   base::string16 content;
-  if (!libraries_preloaded_)
-    BuildJavascriptLibraries(&content);
 
   if (!function_name.empty()) {
     base::string16 called_function;
     if (is_test) {
       called_function =
           BuildRunTestJSCall(is_async, function_name, function_arguments);
     } else {
       called_function =
           content::WebUI::GetJavascriptCall(function_name,
                                             function_arguments.get());
     }
     content.append(called_function);
   }
 
   if (!preload_host)
     SetupHandlers();
 
   bool result = true;
 
+  for (size_t i = 0; i < libraries.size(); ++i)
+    test_handler_->PreloadJavaScript(libraries[i], preload_host);
+
   if (is_test)
     result = test_handler_->RunJavaScriptTestWithResult(content);
   else if (preload_host)
     test_handler_->PreloadJavaScript(content, preload_host);
   else
     test_handler_->RunJavaScript(content);
 
   if (error_messages_.Get().size() > 0) {
     LOG(ERROR) << "Encountered javascript console error(s)";
     result = false;
@@ skipping 236 matching lines @@
 // testDone directly and expect pass result.
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestTestDoneEarlyPassesAsync) {
   ASSERT_TRUE(RunJavascriptAsyncTest("testDone"));
 }
 
 // Test that calling testDone during RunJavascriptTest still completes when
 // waiting for async result.
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestTestDoneEarlyPasses) {
   ASSERT_TRUE(RunJavascriptTest("testDone"));
 }