A bunch of macros for logging. More...

#include <cassert>
#include <cstring>
#include <sstream>
#include <string>
#include "include/base/cef_build.h"
#include "include/internal/cef_logging_internal.h"

Namespaces
	cef

Macros
#define	COMPACT_GOOGLE_LOG_EX_INFO(ClassName, ...)

#define	COMPACT_GOOGLE_LOG_EX_WARNING(ClassName, ...)

#define	COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ...)

#define	COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ...)

#define	COMPACT_GOOGLE_LOG_EX_DFATAL(ClassName, ...)

#define	COMPACT_GOOGLE_LOG_INFO COMPACT_GOOGLE_LOG_EX_INFO(LogMessage)

#define	COMPACT_GOOGLE_LOG_WARNING COMPACT_GOOGLE_LOG_EX_WARNING(LogMessage)

#define	COMPACT_GOOGLE_LOG_ERROR COMPACT_GOOGLE_LOG_EX_ERROR(LogMessage)

#define	COMPACT_GOOGLE_LOG_FATAL COMPACT_GOOGLE_LOG_EX_FATAL(LogMessage)

#define	COMPACT_GOOGLE_LOG_DFATAL COMPACT_GOOGLE_LOG_EX_DFATAL(LogMessage)

#define	ERROR 0

#define	COMPACT_GOOGLE_LOG_EX_0(ClassName, ...) COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ##__VA_ARGS__)

#define	COMPACT_GOOGLE_LOG_0 COMPACT_GOOGLE_LOG_ERROR

#define	LOG_IS_ON(severity) ((::cef::logging::LOG_##severity) >= ::cef::logging::GetMinLogLevel())

#define	VLOG_IS_ON(verboselevel) ((verboselevel) <= ::cef::logging::GetVlogLevel(__FILE__))

#define	LAZY_STREAM(stream, condition) !(condition) ? (void)0 : ::cef::logging::LogMessageVoidify() & (stream)

#define	LOG_STREAM(severity) COMPACT_GOOGLE_LOG_##severity.stream()

#define	LOG(severity) LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity))

#define	LOG_IF(severity, condition) LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity) && (condition))

#define	SYSLOG(severity) LOG(severity)

#define	SYSLOG_IF(severity, condition) LOG_IF(severity, condition)

#define	VLOG_STREAM(verbose_level) cef::logging::LogMessage(__FILE__, __LINE__, -verbose_level).stream()

#define	VLOG(verbose_level) LAZY_STREAM(VLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level))

#define	VLOG_IF(verbose_level, condition)

#define	VPLOG_STREAM(verbose_level)

#define	VPLOG(verbose_level) LAZY_STREAM(VPLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level))

#define	VPLOG_IF(verbose_level, condition)

#define	LOG_ASSERT(condition) LOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". "

#define	SYSLOG_ASSERT(condition) SYSLOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". "

#define	PLOG_STREAM(severity)

#define	PLOG(severity) LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))

#define	PLOG_IF(severity, condition) LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition))

#define	EAT_STREAM_PARAMETERS true ? (void)0 : ::cef::logging::LogMessageVoidify() & LOG_STREAM(FATAL)

#define	CHECK(condition)

#define	PCHECK(condition)

#define	CHECK_OP(name, op, val1, val2)

#define	DEFINE_CHECK_OP_IMPL(name, op)

#define	CHECK_EQ(val1, val2) CHECK_OP(EQ, ==, val1, val2)

#define	CHECK_NE(val1, val2) CHECK_OP(NE, !=, val1, val2)

#define	CHECK_LE(val1, val2) CHECK_OP(LE, <=, val1, val2)

#define	CHECK_LT(val1, val2) CHECK_OP(LT, <, val1, val2)

#define	CHECK_GE(val1, val2) CHECK_OP(GE, >=, val1, val2)

#define	CHECK_GT(val1, val2) CHECK_OP(GT, >, val1, val2)

#define	ENABLE_DLOG 1

#define	DCHECK_IS_ON() 1

#define	DLOG_IS_ON(severity) LOG_IS_ON(severity)

#define	DLOG_IF(severity, condition) LOG_IF(severity, condition)

#define	DLOG_ASSERT(condition) LOG_ASSERT(condition)

#define	DPLOG_IF(severity, condition) PLOG_IF(severity, condition)

#define	DVLOG_IF(verboselevel, condition) VLOG_IF(verboselevel, condition)

#define	DVPLOG_IF(verboselevel, condition) VPLOG_IF(verboselevel, condition)

#define	DLOG(severity) LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))

#define	DPLOG(severity) LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))

#define	DVLOG(verboselevel) DVLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))

#define	DVPLOG(verboselevel) DVPLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))

#define	COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ##__VA_ARGS__)

#define	COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_FATAL

#define	DCHECK(condition)

#define	DPCHECK(condition)

#define	DCHECK_OP(name, op, val1, val2)

#define	DCHECK_EQ(val1, val2) DCHECK_OP(EQ, ==, val1, val2)

#define	DCHECK_NE(val1, val2) DCHECK_OP(NE, !=, val1, val2)

#define	DCHECK_LE(val1, val2) DCHECK_OP(LE, <=, val1, val2)

#define	DCHECK_LT(val1, val2) DCHECK_OP(LT, <, val1, val2)

#define	DCHECK_GE(val1, val2) DCHECK_OP(GE, >=, val1, val2)

#define	DCHECK_GT(val1, val2) DCHECK_OP(GT, >, val1, val2)

#define	NOTREACHED() DCHECK(false)

#define	assert(x) DLOG_ASSERT(x)

#define	NOTIMPLEMENTED_POLICY 4

#define	NOTIMPLEMENTED_MSG "NOT IMPLEMENTED"

#define	NOTIMPLEMENTED() LOG(ERROR) << NOTIMPLEMENTED_MSG

Functions
std::ostream &	operator<< (std::ostream &out, const wchar_t *wstr)

std::ostream &	operator<< (std::ostream &out, const std::wstring &wstr)

Detailed Description

A bunch of macros for logging.

NOTE: The contents of this file are only available to applications that link against the libcef_dll_wrapper target.

WARNING: Logging macros should not be used in the main/browser process before calling CefInitialize or in sub-processes before calling CefExecuteProcess.

INSTRUCTIONS:

The way to log things is to stream things to LOG(). E.g.,

  LOG(INFO) << "Found " << num_cookies << " cookies";

You can also do conditional logging:

  LOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";

The CHECK(condition) macro is active in both debug and release builds and effectively performs a LOG(FATAL) which terminates the process and generates a crashdump unless a debugger is attached.

There are also "debug mode" logging macros like the ones above:

  DLOG(INFO) << "Found cookies";

  DLOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";

All "debug mode" logging is compiled away to nothing for non-debug mode compiles. LOG_IF and development flags also work well together because the code can be compiled away sometimes.

We also have

  LOG_ASSERT(assertion);
  DLOG_ASSERT(assertion);

which is syntactic sugar for "{,D}LOG_IF(FATAL, assert fails) << assertion;"

There are "verbose level" logging macros. They look like

  VLOG(1) << "I'm printed when you run the program with --v=1 or more";
  VLOG(2) << "I'm printed when you run the program with --v=2 or more";

These always log at the INFO log level (when they log at all). The verbose logging can also be turned on module-by-module. For instance,

   --vmodule=profile=2,icon_loader=1,browser_*=3,*‍/chromeos/*=4 --v=0

will cause:

VLOG(2) and lower messages to be printed from profile.{h,cc}
VLOG(1) and lower messages to be printed from icon_loader.{h,cc}
VLOG(3) and lower messages to be printed from files prefixed with "browser"
VLOG(4) and lower messages to be printed from files under a "chromeos" directory.
VLOG(0) and lower messages to be printed from elsewhere

The wildcarding functionality shown by (c) supports both '*' (match 0 or more characters) and '?' (match any single character) wildcards. Any pattern containing a forward or backward slash will be tested against the whole pathname and not just the module. E.g., "*&zwj;/foo/bar/*=2" would change the logging level for all code in source files under a "foo/bar" directory.

There's also VLOG_IS_ON(n) "verbose level" condition macro. To be used as

  if (VLOG_IS_ON(2)) {
    // do some logging preparation and logging
    // that can't be accomplished with just VLOG(2) << ...;
  }

There is also a VLOG_IF "verbose level" condition macro for sample cases, when some extra computation and preparation for logs is not needed.

  VLOG_IF(1, (size > 1024))
     << "I'm printed when size is more than 1024 and when you run the "
        "program with --v=1 or more";

We also override the standard 'assert' to use 'DLOG_ASSERT'.

Lastly, there is:

  PLOG(ERROR) << "Couldn't do foo";
  DPLOG(ERROR) << "Couldn't do foo";
  PLOG_IF(ERROR, cond) << "Couldn't do foo";
  DPLOG_IF(ERROR, cond) << "Couldn't do foo";
  PCHECK(condition) << "Couldn't do foo";
  DPCHECK(condition) << "Couldn't do foo";

which append the last system error to the message in string form (taken from GetLastError() on Windows and errno on POSIX).

The supported severity levels for macros that allow you to specify one are (in increasing order of severity) INFO, WARNING, ERROR, and FATAL.

Very important: logging a message at the FATAL severity level causes the program to terminate (after the message is logged).

There is the special severity of DFATAL, which logs FATAL in debug mode, ERROR in normal mode.

Macro Definition Documentation

◆ assert

#define assert ( x ) DLOG_ASSERT(x)

◆ CHECK

#define CHECK ( condition )

Value:

LAZY_STREAM(LOG_STREAM(FATAL), !(condition)) \

<< "Check failed: " #condition ". "

LOG_STREAM

#define LOG_STREAM(severity)

Definition: cef_logging.h:286

LAZY_STREAM

#define LAZY_STREAM(stream, condition)

Definition: cef_logging.h:275

◆ CHECK_EQ

#define CHECK_EQ	(	val1,
		val2
	)	CHECK_OP(EQ, ==, val1, val2)

◆ CHECK_GE

#define CHECK_GE	(	val1,
		val2
	)	CHECK_OP(GE, >=, val1, val2)

◆ CHECK_GT

#define CHECK_GT	(	val1,
		val2
	)	CHECK_OP(GT, >, val1, val2)

◆ CHECK_LE

#define CHECK_LE	(	val1,
		val2
	)	CHECK_OP(LE, <=, val1, val2)

◆ CHECK_LT

#define CHECK_LT	(	val1,
		val2
	)	CHECK_OP(LT, <, val1, val2)

◆ CHECK_NE

#define CHECK_NE	(	val1,
		val2
	)	CHECK_OP(NE, !=, val1, val2)

◆ CHECK_OP

#define CHECK_OP	(	name,
		op,
		val1,
		val2
	)

Value:

  if (std::string* _result = cef::logging::Check##name##Impl( \
          (val1), (val2), #val1 " " #op " " #val2))           \
  cef::logging::LogMessage(__FILE__, __LINE__, _result).stream()

◆ COMPACT_GOOGLE_LOG_0

#define COMPACT_GOOGLE_LOG_0 COMPACT_GOOGLE_LOG_ERROR

◆ COMPACT_GOOGLE_LOG_DCHECK

#define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_FATAL

◆ COMPACT_GOOGLE_LOG_DFATAL

#define COMPACT_GOOGLE_LOG_DFATAL COMPACT_GOOGLE_LOG_EX_DFATAL(LogMessage)

◆ COMPACT_GOOGLE_LOG_ERROR

#define COMPACT_GOOGLE_LOG_ERROR COMPACT_GOOGLE_LOG_EX_ERROR(LogMessage)

◆ COMPACT_GOOGLE_LOG_EX_0

#define COMPACT_GOOGLE_LOG_EX_0	(	ClassName,
		...
	)	COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ##__VA_ARGS__)

◆ COMPACT_GOOGLE_LOG_EX_DCHECK

#define COMPACT_GOOGLE_LOG_EX_DCHECK	(	ClassName,
		...
	)	COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ##__VA_ARGS__)

◆ COMPACT_GOOGLE_LOG_EX_DFATAL

#define COMPACT_GOOGLE_LOG_EX_DFATAL	(	ClassName,
		...
	)

Value:

::cef::logging::ClassName(__FILE__, __LINE__, ::cef::logging::LOG_DFATAL, \

##__VA_ARGS__)

◆ COMPACT_GOOGLE_LOG_EX_ERROR

#define COMPACT_GOOGLE_LOG_EX_ERROR	(	ClassName,
		...
	)

Value:

::cef::logging::ClassName(__FILE__, __LINE__, ::cef::logging::LOG_ERROR, \

##__VA_ARGS__)

◆ COMPACT_GOOGLE_LOG_EX_FATAL

#define COMPACT_GOOGLE_LOG_EX_FATAL	(	ClassName,
		...
	)

Value:

::cef::logging::ClassName(__FILE__, __LINE__, ::cef::logging::LOG_FATAL, \

##__VA_ARGS__)

◆ COMPACT_GOOGLE_LOG_EX_INFO

#define COMPACT_GOOGLE_LOG_EX_INFO	(	ClassName,
		...
	)

Value:

::cef::logging::ClassName(__FILE__, __LINE__, ::cef::logging::LOG_INFO, \

##__VA_ARGS__)

◆ COMPACT_GOOGLE_LOG_EX_WARNING

#define COMPACT_GOOGLE_LOG_EX_WARNING	(	ClassName,
		...
	)

Value:

::cef::logging::ClassName(__FILE__, __LINE__, ::cef::logging::LOG_WARNING, \

##__VA_ARGS__)

◆ COMPACT_GOOGLE_LOG_FATAL

#define COMPACT_GOOGLE_LOG_FATAL COMPACT_GOOGLE_LOG_EX_FATAL(LogMessage)

◆ COMPACT_GOOGLE_LOG_INFO

#define COMPACT_GOOGLE_LOG_INFO COMPACT_GOOGLE_LOG_EX_INFO(LogMessage)

◆ COMPACT_GOOGLE_LOG_WARNING

#define COMPACT_GOOGLE_LOG_WARNING COMPACT_GOOGLE_LOG_EX_WARNING(LogMessage)

◆ DCHECK

#define DCHECK ( condition )

Value:

LAZY_STREAM(LOG_STREAM(DCHECK), DCHECK_IS_ON() && !(condition)) \

<< "Check failed: " #condition ". "

DCHECK_IS_ON

#define DCHECK_IS_ON()

Definition: cef_logging.h:458

DCHECK

#define DCHECK(condition)

Definition: cef_logging.h:532

◆ DCHECK_EQ

#define DCHECK_EQ	(	val1,
		val2
	)	DCHECK_OP(EQ, ==, val1, val2)

◆ DCHECK_GE

#define DCHECK_GE	(	val1,
		val2
	)	DCHECK_OP(GE, >=, val1, val2)

◆ DCHECK_GT

#define DCHECK_GT	(	val1,
		val2
	)	DCHECK_OP(GT, >, val1, val2)

◆ DCHECK_IS_ON

#define DCHECK_IS_ON ( ) 1

◆ DCHECK_LE

#define DCHECK_LE	(	val1,
		val2
	)	DCHECK_OP(LE, <=, val1, val2)

◆ DCHECK_LT

#define DCHECK_LT	(	val1,
		val2
	)	DCHECK_OP(LT, <, val1, val2)

◆ DCHECK_NE

#define DCHECK_NE	(	val1,
		val2
	)	DCHECK_OP(NE, !=, val1, val2)

◆ DCHECK_OP

#define DCHECK_OP	(	name,
		op,
		val1,
		val2
	)

Value:

  if (DCHECK_IS_ON())                                                      \
    if (std::string* _result = cef::logging::Check##name##Impl(            \
            (val1), (val2), #val1 " " #op " " #val2))                      \
  cef::logging::LogMessage(__FILE__, __LINE__, ::cef::logging::LOG_DCHECK, \
                           _result)                                        \
      .stream()

◆ DEFINE_CHECK_OP_IMPL

#define DEFINE_CHECK_OP_IMPL	(	name,
		op
	)

Value:

  template <class t1, class t2>                                              \
  inline std::string* Check##name##Impl(const t1& v1, const t2& v2,          \
                                        const char* names) {                 \
    if (v1 op v2)                                                            \
      return NULL;                                                           \
    else                                                                     \
      return MakeCheckOpString(v1, v2, names);                               \
  }                                                                          \
  inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \
    if (v1 op v2)                                                            \
      return NULL;                                                           \
    else                                                                     \
      return MakeCheckOpString(v1, v2, names);                               \
  }

◆ DLOG

#define DLOG ( severity ) LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))

◆ DLOG_ASSERT

#define DLOG_ASSERT ( condition ) LOG_ASSERT(condition)

◆ DLOG_IF

#define DLOG_IF	(	severity,
		condition
	)	LOG_IF(severity, condition)

◆ DLOG_IS_ON

#define DLOG_IS_ON ( severity ) LOG_IS_ON(severity)

◆ DPCHECK

#define DPCHECK ( condition )

Value:

LAZY_STREAM(PLOG_STREAM(DCHECK), DCHECK_IS_ON() && !(condition)) \

<< "Check failed: " #condition ". "

PLOG_STREAM

#define PLOG_STREAM(severity)

Definition: cef_logging.h:333

◆ DPLOG

#define DPLOG ( severity ) LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))

◆ DPLOG_IF

#define DPLOG_IF	(	severity,
		condition
	)	PLOG_IF(severity, condition)

◆ DVLOG

#define DVLOG ( verboselevel ) DVLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))

◆ DVLOG_IF

#define DVLOG_IF	(	verboselevel,
		condition
	)	VLOG_IF(verboselevel, condition)

◆ DVPLOG

#define DVPLOG ( verboselevel ) DVPLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))

◆ DVPLOG_IF

#define DVPLOG_IF	(	verboselevel,
		condition
	)	VPLOG_IF(verboselevel, condition)

◆ EAT_STREAM_PARAMETERS

#define EAT_STREAM_PARAMETERS true ? (void)0 : ::cef::logging::LogMessageVoidify() & LOG_STREAM(FATAL)

◆ ENABLE_DLOG

#define ENABLE_DLOG 1

◆ ERROR

#define ERROR 0

◆ LAZY_STREAM

#define LAZY_STREAM	(	stream,
		condition
	)	!(condition) ? (void)0 : ::cef::logging::LogMessageVoidify() & (stream)

◆ LOG

#define LOG ( severity ) LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity))

◆ LOG_ASSERT

#define LOG_ASSERT ( condition ) LOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". "

◆ LOG_IF

#define LOG_IF	(	severity,
		condition
	)	LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity) && (condition))

◆ LOG_IS_ON

#define LOG_IS_ON ( severity ) ((::cef::logging::LOG_##severity) >= ::cef::logging::GetMinLogLevel())

◆ LOG_STREAM

#define LOG_STREAM ( severity ) COMPACT_GOOGLE_LOG_##severity.stream()

◆ NOTIMPLEMENTED

#define NOTIMPLEMENTED ( ) LOG(ERROR) << NOTIMPLEMENTED_MSG

◆ NOTIMPLEMENTED_MSG

#define NOTIMPLEMENTED_MSG "NOT IMPLEMENTED"

◆ NOTIMPLEMENTED_POLICY

#define NOTIMPLEMENTED_POLICY 4

◆ NOTREACHED

#define NOTREACHED ( ) DCHECK(false)

◆ PCHECK

#define PCHECK ( condition )

Value:

LAZY_STREAM(PLOG_STREAM(FATAL), !(condition)) \

<< "Check failed: " #condition ". "

◆ PLOG

#define PLOG ( severity ) LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))

◆ PLOG_IF

#define PLOG_IF	(	severity,
		condition
	)	LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition))

◆ PLOG_STREAM

#define PLOG_STREAM ( severity )

Value:

  COMPACT_GOOGLE_LOG_EX_##severity(Win32ErrorLogMessage,                     \
                                   ::cef::logging::GetLastSystemErrorCode()) \
      .stream()

◆ SYSLOG

#define SYSLOG ( severity ) LOG(severity)

◆ SYSLOG_ASSERT

#define SYSLOG_ASSERT ( condition ) SYSLOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". "

◆ SYSLOG_IF

#define SYSLOG_IF	(	severity,
		condition
	)	LOG_IF(severity, condition)

◆ VLOG

#define VLOG ( verbose_level ) LAZY_STREAM(VLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level))

◆ VLOG_IF

#define VLOG_IF	(	verbose_level,
		condition
	)

Value:

LAZY_STREAM(VLOG_STREAM(verbose_level), \

VLOG_IS_ON(verbose_level) && (condition))

VLOG_IS_ON

#define VLOG_IS_ON(verboselevel)

Definition: cef_logging.h:270

VLOG_STREAM

#define VLOG_STREAM(verbose_level)

Definition: cef_logging.h:296

◆ VLOG_IS_ON

#define VLOG_IS_ON ( verboselevel ) ((verboselevel) <= ::cef::logging::GetVlogLevel(__FILE__))

◆ VLOG_STREAM

#define VLOG_STREAM ( verbose_level ) cef::logging::LogMessage(__FILE__, __LINE__, -verbose_level).stream()

◆ VPLOG

#define VPLOG ( verbose_level ) LAZY_STREAM(VPLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level))

◆ VPLOG_IF

#define VPLOG_IF	(	verbose_level,
		condition
	)

Value:

LAZY_STREAM(VPLOG_STREAM(verbose_level), \

VLOG_IS_ON(verbose_level) && (condition))

VPLOG_STREAM

#define VPLOG_STREAM(verbose_level)

Definition: cef_logging.h:307

◆ VPLOG_STREAM

#define VPLOG_STREAM ( verbose_level )

Value:

  cef::logging::Win32ErrorLogMessage(__FILE__, __LINE__, -verbose_level,       \
                                     ::cef::logging::GetLastSystemErrorCode()) \
      .stream()

Function Documentation

◆ operator<<() [1/2]

std::ostream& operator<<	(	std::ostream &	out,
		const std::wstring &	wstr
	)

inline

◆ operator<<() [2/2]

std::ostream& operator<<	(	std::ostream &	out,
		const wchar_t *	wstr
	)

Namespaces

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ assert

◆ CHECK

◆ CHECK_EQ

◆ CHECK_GE

◆ CHECK_GT

◆ CHECK_LE

◆ CHECK_LT

◆ CHECK_NE

◆ CHECK_OP

◆ COMPACT_GOOGLE_LOG_0

◆ COMPACT_GOOGLE_LOG_DCHECK

◆ COMPACT_GOOGLE_LOG_DFATAL

◆ COMPACT_GOOGLE_LOG_ERROR

◆ COMPACT_GOOGLE_LOG_EX_0

◆ COMPACT_GOOGLE_LOG_EX_DCHECK

◆ COMPACT_GOOGLE_LOG_EX_DFATAL

◆ COMPACT_GOOGLE_LOG_EX_ERROR

◆ COMPACT_GOOGLE_LOG_EX_FATAL

◆ COMPACT_GOOGLE_LOG_EX_INFO

◆ COMPACT_GOOGLE_LOG_EX_WARNING

◆ COMPACT_GOOGLE_LOG_FATAL

◆ COMPACT_GOOGLE_LOG_INFO

◆ COMPACT_GOOGLE_LOG_WARNING

◆ DCHECK

◆ DCHECK_EQ

◆ DCHECK_GE

◆ DCHECK_GT

◆ DCHECK_IS_ON

◆ DCHECK_LE

◆ DCHECK_LT

◆ DCHECK_NE

◆ DCHECK_OP

◆ DEFINE_CHECK_OP_IMPL

◆ DLOG

◆ DLOG_ASSERT

◆ DLOG_IF

◆ DLOG_IS_ON

◆ DPCHECK

◆ DPLOG

◆ DPLOG_IF

◆ DVLOG

◆ DVLOG_IF

◆ DVPLOG

◆ DVPLOG_IF

◆ EAT_STREAM_PARAMETERS

◆ ENABLE_DLOG

◆ ERROR

◆ LAZY_STREAM

◆ LOG

◆ LOG_ASSERT

◆ LOG_IF

◆ LOG_IS_ON

◆ LOG_STREAM

◆ NOTIMPLEMENTED

◆ NOTIMPLEMENTED_MSG

◆ NOTIMPLEMENTED_POLICY

◆ NOTREACHED

◆ PCHECK

◆ PLOG

◆ PLOG_IF

◆ PLOG_STREAM

◆ SYSLOG

◆ SYSLOG_ASSERT

◆ SYSLOG_IF

◆ VLOG

◆ VLOG_IF

◆ VLOG_IS_ON

◆ VLOG_STREAM

◆ VPLOG

◆ VPLOG_IF

◆ VPLOG_STREAM

Function Documentation

◆ operator<<() [1/2]

◆ operator<<() [2/2]