Change the behavior of --enable-dcheck from crashing

base/logging.h

 // 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.
 
 #ifndef BASE_LOGGING_H_
 #define BASE_LOGGING_H_
 
 #include <string>
 #include <cstring>
 #include <sstream>
@@ skipping 59 matching lines @@
 // We also have
 //
 //   LOG_ASSERT(assertion);
 //   DLOG_ASSERT(assertion);
 //
 // which is syntactic sugar for {,D}LOG_IF(FATAL, assert fails) << assertion;
 //
 // We also override the standard 'assert' to use 'DLOG_ASSERT'.
 //
 // The supported severity levels for macros that allow you to specify one
-// are (in increasing order of severity) INFO, WARNING, ERROR, and FATAL.
-//
-// There is also the special severity of DFATAL, which logs FATAL in
-// debug mode, ERROR in normal mode.
+// are (in increasing order of severity) INFO, WARNING, ERROR, ERROR_REPORT,
+// and FATAL.
 //
 // Very important: logging a message at the FATAL severity level causes
 // the program to terminate (after the message is logged).
+//
+// Note the special severity of ERROR_REPORT only available/relevant in normal

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

Nit: add "is" before "available/relevant".

+// mode, which displays error dialog without terminating the program. There is

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

Nit: add "an" before "error dialog".

+// no error dialog for severity ERROR or below in normal mode.
+//
+// There is also the special severity of DFATAL, which logs FATAL in
+// debug mode, ERROR_REPORT in normal mode.
 
 namespace logging {
 
 // Where to record logging output? A flat file and/or system debug log via
 // OutputDebugString. Defaults on Windows to LOG_ONLY_TO_FILE, and on
 // POSIX to LOG_ONLY_TO_SYSTEM_DEBUG_LOG (aka stderr).
 enum LoggingDestination { LOG_NONE,
                           LOG_ONLY_TO_FILE,
                           LOG_ONLY_TO_SYSTEM_DEBUG_LOG,
                           LOG_TO_BOTH_FILE_AND_SYSTEM_DEBUG_LOG };
@@ skipping 47 matching lines @@
 void SetLogFilterPrefix(const char* filter);
 
 // Sets the common items you want to be prepended to each log message.
 // process and thread IDs default to off, the timestamp defaults to on.
 // If this function is not called, logging defaults to writing the timestamp
 // only.
 void SetLogItems(bool enable_process_id, bool enable_thread_id,
                  bool enable_timestamp, bool enable_tickcount);
 
 // Sets the Log Assert Handler that will be used to notify of check failures.
-// The default handler shows a dialog box, however clients can use this
-// function to override with their own handling (e.g. a silent one for Unit
-// Tests)
+// The default handler shows a dialog box and then terminate the process,

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

Nit: "terminate" => "terminates"

+// however clients can use this function to override with their own handling
+// (e.g. a silent one for Unit Tests)
 typedef void (*LogAssertHandlerFunction)(const std::string& str);
 void SetLogAssertHandler(LogAssertHandlerFunction handler);
+// Sets the Log Report Handler that will be used to notify of check failures

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

Nit: add a blank line above this line.

+// in non-debug mode. The default handler shows a dialog box and continues
+// the execution, however clients can use this function to override with their
+// own handling.
+typedef void (*LogReportHandlerFunction)(const std::string& str);
+void SetLogReportHandler(LogReportHandlerFunction handler);
 
 typedef int LogSeverity;
 const LogSeverity LOG_INFO = 0;
 const LogSeverity LOG_WARNING = 1;
 const LogSeverity LOG_ERROR = 2;
-const LogSeverity LOG_FATAL = 3;
-const LogSeverity LOG_NUM_SEVERITIES = 4;
+const LogSeverity LOG_ERROR_REPORT = 3;
+const LogSeverity LOG_FATAL = 4;
+const LogSeverity LOG_NUM_SEVERITIES = 5;
 
-// LOG_DFATAL_LEVEL is LOG_FATAL in debug mode, ERROR in normal mode
+// LOG_DFATAL_LEVEL is LOG_FATAL in debug mode, ERROR_REPORT in normal mode
 #ifdef NDEBUG
-const LogSeverity LOG_DFATAL_LEVEL = LOG_ERROR;
+const LogSeverity LOG_DFATAL_LEVEL = LOG_ERROR_REPORT;
 #else
 const LogSeverity LOG_DFATAL_LEVEL = LOG_FATAL;
 #endif
 
 // A few definitions of macros that don't generate much code. These are used
 // by LOG() and LOG_IF, etc. Since these are used all over our code, it's
 // better to have compact code for these operations.
 #define COMPACT_GOOGLE_LOG_INFO \
   logging::LogMessage(__FILE__, __LINE__)
 #define COMPACT_GOOGLE_LOG_WARNING \
   logging::LogMessage(__FILE__, __LINE__, logging::LOG_WARNING)
 #define COMPACT_GOOGLE_LOG_ERROR \
   logging::LogMessage(__FILE__, __LINE__, logging::LOG_ERROR)
+#define COMPACT_GOOGLE_LOG_ERROR_REPORT \
+  logging::LogMessage(__FILE__, __LINE__, logging::LOG_ERROR_REPORT)
 #define COMPACT_GOOGLE_LOG_FATAL \
   logging::LogMessage(__FILE__, __LINE__, logging::LOG_FATAL)
 #define COMPACT_GOOGLE_LOG_DFATAL \
   logging::LogMessage(__FILE__, __LINE__, logging::LOG_DFATAL_LEVEL)
 
 // wingdi.h defines ERROR to be 0. When we call LOG(ERROR), it gets
 // substituted with 0, and it expands to COMPACT_GOOGLE_LOG_0. To allow us
 // to keep using this syntax, we define this macro to do the same thing
 // as COMPACT_GOOGLE_LOG_ERROR, and also define ERROR the same way that
 // the Windows SDK does for consistency.
@@ skipping 195 matching lines @@
 // non-debug mode. The DCHECK and friends macros use this so that
 // the expanded expression DCHECK(foo) << "asdf" is still syntactically
 // valid, even though the expression will get optimized away.
 #define NDEBUG_EAT_STREAM_PARAMETERS \
   logging::LogMessage(__FILE__, __LINE__).stream()
 
 // Set to true in InitLogging when we want to enable the dchecks in release.
 extern bool g_enable_dcheck;
 #define DCHECK(condition) \
     !logging::g_enable_dcheck ? void (0) : \
-        LOG_IF(FATAL, !(condition)) << "Check failed: " #condition ". "
+        LOG_IF(ERROR_REPORT, !(condition)) << "Check failed: " #condition ". "
 
 // Helper macro for binary operators.
 // Don't use this macro directly in your code, use DCHECK_EQ et al below.
 #define DCHECK_OP(name, op, val1, val2)  \
   if (logging::g_enable_dcheck) \
     if (logging::CheckOpString _result = \
         logging::Check##name##Impl((val1), (val2), #val1 " " #op " " #val2)) \
-      logging::LogMessage(__FILE__, __LINE__, _result).stream()
+      logging::LogMessage(__FILE__, __LINE__, logging::LOG_ERROR_REPORT, \
+                          _result).stream()
 
 #define DCHECK_STREQ(str1, str2) \
   while (false) NDEBUG_EAT_STREAM_PARAMETERS
 
 #define DCHECK_STRCASEEQ(str1, str2) \
   while (false) NDEBUG_EAT_STREAM_PARAMETERS
 
 #define DCHECK_STRNE(str1, str2) \
   while (false) NDEBUG_EAT_STREAM_PARAMETERS
 
@@ skipping 84 matching lines @@
   // are: ctr = 0
   //
   // Using this constructor instead of the more complex constructor above
   // saves a couple of bytes per call site.
   LogMessage(const char* file, int line, LogSeverity severity);
 
   // A special constructor used for check failures.
   // Implied severity = LOG_FATAL
   LogMessage(const char* file, int line, const CheckOpString& result);
 
+  // A special constructor used for check failures, with the option to
+  // specify severity.
+  LogMessage(const char* file, int line, LogSeverity severity,
+             const CheckOpString& result);
+
   ~LogMessage();
 
   std::ostream& stream() { return stream_; }
 
  private:
   void Init(const char* file, int line);
 
   LogSeverity severity_;
   std::ostringstream stream_;
   size_t message_start_;  // Offset of the start of the message (past prefix
@@ skipping 74 matching lines @@
 #elif NOTIMPLEMENTED_POLICY == 4
 #define NOTIMPLEMENTED() LOG(ERROR) << NOTIMPLEMENTED_MSG
 #elif NOTIMPLEMENTED_POLICY == 5
 #define NOTIMPLEMENTED() do {\
   static int count = 0;\
   LOG_IF(ERROR, 0 == count++) << NOTIMPLEMENTED_MSG;\
 } while(0)
 #endif
 
 #endif  // BASE_LOGGING_H_