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

components/crash/content/app/breakpad_mac.mm

 // 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.
 
 #import "components/crash/content/app/breakpad_mac.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 #import <Foundation/Foundation.h>
 #include <stddef.h>
 #include <string.h>
@@ skipping 55 matching lines @@
                      base::SysUTF8ToNSString(value.as_string()));
   }
 }
 
 void ClearCrashKeyValueImpl(const base::StringPiece& key) {
   @autoreleasepool {
     ClearCrashKeyValue(base::SysUTF8ToNSString(key.as_string()));
   }
 }
 
-bool FatalMessageHandler(int severity, const char* file, int line,
-                         size_t message_start, const std::string& str) {
+class FatalMessageListener : logging::LogMessageListener {
+  void OnMessage(int severity,
+                 const char* file,
+                 int line,
+                 size_t message_start,
+                 const std::string& str) override;
+};
+
+void FatalMessageListener::OnMessage(int severity,
+                                     const char* file,
+                                     int line,
+                                     size_t message_start,
+                                     const std::string& str) {
   // Do not handle non-FATAL.
   if (severity != logging::LOG_FATAL)
-    return false;
+    return;
 
   // In case of OOM condition, this code could be reentered when
   // constructing and storing the key.  Using a static is not
   // thread-safe, but if multiple threads are in the process of a
   // fatal crash at the same time, this should work.
   static bool guarded = false;
   if (guarded)
-    return false;
+    return;
 
   base::AutoReset<bool> guard(&guarded, true);
 
   // Only log last path component.  This matches logging.cc.
   if (file) {
     const char* slash = strrchr(file, '/');
     if (slash)
       file = slash + 1;
   }
 
   NSString* fatal_key = @"LOG_FATAL";
   NSString* fatal_value =
       [NSString stringWithFormat:@"%s:%d: %s",
                                  file, line, str.c_str() + message_start];
   SetCrashKeyValue(fatal_key, fatal_value);
 
   // Rather than including the code to force the crash here, allow the
   // caller to do it.
-  return false;
+  return;
 }
 
 // BreakpadGenerateAndSendReport() does not report the current
 // thread.  This class can be used to spin up a thread to run it.
 class DumpHelper : public base::PlatformThread::Delegate {
  public:
   static void DumpWithoutCrashing() {
     DumpHelper dumper;
     base::PlatformThreadHandle handle;
     if (base::PlatformThread::Create(0, &dumper, &handle)) {
@@ skipping 139 matching lines @@
   base::debug::SetCrashKeyReportingFunctions(&SetCrashKeyValueImpl,
                                              &ClearCrashKeyValueImpl);
   GetCrashReporterClient()->RegisterCrashKeys();
 
   // Set Breakpad metadata values.  These values are added to Info.plist during
   // the branded Google Chrome.app build.
   SetCrashKeyValue(@"ver", [info_dictionary objectForKey:@BREAKPAD_VERSION]);
   SetCrashKeyValue(@"prod", [info_dictionary objectForKey:@BREAKPAD_PRODUCT]);
   SetCrashKeyValue(@"plat", @"OS X");
 
-  logging::SetLogMessageHandler(&FatalMessageHandler);
+  // Intentionally leak the listener.
+  new FatalMessageListener();
+
   base::debug::SetDumpWithoutCrashingFunction(&DumpHelper::DumpWithoutCrashing);
 
   // abort() sends SIGABRT, which breakpad does not intercept.
   // Register a signal handler to crash in a way breakpad will
   // intercept.
   struct sigaction sigact;
   memset(&sigact, 0, sizeof(sigact));
   sigact.sa_handler = SIGABRTHandler;
   CHECK(0 == sigaction(SIGABRT, &sigact, NULL));
 }
@@ skipping 11 matching lines @@
 
   // Store process type in crash dump.
   SetCrashKeyValue(@"ptype", process_type);
 
   NSString* pid_value =
       [NSString stringWithFormat:@"%d", static_cast<unsigned int>(getpid())];
   SetCrashKeyValue(@"pid", pid_value);
 }
 
 }  // namespace breakpad