Move logging CriticalSection into implementation.

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 19 matching lines @@
 static const char kLibjingle[] = "libjingle";
 
 #include <time.h>
 #include <limits.h>
 
 #include <algorithm>
 #include <iomanip>
 #include <ostream>
 #include <vector>
 
+#include "webrtc/base/criticalsection.h"
 #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 {
 
@@ skipping 43 matching lines @@
 // 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;
 
+namespace {
 // Global lock for log subsystem, only needed to serialize access to streams_.
-CriticalSection LogMessage::crit_;
+CriticalSection g_log_crit;
+}  // namespace
 
 // 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_);
+LogMessage::StreamList LogMessage::streams_ GUARDED_BY(g_log_crit);
 
 // Boolean options default to false (0)
 bool LogMessage::thread_, LogMessage::timestamp_;
 
-LogMessage::LogMessage(const char* file, int line, LoggingSeverity sev,
-                       LogErrorContext err_ctx, int err, const char* module)
-    : severity_(sev),
-      tag_(kLibjingle),
-      warn_slow_logs_delay_(WARN_SLOW_LOGS_DELAY) {
+LogMessage::LogMessage(const char* file,
+                       int line,
+                       LoggingSeverity sev,
+                       LogErrorContext err_ctx,
+                       int err,
+                       const char* module)
+    : severity_(sev), tag_(kLibjingle) {
   if (timestamp_) {
     uint32_t time = TimeSince(LogStartTime());
     // Also ensure WallClockStartTime is initialized, so that it matches
     // LogStartTime.
     WallClockStartTime();
     print_stream_ << "[" << std::setfill('0') << std::setw(3) << (time / 1000)
                   << ":" << std::setw(3) << (time % 1000) << std::setfill(' ')
                   << "] ";
   }
 
@@ skipping 60 matching lines @@
 LogMessage::~LogMessage() {
   if (!extra_.empty())
     print_stream_ << " : " << extra_;
   print_stream_ << std::endl;
 
   const std::string& str = print_stream_.str();
   if (severity_ >= dbg_sev_) {
     OutputToDebug(str, severity_, tag_);
   }
 
-  uint32_t before = Time();
-  // Must lock streams_ before accessing
-  CritScope cs(&crit_);
-  for (StreamList::iterator it = streams_.begin(); it != streams_.end(); ++it) {
-    if (severity_ >= it->second) {
-      it->first->OnLogMessage(str);
+  CritScope cs(&g_log_crit);
+  for (auto& kv : streams_) {
+    if (severity_ >= kv.second) {
+      kv.first->OnLogMessage(str);
     }
   }
-  uint32_t delay = TimeSince(before);
-  if (delay >= warn_slow_logs_delay_) {
-    rtc::LogMessage slow_log_warning(__FILE__, __LINE__, LS_WARNING);
-    // If our warning is slow, we don't want to warn about it, because
-    // that would lead to inifinite recursion.  So, give a really big
-    // number for the delay threshold.
-    slow_log_warning.warn_slow_logs_delay_ = UINT_MAX;
-    slow_log_warning.stream() << "Slow log: took " << delay << "ms to write "
-                              << str.size() << " bytes.";
-  }
 }
 
 uint32_t LogMessage::LogStartTime() {
   static const uint32_t g_start = Time();
   return g_start;
 }
 
 uint32_t LogMessage::WallClockStartTime() {
   static const uint32_t g_start_wallclock = time(NULL);
   return g_start_wallclock;
 }
 
 void LogMessage::LogThreads(bool on) {
   thread_ = on;
 }
 
 void LogMessage::LogTimestamps(bool on) {
   timestamp_ = on;
 }
 
 void LogMessage::LogToDebug(LoggingSeverity min_sev) {
   dbg_sev_ = min_sev;
-  CritScope cs(&crit_);
+  CritScope cs(&g_log_crit);
   UpdateMinLogSeverity();
 }
 
 void LogMessage::SetLogToStderr(bool log_to_stderr) {
   log_to_stderr_ = log_to_stderr;
 }
 
 int LogMessage::GetLogToStream(LogSink* stream) {
-  CritScope cs(&crit_);
+  CritScope cs(&g_log_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);
+  for (auto& kv : streams_) {
+    if (!stream || stream == kv.first) {
+      sev = std::min(sev, kv.second);
     }
   }
   return sev;
 }
 
 void LogMessage::AddLogToStream(LogSink* stream, LoggingSeverity min_sev) {
-  CritScope cs(&crit_);
+  CritScope cs(&g_log_crit);
   streams_.push_back(std::make_pair(stream, min_sev));
   UpdateMinLogSeverity();
 }
 
 void LogMessage::RemoveLogToStream(LogSink* stream) {
-  CritScope cs(&crit_);
+  CritScope cs(&g_log_crit);
   for (StreamList::iterator it = streams_.begin(); it != streams_.end(); ++it) {
     if (stream == it->first) {
       streams_.erase(it);
       break;
     }
   }
   UpdateMinLogSeverity();
 }
 
 void LogMessage::ConfigureLogging(const char* params) {
@@ skipping 51 matching lines @@
     }
     if (!success) {
       ::AllocConsole();
     }
   }
 #endif  // WEBRTC_WIN
 
   LogToDebug(debug_level);
 }
 
-void LogMessage::UpdateMinLogSeverity() EXCLUSIVE_LOCKS_REQUIRED(crit_) {
+void LogMessage::UpdateMinLogSeverity() EXCLUSIVE_LOCKS_REQUIRED(g_log_crit) {
   LoggingSeverity min_sev = dbg_sev_;
-  for (StreamList::iterator it = streams_.begin(); it != streams_.end(); ++it) {
-    min_sev = std::min(dbg_sev_, it->second);
+  for (auto& kv : streams_) {
+    min_sev = std::min(dbg_sev_, kv.second);
   }
   min_sev_ = min_sev;
 }
 
 void LogMessage::OutputToDebug(const std::string& str,
                                LoggingSeverity severity,
                                const std::string& tag) {
   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.
@@ skipping 202 matching lines @@
   }
 
   if (state) {
     state->unprintable_count_[input] = consecutive_unprintable;
   }
 }
 
 //////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc