Change the behavior of --enable-dcheck from crashing

base/logging.cc

 // Copyright (c) 2006-2008 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 "base/logging.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 typedef HANDLE FileHandle;
 typedef HANDLE MutexHandle;
@@ skipping 28 matching lines @@
 #include "base/lock_impl.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
   
 namespace logging {
 
 bool g_enable_dcheck = false;
 
 const char* const log_severity_names[LOG_NUM_SEVERITIES] = {
-  "INFO", "WARNING", "ERROR", "FATAL" };
+  "INFO", "WARNING", "ERROR", "ERROR_REPORT", "FATAL" };
 
 int min_log_level = 0;
 LogLockingState lock_log_file = LOCK_LOG_FILE;
 
 // The default set here for logging_destination will only be used if
 // InitLogging is not called.  On Windows, use a file next to the exe;
 // on POSIX platforms, where it may not even be possible to locate the
 // executable on disk, use stderr.
 #if defined(OS_WIN)
 LoggingDestination logging_destination = LOG_ONLY_TO_FILE;
@@ skipping 22 matching lines @@
 // this file is lazily opened and the handle may be NULL
 FileHandle log_file = NULL;
 
 // what should be prepended to each message?
 bool log_process_id = false;
 bool log_thread_id = false;
 bool log_timestamp = true;
 bool log_tickcount = false;
 
 // An assert handler override specified by the client to be called instead of
+// the debug message dialog and process termination.
+LogAssertHandlerFunction log_assert_handler = NULL;
+// An report handler override specified by the client to be called instead of

[wtc, 2009/02/19 01:32:04]

Nit: add a blank line above this line.

 // the debug message dialog.
-LogAssertHandlerFunction log_assert_handler = NULL;
+LogReportHandlerFunction log_report_handler = NULL;
 
 // The lock is used if log file locking is false. It helps us avoid problems
 // with multiple threads writing to the log file at the same time.  Use
 // LockImpl directly instead of using Lock, because Lock makes logging calls.
 static LockImpl* log_lock = NULL;
 
 // When we don't use a lock, we are using a global mutex. We need to do this
 // because LockFileEx is not thread safe.
 #if defined(OS_WIN)
 MutexHandle log_mutex = NULL;
@@ skipping 180 matching lines @@
   log_process_id = enable_process_id;
   log_thread_id = enable_thread_id;
   log_timestamp = enable_timestamp;
   log_tickcount = enable_tickcount;
 }
 
 void SetLogAssertHandler(LogAssertHandlerFunction handler) {
   log_assert_handler = handler;
 }
 
+void SetLogReportHandler(LogReportHandlerFunction handler) {
+  log_report_handler = handler;
+}
+
 // Displays a message box to the user with the error message in it. For
 // Windows programs, it's possible that the message loop is messed up on
 // a fatal error, and creating a MessageBox will cause that message loop
 // to be run. Instead, we try to spawn another process that displays its
 // command line. We look for "Debug Message.exe" in the same directory as
 // the application. If it exists, we use it, otherwise, we use a regular
 // message box.
 void DisplayDebugMessage(const std::string& str) {
   if (str.empty())
     return;
@@ skipping 37 matching lines @@
     : severity_(severity) {
   Init(file, line);
 }
 
 LogMessage::LogMessage(const char* file, int line, const CheckOpString& result)
     : severity_(LOG_FATAL) {
   Init(file, line);
   stream_ << "Check failed: " << (*result.str_);
 }
 
+LogMessage::LogMessage(const char* file, int line, LogSeverity severity,
+                       const CheckOpString& result)
+    : severity_(severity) {
+  Init(file, line);
+  stream_ << "Check failed: " << (*result.str_);
+}
+
 LogMessage::LogMessage(const char* file, int line)
      : severity_(LOG_INFO) {
   Init(file, line);
 }
 
 LogMessage::LogMessage(const char* file, int line, LogSeverity severity)
     : severity_(severity) {
   Init(file, line);
 }
 
@@ skipping 143 matching lines @@
         // hosed can cause additional problems.
 #ifndef NDEBUG
         DisplayDebugMessage(stream_.str());
 #endif
         // Crash the process to generate a dump.
         DebugUtil::BreakDebugger();
         // TODO(mmentovai): when we have breakpad support, generate a breakpad
         // dump, but until then, do not invoke the Apple crash reporter.
       }
     }
+  } else if (severity_ == LOG_ERROR_REPORT) {
+    // We are here only if the user runs with --enable-dcheck in release mode.
+    if (log_report_handler) {
+      log_report_handler(std::string(stream_.str()));
+    } else {
+      DisplayDebugMessage(stream_.str());
+    }
   }
 }
 
 void CloseLogFile() {
   if (!log_file)
     return;
 
   CloseFile(log_file);
   log_file = NULL;
 }
 
 } // namespace logging
 
 std::ostream& operator<<(std::ostream& out, const wchar_t* wstr) {
   return out << base::SysWideToUTF8(std::wstring(wstr));
 }