在CEF框架中，有很多的宏定义，有必要拿出来说一说，在阅读源码的时候更好的理解。

CHECK & DCHECK

CEF框架中，在很多代码中都用到了CHECK宏和DCHECK宏，这两个宏的用途是一样的，都是对一些变量或者质量做判断，一个用于release版本，一个用于debug版本。

这两个宏定义的主要作用就是用于做某些条件的断言，或者说判断，如果为空或者失败，则记录日志。

下面就一步一步的看：

在这两个宏里面就涉及到了CEF的日志框架，所以在这里也一起简单提一下。

DCHECK(platform_delegate_);

#define CHECK(condition)                       \LAZY_STREAM(LOG_STREAM(FATAL), !(condition)) \<< "Check failed: " #condition ". "#define PCHECK(condition)                       \LAZY_STREAM(PLOG_STREAM(FATAL), !(condition)) \<< "Check failed: " #condition ". "

#define DCHECK(condition)                                         \LAZY_STREAM(LOG_STREAM(DCHECK), DCHECK_IS_ON() && !(condition)) \<< "Check failed: " #condition ". "

DCHECK_IS_ON

用于判断是否打开DCHECK

#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
#define DCHECK_IS_ON() false
#else
#define DCHECK_IS_ON() true
#endif

在DCHECK和CHECK中的两个宏定义在依次展开。

日志相关

首先，cef框架定义了几个日志等级，就是标准的日志框架中包含的几个等级。

• 日志等级

  • LOG_VERBOSE

  • LOG_INFO

  • LOG_WARNING

  • LOG_ERROR

  • LOG_FATAL

  • LOG_NUM_SEVERITIES

    typedef int LogSeverity;
    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_STREAM宏的定义为：

  // We use the preprocessor's merging operator, "##", so that, e.g.,
  // LOG(INFO) becomes the token COMPACT_GOOGLE_LOG_INFO.  There's some funny
  // subtle difference between ostream member streaming functions (e.g.,
  // ostream::operator<<(int) and ostream non-member streaming functions
  // (e.g., ::operator<<(ostream&, string&): it turns out that it's
  // impossible to stream something like a string directly to an unnamed
  // ostream. We employ a neat hack by calling the stream() member
  // function of LogMessage which seems to avoid the problem.
  #define LOG_STREAM(severity) COMPACT_GOOGLE_LOG_##severity.stream()
  

在LOG_STREAM(FATAL)中，FATAL会替换掉##severity(merging operator)，LOG_STREAM(FATAL)展开为COMPACT_GOOGLE_LOG_FATAL。

对应了几个对应的日志宏定义：

#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 COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_FATAL

COMPACT_GOOGLE_LOG_FATAL

COMPACT_GOOGLE_LOG_FATAL对应的宏定义为：

// 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, ...)                        \::cef::logging::ClassName(__FILE__, __LINE__, ::cef::logging::LOG_INFO, \##__VA_ARGS__)
#define COMPACT_GOOGLE_LOG_EX_WARNING(ClassName, ...)                        \::cef::logging::ClassName(__FILE__, __LINE__, ::cef::logging::LOG_WARNING, \##__VA_ARGS__)
#define COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ...)                        \::cef::logging::ClassName(__FILE__, __LINE__, ::cef::logging::LOG_ERROR, \##__VA_ARGS__)
#define COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ...)                        \::cef::logging::ClassName(__FILE__, __LINE__, ::cef::logging::LOG_FATAL, \##__VA_ARGS__)
#define COMPACT_GOOGLE_LOG_EX_DFATAL(ClassName, ...)                        \::cef::logging::ClassName(__FILE__, __LINE__, ::cef::logging::LOG_DFATAL, \##__VA_ARGS__)

LogMessage

ClassName就对应了COMPACT_GOOGLE_LOG_EX_DFATAL(LogMessage)中的LogMessage，这个类就是cef框架中的日志处理类了：

// This class more or less represents a particular log message.  You
// create an instance of LogMessage and then stream stuff to it.
// When you finish streaming to it, ~LogMessage is called and the
// full message gets streamed to the appropriate destination.
//
// You shouldn't actually use LogMessage's constructor to log things,
// though.  You should use the LOG() macro (and variants thereof)
// above.
class LogMessage {public:// Used for LOG(severity).LogMessage(const char* file, int line, LogSeverity severity);// Used for CHECK_EQ(), etc. Takes ownership of the given string.// Implied severity = LOG_FATAL.LogMessage(const char* file, int line, std::string* result);// Used for DCHECK_EQ(), etc. Takes ownership of the given string.LogMessage(const char* file,int line,LogSeverity severity,std::string* result);LogMessage(const LogMessage&) = delete;LogMessage& operator=(const LogMessage&) = delete;~LogMessage();std::ostream& stream() { return stream_; }private:LogSeverity severity_;std::ostringstream stream_;// The file and line information passed in to the constructor.const char* file_;const int line_;#if defined(OS_WIN)// Stores the current value of GetLastError in the constructor and restores// it in the destructor by calling SetLastError.// This is useful since the LogMessage class uses a lot of Win32 calls// that will lose the value of GLE and the code that called the log function// will have lost the thread error value when the log call returns.class SaveLastError {public:SaveLastError();~SaveLastError();unsigned long get_error() const { return last_error_; }protected:unsigned long last_error_;};SaveLastError last_error_;
#endif
};

LOG_STREAM(FATAL)

也就是说，LOG_STREAM(FATAL)的意思就是把内容写到日志文件里。

LAZY_STREAM

在CHECK和DCHECK宏的最外面，还有一个LAZY_STREAM宏定义。

// Helper macro which avoids evaluating the arguments to a stream if
// the condition doesn't hold.
#define LAZY_STREAM(stream, condition) \!(condition) ? (void)0 : ::cef::logging::LogMessageVoidify() & (stream)

stream就是上面提到的日志流，这个宏定义的意思就是如果输入的condition为空(false)，则返回0(false)；否则则调用LogMessageVoidify & stream

LogMessageVoidify

这个类没什么实际作用，主要作用是抑制宏定义中condition为单独变量时的编译警告。

// This class is used to explicitly ignore values in the conditional
// logging macros.  This avoids compiler warnings like "value computed
// is not used" and "statement has no effect".
class LogMessageVoidify {public:LogMessageVoidify() {}// This has to be an operator with a precedence lower than << but// higher than ?:void operator&(std::ostream&) {}
};