[Mac] Log CHECK() file, line and message into breakpad.

chrome/app/breakpad_mac.mm

 // 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.
 
 #import "chrome/app/breakpad_mac.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 #import <Foundation/Foundation.h>
 
+#include "base/auto_reset.h"
 #include "base/base_switches.h"
 #import "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #import "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #import "base/mac/scoped_nsautorelease_pool.h"
 #include "base/path_service.h"
@@ skipping 23 matching lines @@
 }
 
 void ClearCrashKeyValue(NSString* key) {
   if (gBreakpadRef == NULL) {
     return;
   }
 
   BreakpadRemoveUploadParameter(gBreakpadRef, key);
 }
 
+bool FatalMessageHandler(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;
+
+  // 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;
+
+  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;
+}
+
 }  // namespace
 
 bool IsCrashReporterEnabled() {
   return gBreakpadRef != NULL;
 }
 
 // Only called for a branded build of Chrome.app.
 void InitCrashReporter() {
   DCHECK(!gBreakpadRef);
   base::mac::ScopedNSAutoreleasePool autorelease_pool;
@@ skipping 106 matching lines @@
   // Enable child process crashes to include the page URL.
   // TODO: Should this only be done for certain process types?
   base::mac::SetCrashKeyFunctions(SetCrashKeyValue,
                                   ClearCrashKeyValue);
 
   if (!is_browser) {
     // Get the guid from the command line switch.
     std::string guid =
         command_line->GetSwitchValueASCII(switches::kEnableCrashReporter);
     child_process_logging::SetClientId(guid);
-   }
+  }
+
+  logging::SetLogMessageHandler(&FatalMessageHandler);
 }
 
 void InitCrashProcessInfo() {
   if (gBreakpadRef == NULL) {
     return;
   }
 
   // Determine the process type.
   NSString* process_type = @"browser";
   std::string process_type_switch =
       CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kProcessType);
   if (!process_type_switch.empty()) {
     process_type = base::SysUTF8ToNSString(process_type_switch);
   }
 
   // Store process type in crash dump.
   SetCrashKeyValue(@"ptype", process_type);
 }