Integrate ETW with VLOG logging.

base/logging.cc

 // Copyright (c) 2010 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.
 
 #include "base/logging.h"
 
 #if defined(OS_WIN)
 #include <io.h>
 #include <windows.h>
 typedef HANDLE FileHandle;
@@ skipping 333 matching lines @@
   g_enable_dcheck =
       command_line->HasSwitch(switches::kEnableDCHECK);
   delete g_vlog_info;
   g_vlog_info = NULL;
   // Don't bother initializing g_vlog_info unless we use one of the
   // vlog switches.
   if (command_line->HasSwitch(switches::kV) ||
       command_line->HasSwitch(switches::kVModule)) {
     g_vlog_info =
         new VlogInfo(command_line->GetSwitchValueASCII(switches::kV),
-                     command_line->GetSwitchValueASCII(switches::kVModule));
+                     command_line->GetSwitchValueASCII(switches::kVModule),
+                     &min_log_level);
   }
 
   LoggingLock::Init(lock_log, new_log_file);
 
   LoggingLock logging_lock;
 
   if (log_file) {
     // calling InitLogging twice or after some log call has already opened the
     // default log file will re-initialize to the new options
     CloseFile(log_file);
@@ skipping 17 matching lines @@
 }
 
 void SetMinLogLevel(int level) {
   min_log_level = std::min(LOG_ERROR_REPORT, level);
 }
 
 int GetMinLogLevel() {
   return min_log_level;
 }
 
+int GetVlogVerbosity() {
+  return std::max(-1, LOG_INFO - GetMinLogLevel());
+}
+
 int GetVlogLevelHelper(const char* file, size_t N) {
   DCHECK_GT(N, 0U);
   return g_vlog_info ?
       g_vlog_info->GetVlogLevel(base::StringPiece(file, N - 1)) :
-      VlogInfo::kDefaultVlogLevel;
+      GetVlogVerbosity();
 }
 
 void SetLogItems(bool enable_process_id, bool enable_thread_id,
                  bool enable_timestamp, bool enable_tickcount) {
   log_process_id = enable_process_id;
   log_thread_id = enable_thread_id;
   log_timestamp = enable_timestamp;
   log_tickcount = enable_tickcount;
 }
 
@@ skipping 94 matching lines @@
 LogMessage::SaveLastError::SaveLastError() : last_error_(::GetLastError()) {
 }
 
 LogMessage::SaveLastError::~SaveLastError() {
   ::SetLastError(last_error_);
 }
 #endif  // defined(OS_WIN)
 
 LogMessage::LogMessage(const char* file, int line, LogSeverity severity,
                        int ctr)
-    : severity_(severity) {
+    : severity_(severity), file_(file), line_(line) {
   Init(file, line);
 }
 
 LogMessage::LogMessage(const char* file, int line, const CheckOpString& result)
-    : severity_(LOG_FATAL) {
+    : severity_(LOG_FATAL), file_(file), line_(line) {
   Init(file, line);
   stream_ << "Check failed: " << (*result.str_);
 }
 
 LogMessage::LogMessage(const char* file, int line, LogSeverity severity,
                        const CheckOpString& result)
-    : severity_(severity) {
+    : severity_(severity), file_(file), line_(line) {
   Init(file, line);
   stream_ << "Check failed: " << (*result.str_);
 }
 
 LogMessage::LogMessage(const char* file, int line)
-     : severity_(LOG_INFO) {
+    : severity_(LOG_INFO), file_(file), line_(line) {
   Init(file, line);
 }
 
 LogMessage::LogMessage(const char* file, int line, LogSeverity severity)
-    : severity_(severity) {
+    : severity_(severity), file_(file), line_(line) {
   Init(file, line);
 }
 
 // writes the common header info to the stream
 void LogMessage::Init(const char* file, int line) {
   base::StringPiece filename(file);
   size_t last_slash_pos = filename.find_last_of("\\/");
   if (last_slash_pos != base::StringPiece::npos)
     filename.remove_prefix(last_slash_pos + 1);
 
@@ skipping 17 matching lines @@
             << std::setw(2) << 1 + tm_time->tm_mon
             << std::setw(2) << tm_time->tm_mday
             << '/'
             << std::setw(2) << tm_time->tm_hour
             << std::setw(2) << tm_time->tm_min
             << std::setw(2) << tm_time->tm_sec
             << ':';
   }
   if (log_tickcount)
     stream_ << TickCount() << ':';
-  stream_ << log_severity_names[severity_] << ":" << filename <<
-             "(" << line << ")] ";
+  if (severity_ >= 0)
+    stream_ << log_severity_names[severity_];
+  else
+    stream_ << "VERBOSE" << -severity_;
+
+  stream_ << ":" << file << "(" << line << ")] ";
 
   message_start_ = stream_.tellp();
 }
 
 LogMessage::~LogMessage() {
   // The macros in logging.h should already avoid creating LogMessages
   // when this holds, but it's possible that users create LogMessages
   // directly (e.g., using LOG_STREAM() directly).
   if (severity_ < min_log_level)
     return;
 
 #ifndef NDEBUG
   if (severity_ == LOG_FATAL) {
     // Include a stack trace on a fatal.
     base::debug::StackTrace trace;
     stream_ << std::endl;  // Newline to separate from log message.
     trace.OutputToStream(&stream_);
   }
 #endif
   stream_ << std::endl;
   std::string str_newline(stream_.str());
 
   // Give any log message handler first dibs on the message.
-  if (log_message_handler && log_message_handler(severity_, str_newline))
+  if (log_message_handler && log_message_handler(severity_, file_, line_,
+          message_start_, str_newline)) {
+    // The handler took care of it, no further processing.
     return;
+  }
 
   if (logging_destination == LOG_ONLY_TO_SYSTEM_DEBUG_LOG ||
       logging_destination == LOG_TO_BOTH_FILE_AND_SYSTEM_DEBUG_LOG) {
 #if defined(OS_WIN)
     OutputDebugStringA(str_newline.c_str());
 #endif
     fprintf(stderr, "%s", str_newline.c_str());
     fflush(stderr);
   } else if (severity_ >= kAlwaysPrintErrorLevel) {
     // When we're only outputting to a log file, above a certain log level, we
@@ skipping 189 matching lines @@
 
   if (level == LOG_FATAL)
     base::debug::BreakDebugger();
 }
 
 }  // namespace logging
 
 std::ostream& operator<<(std::ostream& out, const wchar_t* wstr) {
   return out << WideToUTF8(std::wstring(wstr));
 }