Disable base/logging.h stderr logs by default for webrtc/ tests.

webrtc/base/logging.cc

 /*
  *  Copyright 2004 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.
  */
 
@@ skipping 26 matching lines @@
 #include <vector>
 
 #include "webrtc/base/logging.h"
 #include "webrtc/base/platform_thread.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/timeutils.h"
 
 namespace rtc {
+namespace {
+
+// Return the filename portion of the string (that following the last slash).
+const char* FilenameFromPath(const char* file) {
+  const char* end1 = ::strrchr(file, '/');
+  const char* end2 = ::strrchr(file, '\\');
+  if (!end1 && !end2)
+    return file;
+  else
+    return (end1 > end2) ? end1 + 1 : end2 + 1;
+}
+
+}  // namespace
 
 /////////////////////////////////////////////////////////////////////////////
 // Constant Labels
 /////////////////////////////////////////////////////////////////////////////
 
-const char * FindLabel(int value, const ConstantLabel entries[]) {
+const char* FindLabel(int value, const ConstantLabel entries[]) {
   for (int i = 0; entries[i].label; ++i) {
     if (value == entries[i].value) {
       return entries[i].label;
     }
   }
   return 0;
 }
 
-std::string ErrorName(int err, const ConstantLabel * err_table) {
+std::string ErrorName(int err, const ConstantLabel* err_table) {
   if (err == 0)
     return "No error";
 
   if (err_table != 0) {
-    if (const char * value = FindLabel(err, err_table))
+    if (const char* value = FindLabel(err, err_table))
       return value;
   }
 
   char buffer[16];
   snprintf(buffer, sizeof(buffer), "0x%08x", err);
   return buffer;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // LogMessage
 /////////////////////////////////////////////////////////////////////////////
 
 // By default, release builds don't log, debug builds at info level
 #if _DEBUG
 LoggingSeverity LogMessage::min_sev_ = LS_INFO;
 LoggingSeverity LogMessage::dbg_sev_ = LS_INFO;
 #else  // !_DEBUG
 LoggingSeverity LogMessage::min_sev_ = LS_NONE;
 LoggingSeverity LogMessage::dbg_sev_ = LS_NONE;
 #endif  // !_DEBUG
+bool LogMessage::log_to_stderr_ = true;
 
 // Global lock for log subsystem, only needed to serialize access to streams_.
 CriticalSection LogMessage::crit_;
 
 // The list of logging streams currently configured.
 // Note: we explicitly do not clean this up, because of the uncertain ordering
 // of destructors at program exit.  Let the person who sets the stream trigger
 // cleanup by setting to NULL, or let it leak (safe at program exit).
 LogMessage::StreamList LogMessage::streams_ GUARDED_BY(LogMessage::crit_);
 
@@ skipping 12 matching lines @@
     print_stream_ << "[" << std::setfill('0') << std::setw(3) << (time / 1000)
                   << ":" << std::setw(3) << (time % 1000) << std::setfill(' ')
                   << "] ";
   }
 
   if (thread_) {
     PlatformThreadId id = CurrentThreadId();
     print_stream_ << "[" << std::dec << id << "] ";
   }
 
+  print_stream_ << "(" << FilenameFromPath(file)  << ":" << line << "): ";
+
   if (err_ctx != ERRCTX_NONE) {
     std::ostringstream tmp;
     tmp << "[0x" << std::setfill('0') << std::hex << std::setw(8) << err << "]";
     switch (err_ctx) {
       case ERRCTX_ERRNO:
         tmp << " " << strerror(err);
         break;
 #if WEBRTC_WIN
       case ERRCTX_HRESULT: {
         char msgbuf[256];
@@ skipping 78 matching lines @@
 void LogMessage::LogTimestamps(bool on) {
   timestamp_ = on;
 }
 
 void LogMessage::LogToDebug(LoggingSeverity min_sev) {
   dbg_sev_ = min_sev;
   CritScope cs(&crit_);
   UpdateMinLogSeverity();
 }
 
+void LogMessage::SetLogToStderr(bool log_to_stderr) {
+  log_to_stderr_ = log_to_stderr;

[Andrew MacDonald, 2015/09/05 05:32:18]

My intuition is to protect this with the mutex, but the dbg_sev_ write on l.228
isn't. I'm going on faith that it's handled correctly; either both or neither
should be guarded.

[hlundin-webrtc, 2015/09/06 10:10:44]

Acknowledged.

+}
+
 int LogMessage::GetLogToStream(LogSink* stream) {
   CritScope cs(&crit_);
   LoggingSeverity sev = LS_NONE;
   for (StreamList::iterator it = streams_.begin(); it != streams_.end(); ++it) {
     if (!stream || stream == it->first) {
       sev = std::min(sev, it->second);
     }
   }
   return sev;
 }
@@ skipping 80 matching lines @@
 void LogMessage::UpdateMinLogSeverity() EXCLUSIVE_LOCKS_REQUIRED(crit_) {
   LoggingSeverity min_sev = dbg_sev_;
   for (StreamList::iterator it = streams_.begin(); it != streams_.end(); ++it) {
     min_sev = std::min(dbg_sev_, it->second);
   }
   min_sev_ = min_sev;
 }
 
 void LogMessage::OutputToDebug(const std::string& str,
                                LoggingSeverity severity) {
-  bool log_to_stderr = true;
+  bool log_to_stderr = log_to_stderr_;
 #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) && (!defined(DEBUG) || defined(NDEBUG))
   // On the Mac, all stderr output goes to the Console log and causes clutter.
   // So in opt builds, don't log to stderr unless the user specifically sets
   // a preference to do so.
   CFStringRef key = CFStringCreateWithCString(kCFAllocatorDefault,
                                               "logToStdErr",
                                               kCFStringEncodingUTF8);
   CFStringRef domain = CFBundleGetIdentifier(CFBundleGetMainBundle());
   if (key != NULL && domain != NULL) {
     Boolean exists_and_is_valid;
@@ skipping 194 matching lines @@
   }
 
   if (state) {
     state->unprintable_count_[input] = consecutive_unprintable;
   }
 }
 
 //////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc