Move console error detection in browser tests to higher level

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 <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 29 matching lines @@
 
 #if defined(ENABLE_PRINT_PREVIEW)
 #include "chrome/browser/printing/print_preview_dialog_controller.h"
 #endif
 
 using content::RenderViewHost;
 using content::WebContents;
 using content::WebUIController;
 using content::WebUIMessageHandler;
 
-namespace {
-
-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 &&
-      std::string("CONSOLE") == file) {
-    error_messages_.Get().push_back(str);
-  }
-
-  return false;
-}
-
 class WebUIJsInjectionReadyObserver : public content::WebContentsObserver {
  public:
   WebUIJsInjectionReadyObserver(content::WebContents* web_contents,
                                 WebUIBrowserTest* browser_test,
                                 const std::string& preload_test_fixture,
                                 const std::string& preload_test_name)
       : content::WebContentsObserver(web_contents),
         browser_test_(browser_test),
         preload_test_fixture_(preload_test_fixture),
         preload_test_name_(preload_test_name) {}
 
   void RenderViewCreated(content::RenderViewHost* rvh) override {
     browser_test_->PreLoadJavascriptLibraries(
         preload_test_fixture_, preload_test_name_, rvh);
   }
 
  private:
   WebUIBrowserTest* browser_test_;
   std::string preload_test_fixture_;
   std::string preload_test_name_;
 };
 
-}  // namespace
-
 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) {
@@ skipping 262 matching lines @@
 };
 
 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());
   test_factory_->AddFactoryOverride(content::kChromeUIResourcesHost,
                                     mock_provider_.Pointer());
 }
 
 void WebUIBrowserTest::TearDownOnMainThread() {
-  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();
+
+  JavaScriptBrowserTest::TearDownOnMainThread();
 }
 
 void WebUIBrowserTest::SetWebUIInstance(content::WebUI* web_ui) {
   override_selected_web_ui_ = web_ui;
 }
 
 WebUIMessageHandler* WebUIBrowserTest::GetMockMessageHandler() {
   return NULL;
 }
 
@@ skipping 36 matching lines @@
   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) {
+  if (has_console_errors()) {
     LOG(ERROR) << "Encountered javascript console error(s)";
     result = false;
-    error_messages_.Get().clear();
+    set_has_console_errors(false);
   }
+
   return result;
 }
 
 void WebUIBrowserTest::SetupHandlers() {
   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);
 }