Support javascript gtests in an extension background page.

chrome/test/base/web_ui_browser_test.cc

 // Copyright 2014 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_browser_test.h"
 
 #include <string>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/web_ui_test_handler.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/test_chrome_web_ui_controller_factory.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/url_data_source.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_ui_controller.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "net/base/filename_util.h"
-#include "ui/base/resource/resource_bundle.h"
 #include "ui/base/resource/resource_handle.h"
 
 #if defined(ENABLE_FULL_PRINTING)
 #include "chrome/browser/printing/print_preview_dialog_controller.h"
 #endif
 
 using content::RenderViewHost;
 using content::WebContents;
 using content::WebUIController;
 using content::WebUIMessageHandler;
 
 namespace {
 
-const base::FilePath::CharType kA11yAuditLibraryJSPath[] = FILE_PATH_LITERAL(
-    "third_party/accessibility-audit/axs_testing.js");
-const base::FilePath::CharType kMockJSPath[] =
-    FILE_PATH_LITERAL("chrome/third_party/mock4js/mock4js.js");
-const base::FilePath::CharType kWebUILibraryJS[] =
-    FILE_PATH_LITERAL("test_api.js");
-const base::FilePath::CharType kWebUITestFolder[] = FILE_PATH_LITERAL("webui");
 base::LazyInstance<std::vector<std::string> > error_messages_ =
     LAZY_INSTANCE_INITIALIZER;
 
 // Intercepts all log messages.
 bool LogHandler(int severity,
                 const char* file,
                 int line,
                 size_t message_start,
                 const std::string& str) {
-  if (severity == logging::LOG_ERROR &&
-      file &&
+  if (severity == logging::LOG_ERROR && file &&
       std::string("CONSOLE") == file) {
     error_messages_.Get().push_back(str);
   }
 
   return false;
 }
 
 class WebUIJsInjectionReadyObserver : public content::WebContentsObserver {
  public:
   WebUIJsInjectionReadyObserver(content::WebContents* web_contents,
@@ skipping 11 matching lines @@
   }
 
  private:
   WebUIBrowserTest* browser_test_;
   std::string preload_test_fixture_;
   std::string preload_test_name_;
 };
 
 }  // namespace
 
-WebUIBrowserTest::~WebUIBrowserTest() {}
-
-void WebUIBrowserTest::AddLibrary(const base::FilePath& library_path) {
-  user_libraries_.push_back(library_path);
+WebUIBrowserTest::~WebUIBrowserTest() {
 }
 
 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;
@@ skipping 108 matching lines @@
       "preloadJavascriptLibraries", args, false, false, preload_host);
   libraries_preloaded_ = true;
 }
 
 void WebUIBrowserTest::BrowsePreload(const GURL& browse_to) {
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   WebUIJsInjectionReadyObserver injection_observer(
       web_contents, this, preload_test_fixture_, preload_test_name_);
   content::TestNavigationObserver navigation_observer(web_contents);
-  chrome::NavigateParams params(browser(), GURL(browse_to),
-                                content::PAGE_TRANSITION_TYPED);
+  chrome::NavigateParams params(
+      browser(), GURL(browse_to), content::PAGE_TRANSITION_TYPED);
   params.disposition = CURRENT_TAB;
   chrome::Navigate(&params);
   navigation_observer.Wait();
 }
 
 #if defined(ENABLE_FULL_PRINTING)
 
 // This custom ContentBrowserClient is used to get notified when a WebContents
 // for the print preview dialog gets created.
 class PrintContentBrowserClient : public chrome::ChromeContentBrowserClient {
@@ skipping 10 matching lines @@
   void Wait() {
     message_loop_runner_->Run();
     content::WaitForLoadStop(preview_dialog_);
   }
 
  private:
   // ChromeContentBrowserClient implementation:
   virtual content::WebContentsViewDelegate* GetWebContentsViewDelegate(
       content::WebContents* web_contents) OVERRIDE {
     preview_dialog_ = web_contents;
-    observer_.reset(new WebUIJsInjectionReadyObserver(
-        preview_dialog_, browser_test_, preload_test_fixture_,
-        preload_test_name_));
+    observer_.reset(new WebUIJsInjectionReadyObserver(preview_dialog_,
+                                                      browser_test_,
+                                                      preload_test_fixture_,
+                                                      preload_test_name_));
     message_loop_runner_->Quit();
     return NULL;
   }
 
   WebUIBrowserTest* browser_test_;
   scoped_ptr<WebUIJsInjectionReadyObserver> observer_;
   std::string preload_test_fixture_;
   std::string preload_test_name_;
   content::WebContents* preview_dialog_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
@@ skipping 24 matching lines @@
 #else
   NOTREACHED();
 #endif
 }
 
 const char WebUIBrowserTest::kDummyURL[] = "chrome://DummyURL";
 
 WebUIBrowserTest::WebUIBrowserTest()
     : test_handler_(new WebUITestHandler()),
       libraries_preloaded_(false),
-      override_selected_web_ui_(NULL) {}
+      override_selected_web_ui_(NULL) {
+}
 
 void WebUIBrowserTest::set_preload_test_fixture(
     const std::string& preload_test_fixture) {
   preload_test_fixture_ = preload_test_fixture;
 }
 
 void WebUIBrowserTest::set_preload_test_name(
     const std::string& preload_test_name) {
   preload_test_name_ = preload_test_name;
 }
 
 namespace {
 
 // DataSource for the dummy URL.  If no data source is provided then an error
 // page is shown. While this doesn't matter for most tests, without it,
 // navigation to different anchors cannot be listened to (via the hashchange
 // event).
 class MockWebUIDataSource : public content::URLDataSource {
  public:
   MockWebUIDataSource() {}
 
  private:
   virtual ~MockWebUIDataSource() {}
 
-  virtual std::string GetSource() const OVERRIDE {
-    return "dummyurl";
-  }
+  virtual std::string GetSource() const OVERRIDE { return "dummyurl"; }
 
   virtual void StartDataRequest(
       const std::string& path,
       int render_process_id,
       int render_frame_id,
       const content::URLDataSource::GotDataCallback& callback) OVERRIDE {
     std::string dummy_html = "<html><body>Dummy</body></html>";
     scoped_refptr<base::RefCountedString> response =
         base::RefCountedString::TakeString(&dummy_html);
     callback.Run(response.get());
@@ skipping 25 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(MockWebUIProvider);
 };
 
 base::LazyInstance<MockWebUIProvider> mock_provider_ =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 void WebUIBrowserTest::SetUpOnMainThread() {
+  JavaScriptBrowserTest::SetUpOnMainThread();
+
   logging::SetLogMessageHandler(&LogHandler);
 
+  AddLibrary(base::FilePath(kA11yAuditLibraryJSPath));
+
   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());
-
-  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));
-  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);
-
-  AddLibrary(base::FilePath(kA11yAuditLibraryJSPath));
-  AddLibrary(base::FilePath(kMockJSPath));
-  AddLibrary(base::FilePath(kWebUILibraryJS));
+  test_factory_->AddFactoryOverride(GURL(kDummyURL).host(),
+                                    mock_provider_.Pointer());
 }
 
 void WebUIBrowserTest::CleanUpOnMainThread() {
   logging::SetLogMessageHandler(NULL);
 
   test_factory_->RemoveFactoryOverride(GURL(kDummyURL).host());
   content::WebUIControllerFactory::UnregisterFactoryForTesting(
       test_factory_.get());
 
   // This is needed to avoid a debug assert after the test completes, see stack
   // trace in http://crrev.com/179347
   content::WebUIControllerFactory::RegisterFactory(
       ChromeWebUIControllerFactory::GetInstance());
 
   test_factory_.reset();
 }
 
 void WebUIBrowserTest::SetWebUIInstance(content::WebUI* web_ui) {
   override_selected_web_ui_ = web_ui;
 }
 
 WebUIMessageHandler* WebUIBrowserTest::GetMockMessageHandler() {
   return NULL;
 }
 
-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(
-    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 = 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(
-            base::MakeAbsoluteFilePath(
-                library_search_path_iterator->Append(*user_libraries_iterator)),
-            &library_content);
-        if (ok)
-          break;
-      }
-      ASSERT_TRUE(ok) << "User library not found: "
-                      << user_libraries_iterator->value();
-    }
-    library_content.append(";\n");
-
-    // This magic code puts filenames in stack traces.
-    library_content.append("//# sourceURL=");
-    library_content.append(user_libraries_iterator->BaseName().AsUTF8Unsafe());
-    library_content.append("\n");
-    libraries->push_back(base::UTF8ToUTF16(library_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);
-  arguments.push_back(function_name_arg);
-  base::ListValue* baked_argument_list = new base::ListValue();
-  ConstValueVector::const_iterator arguments_iterator;
-  for (arguments_iterator = test_func_args.begin();
-       arguments_iterator != test_func_args.end();
-       ++arguments_iterator) {
-    baked_argument_list->Append((*arguments_iterator)->DeepCopy());
-  }
-  arguments.push_back(baked_argument_list);
-  return content::WebUI::GetJavascriptCall(std::string("runTest"),
-                                           arguments.get());
-}
-
 bool WebUIBrowserTest::RunJavascriptUsingHandler(
     const std::string& function_name,
     const ConstValueVector& function_arguments,
     bool is_test,
     bool is_async,
     RenderViewHost* preload_host) {
   // Get the user libraries. Preloading them individually is best, then
   // we can assign each one a filename for better stack traces. Otherwise
   // append them all to |content|.
   base::string16 content;
   std::vector<base::string16> libraries;
   if (!libraries_preloaded_) {
     BuildJavascriptLibraries(&libraries);
     if (!preload_host) {
       content = JoinString(libraries, '\n');
       libraries.clear();
     }
   }
 
   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());
+      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;
     error_messages_.Get().clear();
   }
   return result;
 }
 
 void WebUIBrowserTest::SetupHandlers() {
-  content::WebUI* web_ui_instance = override_selected_web_ui_ ?
-      override_selected_web_ui_ :
-      browser()->tab_strip_model()->GetActiveWebContents()->GetWebUI();
+  content::WebUI* web_ui_instance =
+      override_selected_web_ui_
+          ? override_selected_web_ui_
+          : browser()->tab_strip_model()->GetActiveWebContents()->GetWebUI();
   ASSERT_TRUE(web_ui_instance != NULL);
 
   test_handler_->set_web_ui(web_ui_instance);
   test_handler_->RegisterMessages();
 
   if (GetMockMessageHandler()) {
     GetMockMessageHandler()->set_web_ui(web_ui_instance);
     GetMockMessageHandler()->RegisterMessages();
   }
 }
+
+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);
+}