1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef BASE_LOGGING_H_
6 #define BASE_LOGGING_H_
14 #include "base/base_export.h"
15 #include "base/basictypes.h"
16 #include "build/build_config.h"
19 // Optional message capabilities
20 // -----------------------------
21 // Assertion failed messages and fatal errors are displayed in a dialog box
22 // before the application exits. However, running this UI creates a message
23 // loop, which causes application messages to be processed and potentially
24 // dispatched to existing application windows. Since the application is in a
25 // bad state when this assertion dialog is displayed, these messages may not
26 // get processed and hang the dialog, or the application might go crazy.
28 // Therefore, it can be beneficial to display the error dialog in a separate
29 // process from the main application. When the logging system needs to display
30 // a fatal error dialog box, it will look for a program called
31 // "DebugMessage.exe" in the same directory as the application executable. It
32 // will run this application with the message as the command line, and will
33 // not include the name of the application as is traditional for easier
36 // The code for DebugMessage.exe is only one line. In WinMain, do:
37 // MessageBox(NULL, GetCommandLineW(), L"Fatal Error", 0);
39 // If DebugMessage.exe is not found, the logging code will use a normal
40 // MessageBox, potentially causing the problems discussed above.
46 // Make a bunch of macros for logging. The way to log things is to stream
47 // things to LOG(<a particular severity level>). E.g.,
49 // LOG(INFO) << "Found " << num_cookies << " cookies";
51 // You can also do conditional logging:
53 // LOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
55 // The above will cause log messages to be output on the 1st, 11th, 21st, ...
56 // times it is executed. Note that the special COUNTER value is used to
57 // identify which repetition is happening.
59 // The CHECK(condition) macro is active in both debug and release builds and
60 // effectively performs a LOG(FATAL) which terminates the process and
61 // generates a crashdump unless a debugger is attached.
63 // There are also "debug mode" logging macros like the ones above:
65 // DLOG(INFO) << "Found cookies";
67 // DLOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
69 // All "debug mode" logging is compiled away to nothing for non-debug mode
70 // compiles. LOG_IF and development flags also work well together
71 // because the code can be compiled away sometimes.
75 // LOG_ASSERT(assertion);
76 // DLOG_ASSERT(assertion);
78 // which is syntactic sugar for {,D}LOG_IF(FATAL, assert fails) << assertion;
80 // There are "verbose level" logging macros. They look like
82 // VLOG(1) << "I'm printed when you run the program with --v=1 or more";
83 // VLOG(2) << "I'm printed when you run the program with --v=2 or more";
85 // These always log at the INFO log level (when they log at all).
86 // The verbose logging can also be turned on module-by-module. For instance,
87 // --vmodule=profile=2,icon_loader=1,browser_*=3,*/chromeos/*=4 --v=0
89 // a. VLOG(2) and lower messages to be printed from profile.{h,cc}
90 // b. VLOG(1) and lower messages to be printed from icon_loader.{h,cc}
91 // c. VLOG(3) and lower messages to be printed from files prefixed with
93 // d. VLOG(4) and lower messages to be printed from files under a
94 // "chromeos" directory.
95 // e. VLOG(0) and lower messages to be printed from elsewhere
97 // The wildcarding functionality shown by (c) supports both '*' (match
98 // 0 or more characters) and '?' (match any single character)
99 // wildcards. Any pattern containing a forward or backward slash will
100 // be tested against the whole pathname and not just the module.
101 // E.g., "*/foo/bar/*=2" would change the logging level for all code
102 // in source files under a "foo/bar" directory.
104 // There's also VLOG_IS_ON(n) "verbose level" condition macro. To be used as
106 // if (VLOG_IS_ON(2)) {
107 // // do some logging preparation and logging
108 // // that can't be accomplished with just VLOG(2) << ...;
111 // There is also a VLOG_IF "verbose level" condition macro for sample
112 // cases, when some extra computation and preparation for logs is not
115 // VLOG_IF(1, (size > 1024))
116 // << "I'm printed when size is more than 1024 and when you run the "
117 // "program with --v=1 or more";
119 // We also override the standard 'assert' to use 'DLOG_ASSERT'.
123 // PLOG(ERROR) << "Couldn't do foo";
124 // DPLOG(ERROR) << "Couldn't do foo";
125 // PLOG_IF(ERROR, cond) << "Couldn't do foo";
126 // DPLOG_IF(ERROR, cond) << "Couldn't do foo";
127 // PCHECK(condition) << "Couldn't do foo";
128 // DPCHECK(condition) << "Couldn't do foo";
130 // which append the last system error to the message in string form (taken from
131 // GetLastError() on Windows and errno on POSIX).
133 // The supported severity levels for macros that allow you to specify one
134 // are (in increasing order of severity) INFO, WARNING, ERROR, ERROR_REPORT,
137 // Very important: logging a message at the FATAL severity level causes
138 // the program to terminate (after the message is logged).
140 // Note the special severity of ERROR_REPORT only available/relevant in normal
141 // mode, which displays error dialog without terminating the program. There is
142 // no error dialog for severity ERROR or below in normal mode.
144 // There is also the special severity of DFATAL, which logs FATAL in
145 // debug mode, ERROR in normal mode.
149 // Where to record logging output? A flat file and/or system debug log via
150 // OutputDebugString. Defaults on Windows to LOG_ONLY_TO_FILE, and on
151 // POSIX to LOG_ONLY_TO_SYSTEM_DEBUG_LOG (aka stderr).
152 enum LoggingDestination
{ LOG_NONE
,
154 LOG_ONLY_TO_SYSTEM_DEBUG_LOG
,
155 LOG_TO_BOTH_FILE_AND_SYSTEM_DEBUG_LOG
};
157 // Indicates that the log file should be locked when being written to.
158 // Often, there is no locking, which is fine for a single threaded program.
159 // If logging is being done from multiple threads or there can be more than
160 // one process doing the logging, the file should be locked during writes to
161 // make each log outut atomic. Other writers will block.
163 // All processes writing to the log file must have their locking set for it to
164 // work properly. Defaults to DONT_LOCK_LOG_FILE.
165 enum LogLockingState
{ LOCK_LOG_FILE
, DONT_LOCK_LOG_FILE
};
167 // On startup, should we delete or append to an existing log file (if any)?
168 // Defaults to APPEND_TO_OLD_LOG_FILE.
169 enum OldFileDeletionState
{ DELETE_OLD_LOG_FILE
, APPEND_TO_OLD_LOG_FILE
};
172 DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS
,
173 ENABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS
176 // TODO(avi): do we want to do a unification of character types here?
178 typedef wchar_t PathChar
;
180 typedef char PathChar
;
183 // Define different names for the BaseInitLoggingImpl() function depending on
184 // whether NDEBUG is defined or not so that we'll fail to link if someone tries
185 // to compile logging.cc with NDEBUG but includes logging.h without defining it,
188 #define BaseInitLoggingImpl BaseInitLoggingImpl_built_with_NDEBUG
190 #define BaseInitLoggingImpl BaseInitLoggingImpl_built_without_NDEBUG
193 // Implementation of the InitLogging() method declared below. We use a
194 // more-specific name so we can #define it above without affecting other code
195 // that has named stuff "InitLogging".
196 BASE_EXPORT
bool BaseInitLoggingImpl(const PathChar
* log_file
,
197 LoggingDestination logging_dest
,
198 LogLockingState lock_log
,
199 OldFileDeletionState delete_old
,
200 DcheckState dcheck_state
);
202 // Sets the log file name and other global logging state. Calling this function
203 // is recommended, and is normally done at the beginning of application init.
204 // If you don't call it, all the flags will be initialized to their default
205 // values, and there is a race condition that may leak a critical section
206 // object if two threads try to do the first log at the same time.
207 // See the definition of the enums above for descriptions and default values.
209 // The default log file is initialized to "debug.log" in the application
210 // directory. You probably don't want this, especially since the program
211 // directory may not be writable on an enduser's system.
212 inline bool InitLogging(const PathChar
* log_file
,
213 LoggingDestination logging_dest
,
214 LogLockingState lock_log
,
215 OldFileDeletionState delete_old
,
216 DcheckState dcheck_state
) {
217 return BaseInitLoggingImpl(log_file
, logging_dest
, lock_log
,
218 delete_old
, dcheck_state
);
221 // Sets the log level. Anything at or above this level will be written to the
222 // log file/displayed to the user (if applicable). Anything below this level
223 // will be silently ignored. The log level defaults to 0 (everything is logged
224 // up to level INFO) if this function is not called.
225 // Note that log messages for VLOG(x) are logged at level -x, so setting
226 // the min log level to negative values enables verbose logging.
227 BASE_EXPORT
void SetMinLogLevel(int level
);
229 // Gets the current log level.
230 BASE_EXPORT
int GetMinLogLevel();
232 // Gets the VLOG default verbosity level.
233 BASE_EXPORT
int GetVlogVerbosity();
235 // Gets the current vlog level for the given file (usually taken from
238 // Note that |N| is the size *with* the null terminator.
239 BASE_EXPORT
int GetVlogLevelHelper(const char* file_start
, size_t N
);
242 int GetVlogLevel(const char (&file
)[N
]) {
243 return GetVlogLevelHelper(file
, N
);
246 // Sets the common items you want to be prepended to each log message.
247 // process and thread IDs default to off, the timestamp defaults to on.
248 // If this function is not called, logging defaults to writing the timestamp
250 BASE_EXPORT
void SetLogItems(bool enable_process_id
, bool enable_thread_id
,
251 bool enable_timestamp
, bool enable_tickcount
);
253 // Sets whether or not you'd like to see fatal debug messages popped up in
254 // a dialog box or not.
255 // Dialogs are not shown by default.
256 BASE_EXPORT
void SetShowErrorDialogs(bool enable_dialogs
);
258 // Sets the Log Assert Handler that will be used to notify of check failures.
259 // The default handler shows a dialog box and then terminate the process,
260 // however clients can use this function to override with their own handling
261 // (e.g. a silent one for Unit Tests)
262 typedef void (*LogAssertHandlerFunction
)(const std::string
& str
);
263 BASE_EXPORT
void SetLogAssertHandler(LogAssertHandlerFunction handler
);
265 // Sets the Log Report Handler that will be used to notify of check failures
266 // in non-debug mode. The default handler shows a dialog box and continues
267 // the execution, however clients can use this function to override with their
269 typedef void (*LogReportHandlerFunction
)(const std::string
& str
);
270 BASE_EXPORT
void SetLogReportHandler(LogReportHandlerFunction handler
);
272 // Sets the Log Message Handler that gets passed every log message before
273 // it's sent to other log destinations (if any).
274 // Returns true to signal that it handled the message and the message
275 // should not be sent to other log destinations.
276 typedef bool (*LogMessageHandlerFunction
)(int severity
,
277 const char* file
, int line
, size_t message_start
, const std::string
& str
);
278 BASE_EXPORT
void SetLogMessageHandler(LogMessageHandlerFunction handler
);
279 BASE_EXPORT LogMessageHandlerFunction
GetLogMessageHandler();
281 typedef int LogSeverity
;
282 const LogSeverity LOG_VERBOSE
= -1; // This is level 1 verbosity
283 // Note: the log severities are used to index into the array of names,
284 // see log_severity_names.
285 const LogSeverity LOG_INFO
= 0;
286 const LogSeverity LOG_WARNING
= 1;
287 const LogSeverity LOG_ERROR
= 2;
288 const LogSeverity LOG_ERROR_REPORT
= 3;
289 const LogSeverity LOG_FATAL
= 4;
290 const LogSeverity LOG_NUM_SEVERITIES
= 5;
292 // LOG_DFATAL is LOG_FATAL in debug mode, ERROR in normal mode
294 const LogSeverity LOG_DFATAL
= LOG_ERROR
;
296 const LogSeverity LOG_DFATAL
= LOG_FATAL
;
299 // A few definitions of macros that don't generate much code. These are used
300 // by LOG() and LOG_IF, etc. Since these are used all over our code, it's
301 // better to have compact code for these operations.
302 #define COMPACT_GOOGLE_LOG_EX_INFO(ClassName, ...) \
303 logging::ClassName(__FILE__, __LINE__, logging::LOG_INFO , ##__VA_ARGS__)
304 #define COMPACT_GOOGLE_LOG_EX_WARNING(ClassName, ...) \
305 logging::ClassName(__FILE__, __LINE__, logging::LOG_WARNING , ##__VA_ARGS__)
306 #define COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ...) \
307 logging::ClassName(__FILE__, __LINE__, logging::LOG_ERROR , ##__VA_ARGS__)
308 #define COMPACT_GOOGLE_LOG_EX_ERROR_REPORT(ClassName, ...) \
309 logging::ClassName(__FILE__, __LINE__, \
310 logging::LOG_ERROR_REPORT , ##__VA_ARGS__)
311 #define COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ...) \
312 logging::ClassName(__FILE__, __LINE__, logging::LOG_FATAL , ##__VA_ARGS__)
313 #define COMPACT_GOOGLE_LOG_EX_DFATAL(ClassName, ...) \
314 logging::ClassName(__FILE__, __LINE__, logging::LOG_DFATAL , ##__VA_ARGS__)
316 #define COMPACT_GOOGLE_LOG_INFO \
317 COMPACT_GOOGLE_LOG_EX_INFO(LogMessage)
318 #define COMPACT_GOOGLE_LOG_WARNING \
319 COMPACT_GOOGLE_LOG_EX_WARNING(LogMessage)
320 #define COMPACT_GOOGLE_LOG_ERROR \
321 COMPACT_GOOGLE_LOG_EX_ERROR(LogMessage)
322 #define COMPACT_GOOGLE_LOG_ERROR_REPORT \
323 COMPACT_GOOGLE_LOG_EX_ERROR_REPORT(LogMessage)
324 #define COMPACT_GOOGLE_LOG_FATAL \
325 COMPACT_GOOGLE_LOG_EX_FATAL(LogMessage)
326 #define COMPACT_GOOGLE_LOG_DFATAL \
327 COMPACT_GOOGLE_LOG_EX_DFATAL(LogMessage)
329 // wingdi.h defines ERROR to be 0. When we call LOG(ERROR), it gets
330 // substituted with 0, and it expands to COMPACT_GOOGLE_LOG_0. To allow us
331 // to keep using this syntax, we define this macro to do the same thing
332 // as COMPACT_GOOGLE_LOG_ERROR, and also define ERROR the same way that
333 // the Windows SDK does for consistency.
335 #define COMPACT_GOOGLE_LOG_EX_0(ClassName, ...) \
336 COMPACT_GOOGLE_LOG_EX_ERROR(ClassName , ##__VA_ARGS__)
337 #define COMPACT_GOOGLE_LOG_0 COMPACT_GOOGLE_LOG_ERROR
338 // Needed for LOG_IS_ON(ERROR).
339 const LogSeverity LOG_0
= LOG_ERROR
;
341 // As special cases, we can assume that LOG_IS_ON(ERROR_REPORT) and
342 // LOG_IS_ON(FATAL) always hold. Also, LOG_IS_ON(DFATAL) always holds
343 // in debug mode. In particular, CHECK()s will always fire if they
345 #define LOG_IS_ON(severity) \
346 ((::logging::LOG_ ## severity) >= ::logging::GetMinLogLevel())
348 // We can't do any caching tricks with VLOG_IS_ON() like the
349 // google-glog version since it requires GCC extensions. This means
350 // that using the v-logging functions in conjunction with --vmodule
352 #define VLOG_IS_ON(verboselevel) \
353 ((verboselevel) <= ::logging::GetVlogLevel(__FILE__))
355 // Helper macro which avoids evaluating the arguments to a stream if
356 // the condition doesn't hold.
357 #define LAZY_STREAM(stream, condition) \
358 !(condition) ? (void) 0 : ::logging::LogMessageVoidify() & (stream)
360 // We use the preprocessor's merging operator, "##", so that, e.g.,
361 // LOG(INFO) becomes the token COMPACT_GOOGLE_LOG_INFO. There's some funny
362 // subtle difference between ostream member streaming functions (e.g.,
363 // ostream::operator<<(int) and ostream non-member streaming functions
364 // (e.g., ::operator<<(ostream&, string&): it turns out that it's
365 // impossible to stream something like a string directly to an unnamed
366 // ostream. We employ a neat hack by calling the stream() member
367 // function of LogMessage which seems to avoid the problem.
368 #define LOG_STREAM(severity) COMPACT_GOOGLE_LOG_ ## severity.stream()
370 #define LOG(severity) LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity))
371 #define LOG_IF(severity, condition) \
372 LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
374 #define SYSLOG(severity) LOG(severity)
375 #define SYSLOG_IF(severity, condition) LOG_IF(severity, condition)
377 // The VLOG macros log with negative verbosities.
378 #define VLOG_STREAM(verbose_level) \
379 logging::LogMessage(__FILE__, __LINE__, -verbose_level).stream()
381 #define VLOG(verbose_level) \
382 LAZY_STREAM(VLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level))
384 #define VLOG_IF(verbose_level, condition) \
385 LAZY_STREAM(VLOG_STREAM(verbose_level), \
386 VLOG_IS_ON(verbose_level) && (condition))
389 #define VPLOG_STREAM(verbose_level) \
390 logging::Win32ErrorLogMessage(__FILE__, __LINE__, -verbose_level, \
391 ::logging::GetLastSystemErrorCode()).stream()
392 #elif defined(OS_POSIX)
393 #define VPLOG_STREAM(verbose_level) \
394 logging::ErrnoLogMessage(__FILE__, __LINE__, -verbose_level, \
395 ::logging::GetLastSystemErrorCode()).stream()
398 #define VPLOG(verbose_level) \
399 LAZY_STREAM(VPLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level))
401 #define VPLOG_IF(verbose_level, condition) \
402 LAZY_STREAM(VPLOG_STREAM(verbose_level), \
403 VLOG_IS_ON(verbose_level) && (condition))
405 // TODO(akalin): Add more VLOG variants, e.g. VPLOG.
407 #define LOG_ASSERT(condition) \
408 LOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". "
409 #define SYSLOG_ASSERT(condition) \
410 SYSLOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". "
413 #define LOG_GETLASTERROR_STREAM(severity) \
414 COMPACT_GOOGLE_LOG_EX_ ## severity(Win32ErrorLogMessage, \
415 ::logging::GetLastSystemErrorCode()).stream()
416 #define LOG_GETLASTERROR(severity) \
417 LAZY_STREAM(LOG_GETLASTERROR_STREAM(severity), LOG_IS_ON(severity))
418 #define LOG_GETLASTERROR_MODULE_STREAM(severity, module) \
419 COMPACT_GOOGLE_LOG_EX_ ## severity(Win32ErrorLogMessage, \
420 ::logging::GetLastSystemErrorCode(), module).stream()
421 #define LOG_GETLASTERROR_MODULE(severity, module) \
422 LAZY_STREAM(LOG_GETLASTERROR_STREAM(severity, module), \
424 // PLOG_STREAM is used by PLOG, which is the usual error logging macro
425 // for each platform.
426 #define PLOG_STREAM(severity) LOG_GETLASTERROR_STREAM(severity)
427 #elif defined(OS_POSIX)
428 #define LOG_ERRNO_STREAM(severity) \
429 COMPACT_GOOGLE_LOG_EX_ ## severity(ErrnoLogMessage, \
430 ::logging::GetLastSystemErrorCode()).stream()
431 #define LOG_ERRNO(severity) \
432 LAZY_STREAM(LOG_ERRNO_STREAM(severity), LOG_IS_ON(severity))
433 // PLOG_STREAM is used by PLOG, which is the usual error logging macro
434 // for each platform.
435 #define PLOG_STREAM(severity) LOG_ERRNO_STREAM(severity)
436 // TODO(tschmelcher): Should we add OSStatus logging for Mac?
439 #define PLOG(severity) \
440 LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))
442 #define PLOG_IF(severity, condition) \
443 LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
445 // CHECK dies with a fatal error if condition is not true. It is *not*
446 // controlled by NDEBUG, so the check will be executed regardless of
449 // We make sure CHECK et al. always evaluates their arguments, as
450 // doing CHECK(FunctionWithSideEffect()) is a common idiom.
451 #define CHECK(condition) \
452 LAZY_STREAM(LOG_STREAM(FATAL), !(condition)) \
453 << "Check failed: " #condition ". "
455 #define PCHECK(condition) \
456 LAZY_STREAM(PLOG_STREAM(FATAL), !(condition)) \
457 << "Check failed: " #condition ". "
459 // Build the error message string. This is separate from the "Impl"
460 // function template because it is not performance critical and so can
461 // be out of line, while the "Impl" code should be inline. Caller
462 // takes ownership of the returned string.
463 template<class t1
, class t2
>
464 std::string
* MakeCheckOpString(const t1
& v1
, const t2
& v2
, const char* names
) {
465 std::ostringstream ss
;
466 ss
<< names
<< " (" << v1
<< " vs. " << v2
<< ")";
467 std::string
* msg
= new std::string(ss
.str());
471 // MSVC doesn't like complex extern templates and DLLs.
472 #if !defined(COMPILER_MSVC)
473 // Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated
475 extern template BASE_EXPORT
std::string
* MakeCheckOpString
<int, int>(
476 const int&, const int&, const char* names
);
477 extern template BASE_EXPORT
478 std::string
* MakeCheckOpString
<unsigned long, unsigned long>(
479 const unsigned long&, const unsigned long&, const char* names
);
480 extern template BASE_EXPORT
481 std::string
* MakeCheckOpString
<unsigned long, unsigned int>(
482 const unsigned long&, const unsigned int&, const char* names
);
483 extern template BASE_EXPORT
484 std::string
* MakeCheckOpString
<unsigned int, unsigned long>(
485 const unsigned int&, const unsigned long&, const char* names
);
486 extern template BASE_EXPORT
487 std::string
* MakeCheckOpString
<std::string
, std::string
>(
488 const std::string
&, const std::string
&, const char* name
);
491 // Helper macro for binary operators.
492 // Don't use this macro directly in your code, use CHECK_EQ et al below.
494 // TODO(akalin): Rewrite this so that constructs like if (...)
495 // CHECK_EQ(...) else { ... } work properly.
496 #define CHECK_OP(name, op, val1, val2) \
497 if (std::string* _result = \
498 logging::Check##name##Impl((val1), (val2), \
499 #val1 " " #op " " #val2)) \
500 logging::LogMessage(__FILE__, __LINE__, _result).stream()
502 // Helper functions for CHECK_OP macro.
503 // The (int, int) specialization works around the issue that the compiler
504 // will not instantiate the template version of the function on values of
505 // unnamed enum type - see comment below.
506 #define DEFINE_CHECK_OP_IMPL(name, op) \
507 template <class t1, class t2> \
508 inline std::string* Check##name##Impl(const t1& v1, const t2& v2, \
509 const char* names) { \
510 if (v1 op v2) return NULL; \
511 else return MakeCheckOpString(v1, v2, names); \
513 inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \
514 if (v1 op v2) return NULL; \
515 else return MakeCheckOpString(v1, v2, names); \
517 DEFINE_CHECK_OP_IMPL(EQ
, ==)
518 DEFINE_CHECK_OP_IMPL(NE
, !=)
519 DEFINE_CHECK_OP_IMPL(LE
, <=)
520 DEFINE_CHECK_OP_IMPL(LT
, < )
521 DEFINE_CHECK_OP_IMPL(GE
, >=)
522 DEFINE_CHECK_OP_IMPL(GT
, > )
523 #undef DEFINE_CHECK_OP_IMPL
525 #define CHECK_EQ(val1, val2) CHECK_OP(EQ, ==, val1, val2)
526 #define CHECK_NE(val1, val2) CHECK_OP(NE, !=, val1, val2)
527 #define CHECK_LE(val1, val2) CHECK_OP(LE, <=, val1, val2)
528 #define CHECK_LT(val1, val2) CHECK_OP(LT, < , val1, val2)
529 #define CHECK_GE(val1, val2) CHECK_OP(GE, >=, val1, val2)
530 #define CHECK_GT(val1, val2) CHECK_OP(GT, > , val1, val2)
532 // http://crbug.com/16512 is open for a real fix for this. For now, Windows
533 // uses OFFICIAL_BUILD and other platforms use the branding flag when NDEBUG is
535 #if ( defined(OS_WIN) && defined(OFFICIAL_BUILD)) || \
536 (!defined(OS_WIN) && defined(NDEBUG) && defined(GOOGLE_CHROME_BUILD))
537 // Used by unit tests.
538 #define LOGGING_IS_OFFICIAL_BUILD
540 // In order to have optimized code for official builds, remove DLOGs and
542 #define ENABLE_DLOG 0
543 #define ENABLE_DCHECK 0
545 #elif defined(NDEBUG)
546 // Otherwise, if we're a release build, remove DLOGs but not DCHECKs
547 // (since those can still be turned on via a command-line flag).
548 #define ENABLE_DLOG 0
549 #define ENABLE_DCHECK 1
552 // Otherwise, we're a debug build so enable DLOGs and DCHECKs.
553 #define ENABLE_DLOG 1
554 #define ENABLE_DCHECK 1
557 // Definitions for DLOG et al.
561 #define DLOG_IS_ON(severity) LOG_IS_ON(severity)
562 #define DLOG_IF(severity, condition) LOG_IF(severity, condition)
563 #define DLOG_ASSERT(condition) LOG_ASSERT(condition)
564 #define DPLOG_IF(severity, condition) PLOG_IF(severity, condition)
565 #define DVLOG_IF(verboselevel, condition) VLOG_IF(verboselevel, condition)
566 #define DVPLOG_IF(verboselevel, condition) VPLOG_IF(verboselevel, condition)
570 // If ENABLE_DLOG is off, we want to avoid emitting any references to
571 // |condition| (which may reference a variable defined only if NDEBUG
572 // is not defined). Contrast this with DCHECK et al., which has
573 // different behavior.
575 #define DLOG_EAT_STREAM_PARAMETERS \
576 true ? (void) 0 : ::logging::LogMessageVoidify() & LOG_STREAM(FATAL)
578 #define DLOG_IS_ON(severity) false
579 #define DLOG_IF(severity, condition) DLOG_EAT_STREAM_PARAMETERS
580 #define DLOG_ASSERT(condition) DLOG_EAT_STREAM_PARAMETERS
581 #define DPLOG_IF(severity, condition) DLOG_EAT_STREAM_PARAMETERS
582 #define DVLOG_IF(verboselevel, condition) DLOG_EAT_STREAM_PARAMETERS
583 #define DVPLOG_IF(verboselevel, condition) DLOG_EAT_STREAM_PARAMETERS
585 #endif // ENABLE_DLOG
587 // DEBUG_MODE is for uses like
588 // if (DEBUG_MODE) foo.CheckThatFoo();
591 // foo.CheckThatFoo();
594 // We tie its state to ENABLE_DLOG.
595 enum { DEBUG_MODE
= ENABLE_DLOG
};
599 #define DLOG(severity) \
600 LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))
603 #define DLOG_GETLASTERROR(severity) \
604 LAZY_STREAM(LOG_GETLASTERROR_STREAM(severity), DLOG_IS_ON(severity))
605 #define DLOG_GETLASTERROR_MODULE(severity, module) \
606 LAZY_STREAM(LOG_GETLASTERROR_STREAM(severity, module), \
607 DLOG_IS_ON(severity))
608 #elif defined(OS_POSIX)
609 #define DLOG_ERRNO(severity) \
610 LAZY_STREAM(LOG_ERRNO_STREAM(severity), DLOG_IS_ON(severity))
613 #define DPLOG(severity) \
614 LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))
616 #define DVLOG(verboselevel) DVLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
618 #define DVPLOG(verboselevel) DVPLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
620 // Definitions for DCHECK et al.
626 BASE_EXPORT
extern DcheckState g_dcheck_state
;
628 #if defined(DCHECK_ALWAYS_ON)
630 #define DCHECK_IS_ON() true
631 #define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \
632 COMPACT_GOOGLE_LOG_EX_FATAL(ClassName , ##__VA_ARGS__)
633 #define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_FATAL
634 const LogSeverity LOG_DCHECK
= LOG_FATAL
;
638 #define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \
639 COMPACT_GOOGLE_LOG_EX_ERROR_REPORT(ClassName , ##__VA_ARGS__)
640 #define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_ERROR_REPORT
641 const LogSeverity LOG_DCHECK
= LOG_ERROR_REPORT
;
642 #define DCHECK_IS_ON() \
643 ((::logging::g_dcheck_state == \
644 ::logging::ENABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS) && \
647 #endif // defined(DCHECK_ALWAYS_ON)
649 #else // defined(NDEBUG)
651 // On a regular debug build, we want to have DCHECKs enabled.
652 #define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \
653 COMPACT_GOOGLE_LOG_EX_FATAL(ClassName , ##__VA_ARGS__)
654 #define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_FATAL
655 const LogSeverity LOG_DCHECK
= LOG_FATAL
;
656 #define DCHECK_IS_ON() true
658 #endif // defined(NDEBUG)
660 #else // ENABLE_DCHECK
662 // These are just dummy values since DCHECK_IS_ON() is always false in
664 #define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \
665 COMPACT_GOOGLE_LOG_EX_INFO(ClassName , ##__VA_ARGS__)
666 #define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_INFO
667 const LogSeverity LOG_DCHECK
= LOG_INFO
;
668 #define DCHECK_IS_ON() false
670 #endif // ENABLE_DCHECK
673 // DCHECK et al. make sure to reference |condition| regardless of
674 // whether DCHECKs are enabled; this is so that we don't get unused
675 // variable warnings if the only use of a variable is in a DCHECK.
676 // This behavior is different from DLOG_IF et al.
678 #define DCHECK(condition) \
679 LAZY_STREAM(LOG_STREAM(DCHECK), DCHECK_IS_ON() && !(condition)) \
680 << "Check failed: " #condition ". "
682 #define DPCHECK(condition) \
683 LAZY_STREAM(PLOG_STREAM(DCHECK), DCHECK_IS_ON() && !(condition)) \
684 << "Check failed: " #condition ". "
686 // Helper macro for binary operators.
687 // Don't use this macro directly in your code, use DCHECK_EQ et al below.
688 #define DCHECK_OP(name, op, val1, val2) \
689 if (DCHECK_IS_ON()) \
690 if (std::string* _result = \
691 logging::Check##name##Impl((val1), (val2), \
692 #val1 " " #op " " #val2)) \
693 logging::LogMessage( \
694 __FILE__, __LINE__, ::logging::LOG_DCHECK, \
697 // Equality/Inequality checks - compare two values, and log a
698 // LOG_DCHECK message including the two values when the result is not
699 // as expected. The values must have operator<<(ostream, ...)
702 // You may append to the error message like so:
703 // DCHECK_NE(1, 2) << ": The world must be ending!";
705 // We are very careful to ensure that each argument is evaluated exactly
706 // once, and that anything which is legal to pass as a function argument is
707 // legal here. In particular, the arguments may be temporary expressions
708 // which will end up being destroyed at the end of the apparent statement,
710 // DCHECK_EQ(string("abc")[1], 'b');
712 // WARNING: These may not compile correctly if one of the arguments is a pointer
713 // and the other is NULL. To work around this, simply static_cast NULL to the
714 // type of the desired pointer.
716 #define DCHECK_EQ(val1, val2) DCHECK_OP(EQ, ==, val1, val2)
717 #define DCHECK_NE(val1, val2) DCHECK_OP(NE, !=, val1, val2)
718 #define DCHECK_LE(val1, val2) DCHECK_OP(LE, <=, val1, val2)
719 #define DCHECK_LT(val1, val2) DCHECK_OP(LT, < , val1, val2)
720 #define DCHECK_GE(val1, val2) DCHECK_OP(GE, >=, val1, val2)
721 #define DCHECK_GT(val1, val2) DCHECK_OP(GT, > , val1, val2)
723 #define NOTREACHED() DCHECK(false)
725 // Redefine the standard assert to use our nice log files
727 #define assert(x) DLOG_ASSERT(x)
729 // This class more or less represents a particular log message. You
730 // create an instance of LogMessage and then stream stuff to it.
731 // When you finish streaming to it, ~LogMessage is called and the
732 // full message gets streamed to the appropriate destination.
734 // You shouldn't actually use LogMessage's constructor to log things,
735 // though. You should use the LOG() macro (and variants thereof)
737 class BASE_EXPORT LogMessage
{
739 LogMessage(const char* file
, int line
, LogSeverity severity
, int ctr
);
741 // Two special constructors that generate reduced amounts of code at
742 // LOG call sites for common cases.
744 // Used for LOG(INFO): Implied are:
745 // severity = LOG_INFO, ctr = 0
747 // Using this constructor instead of the more complex constructor above
748 // saves a couple of bytes per call site.
749 LogMessage(const char* file
, int line
);
751 // Used for LOG(severity) where severity != INFO. Implied
754 // Using this constructor instead of the more complex constructor above
755 // saves a couple of bytes per call site.
756 LogMessage(const char* file
, int line
, LogSeverity severity
);
758 // A special constructor used for check failures. Takes ownership
759 // of the given string.
760 // Implied severity = LOG_FATAL
761 LogMessage(const char* file
, int line
, std::string
* result
);
763 // A special constructor used for check failures, with the option to
764 // specify severity. Takes ownership of the given string.
765 LogMessage(const char* file
, int line
, LogSeverity severity
,
766 std::string
* result
);
770 std::ostream
& stream() { return stream_
; }
773 void Init(const char* file
, int line
);
775 LogSeverity severity_
;
776 std::ostringstream stream_
;
777 size_t message_start_
; // Offset of the start of the message (past prefix
779 // The file and line information passed in to the constructor.
784 // Stores the current value of GetLastError in the constructor and restores
785 // it in the destructor by calling SetLastError.
786 // This is useful since the LogMessage class uses a lot of Win32 calls
787 // that will lose the value of GLE and the code that called the log function
788 // will have lost the thread error value when the log call returns.
789 class SaveLastError
{
794 unsigned long get_error() const { return last_error_
; }
797 unsigned long last_error_
;
800 SaveLastError last_error_
;
803 DISALLOW_COPY_AND_ASSIGN(LogMessage
);
806 // A non-macro interface to the log facility; (useful
807 // when the logging level is not a compile-time constant).
808 inline void LogAtLevel(int const log_level
, std::string
const &msg
) {
809 LogMessage(__FILE__
, __LINE__
, log_level
).stream() << msg
;
812 // This class is used to explicitly ignore values in the conditional
813 // logging macros. This avoids compiler warnings like "value computed
814 // is not used" and "statement has no effect".
815 class LogMessageVoidify
{
817 LogMessageVoidify() { }
818 // This has to be an operator with a precedence lower than << but
820 void operator&(std::ostream
&) { }
824 typedef unsigned long SystemErrorCode
;
825 #elif defined(OS_POSIX)
826 typedef int SystemErrorCode
;
829 // Alias for ::GetLastError() on Windows and errno on POSIX. Avoids having to
830 // pull in windows.h just for GetLastError() and DWORD.
831 BASE_EXPORT SystemErrorCode
GetLastSystemErrorCode();
834 // Appends a formatted system message of the GetLastError() type.
835 class BASE_EXPORT Win32ErrorLogMessage
{
837 Win32ErrorLogMessage(const char* file
,
839 LogSeverity severity
,
843 Win32ErrorLogMessage(const char* file
,
845 LogSeverity severity
,
846 SystemErrorCode err
);
848 // Appends the error message before destructing the encapsulated class.
849 ~Win32ErrorLogMessage();
851 std::ostream
& stream() { return log_message_
.stream(); }
854 SystemErrorCode err_
;
855 // Optional name of the module defining the error.
857 LogMessage log_message_
;
859 DISALLOW_COPY_AND_ASSIGN(Win32ErrorLogMessage
);
861 #elif defined(OS_POSIX)
862 // Appends a formatted system message of the errno type
863 class BASE_EXPORT ErrnoLogMessage
{
865 ErrnoLogMessage(const char* file
,
867 LogSeverity severity
,
868 SystemErrorCode err
);
870 // Appends the error message before destructing the encapsulated class.
873 std::ostream
& stream() { return log_message_
.stream(); }
876 SystemErrorCode err_
;
877 LogMessage log_message_
;
879 DISALLOW_COPY_AND_ASSIGN(ErrnoLogMessage
);
883 // Closes the log file explicitly if open.
884 // NOTE: Since the log file is opened as necessary by the action of logging
885 // statements, there's no guarantee that it will stay closed
887 BASE_EXPORT
void CloseLogFile();
889 // Async signal safe logging mechanism.
890 BASE_EXPORT
void RawLog(int level
, const char* message
);
892 #define RAW_LOG(level, message) logging::RawLog(logging::LOG_ ## level, message)
894 #define RAW_CHECK(condition) \
897 logging::RawLog(logging::LOG_FATAL, "Check failed: " #condition "\n"); \
900 } // namespace logging
902 // These functions are provided as a convenience for logging, which is where we
903 // use streams (it is against Google style to use streams in other places). It
904 // is designed to allow you to emit non-ASCII Unicode strings to the log file,
905 // which is normally ASCII. It is relatively slow, so try not to use it for
906 // common cases. Non-ASCII characters will be converted to UTF-8 by these
908 BASE_EXPORT
std::ostream
& operator<<(std::ostream
& out
, const wchar_t* wstr
);
909 inline std::ostream
& operator<<(std::ostream
& out
, const std::wstring
& wstr
) {
910 return out
<< wstr
.c_str();
913 // The NOTIMPLEMENTED() macro annotates codepaths which have
914 // not been implemented yet.
916 // The implementation of this macro is controlled by NOTIMPLEMENTED_POLICY:
917 // 0 -- Do nothing (stripped by compiler)
918 // 1 -- Warn at compile time
919 // 2 -- Fail at compile time
920 // 3 -- Fail at runtime (DCHECK)
921 // 4 -- [default] LOG(ERROR) at runtime
922 // 5 -- LOG(ERROR) at runtime, only once per call-site
924 #ifndef NOTIMPLEMENTED_POLICY
925 // Select default policy: LOG(ERROR)
926 #define NOTIMPLEMENTED_POLICY 4
929 #if defined(COMPILER_GCC)
930 // On Linux, with GCC, we can use __PRETTY_FUNCTION__ to get the demangled name
931 // of the current function in the NOTIMPLEMENTED message.
932 #define NOTIMPLEMENTED_MSG "Not implemented reached in " << __PRETTY_FUNCTION__
934 #define NOTIMPLEMENTED_MSG "NOT IMPLEMENTED"
937 #if NOTIMPLEMENTED_POLICY == 0
938 #define NOTIMPLEMENTED() ;
939 #elif NOTIMPLEMENTED_POLICY == 1
940 // TODO, figure out how to generate a warning
941 #define NOTIMPLEMENTED() COMPILE_ASSERT(false, NOT_IMPLEMENTED)
942 #elif NOTIMPLEMENTED_POLICY == 2
943 #define NOTIMPLEMENTED() COMPILE_ASSERT(false, NOT_IMPLEMENTED)
944 #elif NOTIMPLEMENTED_POLICY == 3
945 #define NOTIMPLEMENTED() NOTREACHED()
946 #elif NOTIMPLEMENTED_POLICY == 4
947 #define NOTIMPLEMENTED() LOG(ERROR) << NOTIMPLEMENTED_MSG
948 #elif NOTIMPLEMENTED_POLICY == 5
949 #define NOTIMPLEMENTED() do {\
950 static int count = 0;\
951 LOG_IF(ERROR, 0 == count++) << NOTIMPLEMENTED_MSG;\
959 // Allows StringPiece to be logged.
960 BASE_EXPORT
std::ostream
& operator<<(std::ostream
& o
, const StringPiece
& piece
);
964 #endif // BASE_LOGGING_H_