Allow multiple logging::LogMessage{Handler,Listener}s

chrome/browser/media/webrtc_browsertest_base.cc

 // Copyright 2013 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/media/webrtc_browsertest_base.h"
 
 #include <stddef.h>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
@@ skipping 45 matching lines @@
    "{audio: true, video: {mandatory: {minWidth: 1280, maxWidth: 1280, "
    " minHeight: 720, maxHeight: 720}}}";
 const char WebRtcTestBase::kUseDefaultCertKeygen[] = "null";
 const char WebRtcTestBase::kUseDefaultVideoCodec[] = "";
 
 namespace {
 
 base::LazyInstance<bool> hit_javascript_errors_ =
       LAZY_INSTANCE_INITIALIZER;
 
-// Intercepts all log messages. We always attach this handler but only look at
-// the results if the test requests so. Note that this will only work if the
-// WebrtcTestBase-inheriting test cases do not run in parallel (if they did they
-// would race to look at the log, which is global to all tests).
-bool JavascriptErrorDetectingLogHandler(int severity,
-                                        const char* file,
-                                        int line,
-                                        size_t message_start,
-                                        const std::string& str) {
-  if (file == NULL || std::string("CONSOLE") != file)
-    return false;
-
-  bool contains_uncaught = str.find("\"Uncaught ") != std::string::npos;
-  if (severity == logging::LOG_ERROR ||
-      (severity == logging::LOG_INFO && contains_uncaught)) {
-    hit_javascript_errors_.Get() = true;
-  }
-
-  return false;
-}
-
 // PermissionRequestObserver ---------------------------------------------------
 
 // Used to observe the creation of permission prompt without responding.
 class PermissionRequestObserver : public PermissionRequestManager::Observer {
  public:
   explicit PermissionRequestObserver(content::WebContents* web_contents)
       : request_manager_(
             PermissionRequestManager::FromWebContents(web_contents)),
         request_shown_(false),
         message_loop_runner_(new content::MessageLoopRunner) {
@@ skipping 18 matching lines @@
 
   PermissionRequestManager* request_manager_;
   bool request_shown_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(PermissionRequestObserver);
 };
 
 }  // namespace
 
+// Intercepts all log messages. We always attach this listener but only look at
+// the results if the test requests so.
+void JavascriptErrorDetectingListener::OnMessage(int severity,
+                                                 const char* file,
+                                                 int line,
+                                                 size_t message_start,
+                                                 const std::string& str) {
+  if (file == NULL || std::string("CONSOLE") != file)
+    return;
+
+  bool contains_uncaught = str.find("\"Uncaught ") != std::string::npos;
+  if (severity == logging::LOG_ERROR ||
+      (severity == logging::LOG_INFO && contains_uncaught)) {
+    hit_javascript_errors_.Get() = true;
+  }
+}
+
 WebRtcTestBase::WebRtcTestBase(): detect_errors_in_javascript_(false) {
-  // The handler gets set for each test method, but that's fine since this
-  // set operation is idempotent.
-  logging::SetLogMessageHandler(&JavascriptErrorDetectingLogHandler);
   hit_javascript_errors_.Get() = false;
 
   EnablePixelOutput();
 }
 
 WebRtcTestBase::~WebRtcTestBase() {
   if (detect_errors_in_javascript_) {
     EXPECT_FALSE(hit_javascript_errors_.Get())
         << "Encountered javascript errors during test execution (Search "
         << "for Uncaught or ERROR:CONSOLE in the test output).";
@@ skipping 334 matching lines @@
 void WebRtcTestBase::SetDefaultVideoCodec(
     content::WebContents* tab,
     const std::string& video_codec) const {
   EXPECT_EQ("ok-forced",
             ExecuteJavascript("forceVideoCodec('" + video_codec + "')", tab));
 }
 
 void WebRtcTestBase::EnableOpusDtx(content::WebContents* tab) const {
   EXPECT_EQ("ok-forced", ExecuteJavascript("forceOpusDtx()", tab));
 }