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

chrome/installer/util/installation_validator_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 
 #include <map>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 212 matching lines @@
   app_cmd.set_is_auto_run_on_os_upgrade(true);
   commands_.Set(installer::kCmdOnOsUpgrade, app_cmd);
 }
 
 }  // namespace
 
 // Fixture for testing the InstallationValidator.  Errors logged by the
 // validator are sent to an optional mock recipient (see
 // set_validation_error_recipient) upon which expectations can be placed.
 class InstallationValidatorTest
-    : public testing::TestWithParam<InstallationValidator::InstallationType> {
+    : public testing::TestWithParam<InstallationValidator::InstallationType>,
+      logging::LogMessageHandler {
  public:
 
   // These shouldn't need to be public, but there seems to be some interaction
   // with parameterized tests that requires it.
   static void SetUpTestCase();
   static void TearDownTestCase();
 
   // Returns the multi channel modifiers for a given installation type.
   static int GetChannelModifiers(InstallationValidator::InstallationType type);
 
  protected:
   typedef std::map<InstallationValidator::InstallationType, int>
       InstallationTypeToModifiers;
 
   class ValidationErrorRecipient {
    public:
     virtual ~ValidationErrorRecipient() { }
     virtual void ReceiveValidationError(const char* file,
                                         int line,
                                         const char* message) = 0;
   };
   class MockValidationErrorRecipient : public ValidationErrorRecipient {
    public:
     MOCK_METHOD3(ReceiveValidationError, void(const char* file,
                                               int line,
                                               const char* message));
   };
 
  protected:
-  static bool HandleLogMessage(int severity,
-                               const char* file,
-                               int line,
-                               size_t message_start,
-                               const std::string& str);
+  // logging::LogMessageHandler
+  bool OnMessage(int severity,
+                 const char* file,
+                 int line,
+                 size_t message_start,
+                 const std::string& str) override;
   static void set_validation_error_recipient(
       ValidationErrorRecipient* recipient);
   static void MakeProductState(
       BrowserDistribution::Type prod_type,
       InstallationValidator::InstallationType inst_type,
       Level install_level,
       Channel channel,
       Vehicle vehicle,
       FakeProductState* state);
   static void MakeMachineState(
       InstallationValidator::InstallationType inst_type,
       Level install_level,
       Channel channel,
       Vehicle vehicle,
       FakeInstallationState* state);
   void TearDown() override;
 
-  static logging::LogMessageHandlerFunction old_log_message_handler_;
   static ValidationErrorRecipient* validation_error_recipient_;
   static InstallationTypeToModifiers* type_to_modifiers_;
 };
 
 // static
-logging::LogMessageHandlerFunction
-    InstallationValidatorTest::old_log_message_handler_ = NULL;
-
-// static
 InstallationValidatorTest::ValidationErrorRecipient*
     InstallationValidatorTest::validation_error_recipient_ = NULL;
 
 // static
 InstallationValidatorTest::InstallationTypeToModifiers*
     InstallationValidatorTest::type_to_modifiers_ = NULL;
 
 // static
 int InstallationValidatorTest::GetChannelModifiers(
     InstallationValidator::InstallationType type) {
   DCHECK(type_to_modifiers_);
   DCHECK(type_to_modifiers_->find(type) != type_to_modifiers_->end());
 
   return (*type_to_modifiers_)[type];
 }
 
 // static
 void InstallationValidatorTest::SetUpTestCase() {
   DCHECK(type_to_modifiers_ == NULL);
-  old_log_message_handler_ = logging::GetLogMessageHandler();
-  logging::SetLogMessageHandler(&HandleLogMessage);
 
   type_to_modifiers_ = new InstallationTypeToModifiers();
   InstallationTypeToModifiers& ttm = *type_to_modifiers_;
   ttm[InstallationValidator::NO_PRODUCTS] = 0;
   ttm[InstallationValidator::CHROME_SINGLE] = 0;
   ttm[InstallationValidator::CHROME_MULTI] = CM_MULTI | CM_CHROME;
   ttm[InstallationValidator::CHROME_FRAME_SINGLE] = 0;
   ttm[InstallationValidator::CHROME_FRAME_SINGLE_CHROME_SINGLE] = 0;
   ttm[InstallationValidator::CHROME_FRAME_SINGLE_CHROME_MULTI] =
       CM_MULTI | CM_CHROME;
   ttm[InstallationValidator::CHROME_FRAME_MULTI] = CM_MULTI | CM_CHROME_FRAME;
   ttm[InstallationValidator::CHROME_FRAME_MULTI_CHROME_MULTI] =
       CM_MULTI | CM_CHROME_FRAME | CM_CHROME;
 }
 
 // static
 void InstallationValidatorTest::TearDownTestCase() {
-  logging::SetLogMessageHandler(old_log_message_handler_);
-  old_log_message_handler_ = NULL;
-
   delete type_to_modifiers_;
   type_to_modifiers_ = NULL;
 }
 
-// static
-bool InstallationValidatorTest::HandleLogMessage(int severity,
-                                                 const char* file,
-                                                 int line,
-                                                 size_t message_start,
-                                                 const std::string& str) {
+bool InstallationValidatorTest::OnMessage(int severity,
+                                          const char* file,
+                                          int line,
+                                          size_t message_start,
+                                          const std::string& str) {
   // All validation failures result in LOG(ERROR)
   if (severity == logging::LOG_ERROR && !str.empty()) {
     // Remove the trailing newline, if present.
     size_t message_length = str.size() - message_start;
     if (*str.rbegin() == '\n')
       --message_length;
     if (validation_error_recipient_ != NULL) {
       validation_error_recipient_->ReceiveValidationError(
           file, line, str.substr(message_start, message_length).c_str());
     } else {
       // Fail the test if an error wasn't handled.
       ADD_FAILURE_AT(file, line)
           << base::StringPiece(str.c_str() + message_start, message_length);
     }
     return true;
   }
 
-  if (old_log_message_handler_ != NULL)
-    return (old_log_message_handler_)(severity, file, line, message_start, str);
-
   return false;
 }
 
 // static
 void InstallationValidatorTest::set_validation_error_recipient(
     ValidationErrorRecipient* recipient) {
   validation_error_recipient_ = recipient;
 }
 
 // static
@@ skipping 106 matching lines @@
     AllValidInstallations,
     InstallationValidatorTest,
     Values(InstallationValidator::NO_PRODUCTS,
            InstallationValidator::CHROME_SINGLE,
            InstallationValidator::CHROME_MULTI,
            InstallationValidator::CHROME_FRAME_SINGLE,
            InstallationValidator::CHROME_FRAME_SINGLE_CHROME_SINGLE,
            InstallationValidator::CHROME_FRAME_SINGLE_CHROME_MULTI,
            InstallationValidator::CHROME_FRAME_MULTI,
            InstallationValidator::CHROME_FRAME_MULTI_CHROME_MULTI));