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 46 matching lines @@
    " 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) {
+// the results if the test requests so.
+void JavascriptErrorDetectingLogListener(int severity,
+                                         const char* file,
+                                         int line,
+                                         size_t message_start,
+                                         const std::string& str) {
   if (file == NULL || std::string("CONSOLE") != file)
-    return false;
+    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;
   }
-
-  return false;
 }
 
 // PermissionRequestObserver ---------------------------------------------------
 
 // Used to observe the creation of permission prompt without responding.
 class PermissionRequestObserver : public PermissionBubbleManager::Observer {
  public:
   explicit PermissionRequestObserver(content::WebContents* web_contents)
       : bubble_manager_(PermissionBubbleManager::FromWebContents(web_contents)),
         request_shown_(false),
@@ skipping 19 matching lines @@
 
   PermissionBubbleManager* bubble_manager_;
   bool request_shown_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(PermissionRequestObserver);
 };
 
 }  // namespace
 
-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);
+WebRtcTestBase::WebRtcTestBase()
+    : log_listener_(JavascriptErrorDetectingLogListener),
+      detect_errors_in_javascript_(false) {
   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 339 matching lines @@
 }
 
 void WebRtcTestBase::GenerateAndCloneCertificate(
     content::WebContents* tab, const std::string& keygen_algorithm) const {
   std::string javascript = base::StringPrintf(
       "generateAndCloneCertificate(%s)", keygen_algorithm.c_str());
   std::string response = ExecuteJavascript(javascript, tab);
   EXPECT_EQ("ok-generated-and-cloned", response) << "Failed to generate and "
       "clone certificate: " << response;
 }