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

ios/chrome/browser/crash_report/breakpad_helper.mm

 // Copyright 2015 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 "ios/chrome/browser/crash_report/breakpad_helper.h"
 
 #import <Foundation/Foundation.h>
 #include <stddef.h>
 
 #include "base/auto_reset.h"
@@ skipping 64 matching lines @@
                           const base::StringPiece& value) {
   AddReportParameter(base::SysUTF8ToNSString(key.as_string()),
                      base::SysUTF8ToNSString(value.as_string()), true);
 }
 
 // Callback for base::debug::SetCrashKeyReportingFunctions
 void ClearCrashKeyValueImpl(const base::StringPiece& key) {
   RemoveReportParameter(base::SysUTF8ToNSString(key.as_string()));
 }
 
-// Callback for logging::SetLogMessageHandler
-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];
   AddReportParameter(fatal_key, fatal_value, true);
 
   // Rather than including the code to force the crash here, allow the
   // caller to do it.
-  return false;
 }
 
 // Caches the uploading flag in NSUserDefaults, so that we can access the value
 // in safe mode.
 void CacheUploadingEnabled(bool uploading_enabled) {
   NSUserDefaults* user_defaults = [NSUserDefaults standardUserDefaults];
   [user_defaults setBool:uploading_enabled ? YES : NO
                   forKey:kCrashReportsUploadingEnabledKey];
 }
 
 }  // namespace
 
 void Start(const std::string& channel_name) {
   DCHECK(!g_crash_reporter_enabled);
   [[BreakpadController sharedInstance] start:YES];
   base::debug::SetCrashKeyReportingFunctions(&SetCrashKeyValueImpl,
                                              &ClearCrashKeyValueImpl);
-  logging::SetLogMessageHandler(&FatalMessageHandler);
+  // Intentionally leak the listener.
+  auto* listener = new FatalMessageListener();
+  CHECK(listener);
+
   g_crash_reporter_enabled = true;
   // Register channel information.
   if (channel_name.length()) {
     AddReportParameter(@"channel", base::SysUTF8ToNSString(channel_name), true);
   }
   // Notifying the PathService on the location of the crashes so that crashes
   // can be displayed to the user on the about:crashes page.
   NSArray* cachesDirectories = NSSearchPathForDirectoriesInDomains(
       NSCachesDirectory, NSUserDomainMask, YES);
   NSString* cachePath = [cachesDirectories objectAtIndex:0];
@@ skipping 214 matching lines @@
 void RestoreDefaultConfiguration() {
   if (!g_crash_reporter_enabled)
     return;
   [[BreakpadController sharedInstance] stop];
   [[BreakpadController sharedInstance] resetConfiguration];
   [[BreakpadController sharedInstance] start:NO];
   [[BreakpadController sharedInstance] setUploadingEnabled:NO];
 }
 
 }  // namespace breakpad_helper