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

chrome/installer/util/installation_validation_helper.cc

 // Copyright (c) 2011 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.
 
 // This file declares helper functions for use in tests that expect a valid
 // installation, possibly of a specific type.  Validation violations result in
 // test failures.
 
 #include "chrome/installer/util/installation_validation_helper.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
 #include "chrome/installer/util/installation_state.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace installer {
 
 namespace {
 
 // A helper class that installs a log message handler to add a test failure for
 // each ERROR message.  Only one instance of this class may be live at a time.
-class FailureLogHelper {
+class FailureLogHelper : logging::LogMessageHandler {
  public:
   FailureLogHelper();
-  ~FailureLogHelper();
+  ~FailureLogHelper() override;
+
+  bool OnMessage(int severity,
+                 const char* file,
+                 int line,
+                 size_t message_start,
+                 const std::string& str) override;
 
  private:
-  static bool AddFailureForLogMessage(int severity,
-                                      const char* file,
-                                      int line,
-                                      size_t message_start,
-                                      const std::string& str);
-
   static const logging::LogSeverity kViolationSeverity_;
-  static logging::LogMessageHandlerFunction old_message_handler_;
   static int old_min_log_level_;
 };
 
 // InstallationValidator logs all violations at ERROR level.
 // static
 const logging::LogSeverity
     FailureLogHelper::kViolationSeverity_ = logging::LOG_ERROR;
 
 // static
-logging::LogMessageHandlerFunction
-    FailureLogHelper::old_message_handler_ = NULL;
-
-// static
 int FailureLogHelper::old_min_log_level_ =
     FailureLogHelper::kViolationSeverity_;
 
 FailureLogHelper::FailureLogHelper() {
-  LOG_ASSERT(old_message_handler_ == NULL);
-
   // The validator logs at ERROR level.  Ensure that it generates messages so we
   // can transform them into test failures.
   old_min_log_level_ = logging::GetMinLogLevel();
   if (old_min_log_level_ > kViolationSeverity_)
     logging::SetMinLogLevel(kViolationSeverity_);
-
-  old_message_handler_ = logging::GetLogMessageHandler();
-  logging::SetLogMessageHandler(&AddFailureForLogMessage);
 }
 
 FailureLogHelper::~FailureLogHelper() {
-  logging::SetLogMessageHandler(old_message_handler_);
-  old_message_handler_ = NULL;
-
   if (old_min_log_level_ > kViolationSeverity_)
     logging::SetMinLogLevel(old_min_log_level_);
 }
 
-// A logging::LogMessageHandlerFunction that adds a non-fatal test failure
+// A logging::LogMessageHandler that adds a non-fatal test failure
 // (i.e., similar to an unmet EXPECT_FOO) for each non-empty message logged at
 // the severity of validation violations.  All other messages are sent through
 // the default logging pipeline.
 // static
-bool FailureLogHelper::AddFailureForLogMessage(int severity,
-                                               const char* file,
-                                               int line,
-                                               size_t message_start,
-                                               const std::string& str) {
+bool FailureLogHelper::OnMessage(int severity,
+                                 const char* file,
+                                 int line,
+                                 size_t message_start,
+                                 const std::string& str) {
   if (severity == kViolationSeverity_ && !str.empty()) {
     // Remove the trailing newline, if present.
     size_t message_length = str.size() - message_start;
     if (*str.rbegin() == '\n')
       --message_length;
     ADD_FAILURE_AT(file, line)
         << base::StringPiece(str.c_str() + message_start, message_length);
     return true;
   }
 
-  if (old_message_handler_ != NULL)
-    return (old_message_handler_)(severity, file, line, message_start, str);
-
   return false;
 }
 
 }  // namespace
 
 InstallationValidator::InstallationType ExpectValidInstallation(
     bool system_level) {
   FailureLogHelper log_helper;
   InstallationValidator::InstallationType found_type =
       InstallationValidator::NO_PRODUCTS;
@@ skipping 21 matching lines @@
 }
 
 void ExpectInstallationOfTypeForState(
     const InstallationState& machine_state,
     bool system_level,
     InstallationValidator::InstallationType type) {
   EXPECT_EQ(type, ExpectValidInstallationForState(machine_state, system_level));
 }
 
 }  // namespace installer