Remove dependency on Chromium in diagnostic_logging.h.

overrides/webrtc/base/logging.cc

 /*
  *  Copyright 2012 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-// IMPORTANT
-// Since this file includes Chromium source files, it must not include
-// logging.h since logging.h defines some of the same macros as Chrome does
-// and we'll run into conflict.
-
 #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
 #include <CoreServices/CoreServices.h>
 #endif  // OS_MACOSX
 
 #include <algorithm>
 #include <iomanip>
 
 #include "base/atomicops.h"
+#include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/threading/platform_thread.h"
 #include "third_party/webrtc/base/ipaddress.h"
 #include "third_party/webrtc/base/stream.h"
 #include "third_party/webrtc/base/stringencode.h"
 #include "third_party/webrtc/base/stringutils.h"
 #include "third_party/webrtc/base/timeutils.h"
 #include "third_party/webrtc/overrides/webrtc/base/diagnostic_logging.h"
+#include "third_party/webrtc/overrides/webrtc/base/logging.h"
 
 // From this file we can't use VLOG since it expands into usage of the __FILE__
 // macro (for correct filtering). The actual logging call from DIAGNOSTIC_LOG in
 // ~DiagnosticLogMessage. Note that the second parameter to the LAZY_STREAM
 // macro is true since the filter check has already been done for
 // DIAGNOSTIC_LOG.
-#define LOG_LAZY_STREAM_DIRECT(file_name, line_number, sev) \
+#define LOG_LAZY_STREAM_DIRECT(file_name, line_number, sev)   \
   RTC_LAZY_STREAM(logging::LogMessage(file_name, line_number, \
                                   sev).stream(), true)
 
 namespace rtc {
 
 void (*g_logging_delegate_function)(const std::string&) = NULL;
 void (*g_extra_logging_init_function)(
     void (*logging_delegate_function)(const std::string&)) = NULL;
 #ifndef NDEBUG
 static_assert(sizeof(base::subtle::Atomic32) == sizeof(base::PlatformThreadId),
@@ skipping 23 matching lines @@
 
   char buffer[16];
   base::snprintf(buffer, sizeof(buffer), "0x%08x", err);
   return buffer;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Log helper functions
 /////////////////////////////////////////////////////////////////////////////
 
+inline int WebRtcSevToChromeSev(LoggingSeverity sev) {
+  switch (sev) {
+    case LS_ERROR:
+      return ::logging::LOG_ERROR;
+    case LS_WARNING:
+      return ::logging::LOG_WARNING;
+    case LS_INFO:
+      return ::logging::LOG_INFO;
+    case LS_VERBOSE:
+    case LS_SENSITIVE:
+      return ::logging::LOG_VERBOSE;
+    default:
+      RTC_NOTREACHED();
+      return ::logging::LOG_FATAL;
+  }
+}
+
+inline int WebRtcVerbosityLevel(LoggingSeverity sev) {
+  switch (sev) {
+    case LS_ERROR:
+      return -2;
+    case LS_WARNING:
+      return -1;
+    case LS_INFO:  // We treat 'info' and 'verbose' as the same verbosity level.
+    case LS_VERBOSE:
+      return 1;
+    case LS_SENSITIVE:
+      return 2;
+    default:
+      RTC_NOTREACHED();
+      return 0;
+  }
+}
+
 // Generates extra information for LOG_E.
 static std::string GenerateExtra(LogErrorContext err_ctx,
                                  int err,
                                  const char* module) {
   if (err_ctx != ERRCTX_NONE) {
     std::ostringstream tmp;
     tmp << ": ";
     tmp << "[0x" << std::setfill('0') << std::hex << std::setw(8) << err << "]";
     switch (err_ctx) {
       case ERRCTX_ERRNO:
@@ skipping 36 matching lines @@
         break;
     }
     return tmp.str();
   }
   return "";
 }
 
 DiagnosticLogMessage::DiagnosticLogMessage(const char* file,
                                            int line,
                                            LoggingSeverity severity,
-                                           bool log_to_chrome,
                                            LogErrorContext err_ctx,
                                            int err)
     : file_name_(file),
       line_(line),
       severity_(severity),
-      log_to_chrome_(log_to_chrome) {
+      log_to_chrome_(CheckVlogIsOnHelper(severity, file, strlen(file) + 1)) {
   extra_ = GenerateExtra(err_ctx, err, NULL);
 }
 
 DiagnosticLogMessage::DiagnosticLogMessage(const char* file,
                                            int line,
                                            LoggingSeverity severity,
-                                           bool log_to_chrome,
                                            LogErrorContext err_ctx,
                                            int err,
                                            const char* module)
     : file_name_(file),
       line_(line),
       severity_(severity),
-      log_to_chrome_(log_to_chrome) {
+      log_to_chrome_(CheckVlogIsOnHelper(severity, file, strlen(file) + 1)) {
   extra_ = GenerateExtra(err_ctx, err, module);
 }
 
 DiagnosticLogMessage::~DiagnosticLogMessage() {
   const bool call_delegate =
       g_logging_delegate_function && severity_ <= LS_INFO;
 
   if (call_delegate || log_to_chrome_) {
     print_stream_ << extra_;
     const std::string& str = print_stream_.str();
@@ skipping 10 matching lines @@
 
 // static
 void LogMessage::LogToDebug(int min_sev) {
   logging::SetMinLogLevel(min_sev);
 }
 
 // Note: this function is a copy from the overriden libjingle implementation.
 void LogMultiline(LoggingSeverity level, const char* label, bool input,
                   const void* data, size_t len, bool hex_mode,
                   LogMultilineState* state) {
+  // TODO(grunell): This will not do the expected verbosity level checking. We
+  // need a macro for the multiline logging.

[tommi, 2015/09/15 15:06:29]

is this worthy of a bug?

[Henrik Grunell WebRTC, 2015/09/17 07:50:17]

Yes. https://code.google.com/p/webrtc/issues/detail?id=5011

   if (!LOG_RTC_CHECK_LEVEL_V(level))
     return;
 
   const char * direction = (input ? " << " : " >> ");
 
   // NULL data means to flush our count of unprintable characters.
   if (!data) {
     if (state && state->unprintable_count_[input]) {
       LOG_V(level) << label << direction << "## "
                    << state->unprintable_count_[input]
@@ skipping 127 matching lines @@
     g_extra_logging_init_function(delegate);
 }
 
 void SetExtraLoggingInit(
     void (*function)(void (*delegate)(const std::string&))) {
   RTC_CHECK(function);
   RTC_CHECK(!g_extra_logging_init_function);
   g_extra_logging_init_function = function;
 }
 
+bool CheckVlogIsOnHelper(
+    rtc::LoggingSeverity severity, const char* file, size_t N) {
+  return rtc::WebRtcVerbosityLevel(severity) <=
+         ::logging::GetVlogLevelHelper(file, N);
+}
+
 }  // namespace rtc