Implement Dump-on-DCHECK (via alternate DCHECK and DCHECK_OP macro implementations).

base/logging.h

 // Copyright (c) 2012 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 <stddef.h>
 
 #include <cassert>
@@ skipping 317 matching lines @@
 const LogSeverity LOG_VERBOSE = -1;  // This is level 1 verbosity
 // Note: the log severities are used to index into the array of names,
 // see log_severity_names.
 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;
 
 // LOG_DFATAL is LOG_FATAL in debug mode, ERROR in normal mode
-#if defined(NDEBUG)
+#if defined(NDEBUG) || defined(DCHECK_IS_DUMP_WITHOUT_CRASH)
 const LogSeverity LOG_DFATAL = LOG_ERROR;
 #else
 const LogSeverity LOG_DFATAL = 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_EX_INFO(ClassName, ...) \
   ::logging::ClassName(__FILE__, __LINE__, ::logging::LOG_INFO, ##__VA_ARGS__)
@@ skipping 452 matching lines @@
 // whether DCHECKs are enabled; this is so that we don't get unused
 // variable warnings if the only use of a variable is in a DCHECK.
 // This behavior is different from DLOG_IF et al.
 //
 // Note that the definition of the DCHECK macros depends on whether or not
 // DCHECK_IS_ON() is true. When DCHECK_IS_ON() is false, the macros use
 // EAT_STREAM_PARAMETERS to avoid expressions that would create temporaries.
 
 #if DCHECK_IS_ON()
 
+#if defined(DCHECK_IS_DUMP_WITHOUT_CRASH)
+// DCHECK is configured to dump-without-crashing, rather than logging.
+// Since we only intend to enable this in official builds, we follow the
+// example of CHECK_OP etc in official builds, and strip out logging.
+// See crbug.com/596231.
+
+BASE_EXPORT void DCheckDumpWithoutCrashingOnce();
+
+#define DCHECK(condition)                                   \
+  !(condition) ? ::logging::DCheckDumpWithoutCrashingOnce() \
+               : EAT_STREAM_PARAMETERS
+
+#define DPCHECK(condition) DCHECK(condition)
+
+#else // defined(DCHECK_IS_DUMP_WITHOUT_CRASH)
+
 #define DCHECK(condition)                                           \
   LAZY_STREAM(LOG_STREAM(DCHECK), !ANALYZER_ASSUME_TRUE(condition)) \
       << "Check failed: " #condition ". "
 #define DPCHECK(condition)                                           \
   LAZY_STREAM(PLOG_STREAM(DCHECK), !ANALYZER_ASSUME_TRUE(condition)) \
       << "Check failed: " #condition ". "
 
+#endif // defined(DCHECK_IS_DUMP_WITHOUT_CRASH)
+
 #else  // DCHECK_IS_ON()
 
 #define DCHECK(condition) \
   EAT_STREAM_PARAMETERS << !ANALYZER_ASSUME_TRUE(condition)
 #define DPCHECK(condition) \
   EAT_STREAM_PARAMETERS << !ANALYZER_ASSUME_TRUE(condition)
 
 #endif  // DCHECK_IS_ON()
 
 // Helper macro for binary operators.
 // Don't use this macro directly in your code, use DCHECK_EQ et al below.
 // The 'switch' is used to prevent the 'else' from being ambiguous when the
 // macro is used in an 'if' clause such as:
 // if (a == 1)
 //   DCHECK_EQ(2, a);
 #if DCHECK_IS_ON()
 
+#if defined(DCHECK_IS_DUMP_WITHOUT_CRASH)
+// DCHECK is configured to dump-without-crashing, rather than logging.
+// DCHECK_OP builds on DCHECK in this case (thereby inheriting the stripping
+// of any << logged output. We use Check[op]Impl() for the comparison rather
+// that comparing val1 and val2 directly because it ensures that the values'
+// operator<< implementation is referenced, while coping with unnamed enums.
+// See crbug.com/596231.
+
+#define DCHECK_OP(name, op, val1, val2) \
+  DCHECK(::logging::Check##name##Impl((val1), (val2), "") == nullptr)
+
+#else  // defined(DCHECK_IS_DUMP_WITHOUT_CRASH)
+
 #define DCHECK_OP(name, op, val1, val2)                                \
   switch (0) case 0: default:                                          \
   if (::logging::CheckOpResult true_if_passed =                        \
       DCHECK_IS_ON() ?                                                 \
       ::logging::Check##name##Impl((val1), (val2),                     \
                                    #val1 " " #op " " #val2) : nullptr) \
    ;                                                                   \
   else                                                                 \
     ::logging::LogMessage(__FILE__, __LINE__, ::logging::LOG_DCHECK,   \
                           true_if_passed.message()).stream()
 
+#endif // defined(DCHECK_IS_DUMP_WITHOUT_CRASH)
+
 #else  // DCHECK_IS_ON()
 
 // When DCHECKs aren't enabled, DCHECK_OP still needs to reference operator<<
 // overloads for |val1| and |val2| to avoid potential compiler warnings about
 // unused functions. For the same reason, it also compares |val1| and |val2|
 // using |op|.
 //
 // Note that the contract of DCHECK_EQ, etc is that arguments are only evaluated
 // once. Even though |val1| and |val2| appear twice in this version of the macro
 // expansion, this is OK, since the expression is never actually evaluated.
@@ skipping 269 matching lines @@
 #elif NOTIMPLEMENTED_POLICY == 5
 #define NOTIMPLEMENTED() do {\
   static bool logged_once = false;\
   LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG;\
   logged_once = true;\
 } while(0);\
 EAT_STREAM_PARAMETERS
 #endif
 
 #endif  // BASE_LOGGING_H_