Move webrtc/{base => rtc_base}

webrtc/base/logging.cc

Index: webrtc/base/logging.cc
diff --git a/webrtc/base/logging.cc b/webrtc/base/logging.cc
deleted file mode 100644
index 25f85c96a7c03c7b2e406f4441bd0f3a2f3a7965..0000000000000000000000000000000000000000
--- a/webrtc/base/logging.cc
+++ /dev/null
@@ -1,561 +0,0 @@
-/*
- *  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.
- */
-
-#if defined(WEBRTC_WIN)
-#if !defined(WIN32_LEAN_AND_MEAN)
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#if _MSC_VER < 1900
-#define snprintf _snprintf
-#endif
-#undef ERROR  // wingdi.h
-#endif
-
-#if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
-#include <CoreServices/CoreServices.h>
-#elif defined(WEBRTC_ANDROID)
-#include <android/log.h>
-// Android has a 1024 limit on log inputs. We use 60 chars as an
-// approx for the header/tag portion.
-// See android/system/core/liblog/logd_write.c
-static const int kMaxLogLineSize = 1024 - 60;
-#endif  // WEBRTC_MAC && !defined(WEBRTC_IOS) || WEBRTC_ANDROID
-
-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/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[]) {
-  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) {
-  if (err == 0)
-    return "No error";
-
-  if (err_table != 0) {
-    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 !defined(NDEBUG)
-LoggingSeverity LogMessage::min_sev_ = LS_INFO;
-LoggingSeverity LogMessage::dbg_sev_ = LS_INFO;
-#else
-LoggingSeverity LogMessage::min_sev_ = LS_NONE;
-LoggingSeverity LogMessage::dbg_sev_ = LS_NONE;
-#endif
-bool LogMessage::log_to_stderr_ = true;
-
-namespace {
-// Global lock for log subsystem, only needed to serialize access to streams_.
-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(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) {
-  if (timestamp_) {
-    // Use SystemTimeMillis so that even if tests use fake clocks, the timestamp
-    // in log messages represents the real system time.
-    int64_t time = TimeDiff(SystemTimeMillis(), 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(' ')
-                  << "] ";
-  }
-
-  if (thread_) {
-    PlatformThreadId id = CurrentThreadId();
-    print_stream_ << "[" << std::dec << id << "] ";
-  }
-
-  if (file != nullptr)
-    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;
-#ifdef WEBRTC_WIN
-      case ERRCTX_HRESULT: {
-        char msgbuf[256];
-        DWORD flags = FORMAT_MESSAGE_FROM_SYSTEM;
-        HMODULE hmod = GetModuleHandleA(module);
-        if (hmod)
-          flags |= FORMAT_MESSAGE_FROM_HMODULE;
-        if (DWORD len = FormatMessageA(
-                flags, hmod, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                msgbuf, sizeof(msgbuf) / sizeof(msgbuf[0]), nullptr)) {
-          while ((len > 0) &&
-              isspace(static_cast<unsigned char>(msgbuf[len-1]))) {
-            msgbuf[--len] = 0;
-          }
-          tmp << " " << msgbuf;
-        }
-        break;
-      }
-#endif  // WEBRTC_WIN
-#if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
-      case ERRCTX_OSSTATUS: {
-        std::string desc(DescriptionFromOSStatus(err));
-        tmp << " " << (desc.empty() ? "Unknown error" : desc.c_str());
-        break;
-      }
-#endif  // WEBRTC_MAC && !defined(WEBRTC_IOS)
-      default:
-        break;
-    }
-    extra_ = tmp.str();
-  }
-}
-
-LogMessage::LogMessage(const char* file,
-                       int line,
-                       LoggingSeverity sev,
-                       const std::string& tag)
-    : LogMessage(file,
-                 line,
-                 sev,
-                 ERRCTX_NONE,
-                 0 /* err */,
-                 nullptr /* module */) {
-  tag_ = tag;
-  print_stream_ << tag << ": ";
-}
-
-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_);
-  }
-
-  CritScope cs(&g_log_crit);
-  for (auto& kv : streams_) {
-    if (severity_ >= kv.second) {
-      kv.first->OnLogMessage(str);
-    }
-  }
-}
-
-int64_t LogMessage::LogStartTime() {
-  static const int64_t g_start = SystemTimeMillis();
-  return g_start;
-}
-
-uint32_t LogMessage::WallClockStartTime() {
-  static const uint32_t g_start_wallclock = time(nullptr);
-  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(&g_log_crit);
-  UpdateMinLogSeverity();
-}
-
-void LogMessage::SetLogToStderr(bool log_to_stderr) {
-  log_to_stderr_ = log_to_stderr;
-}
-
-int LogMessage::GetLogToStream(LogSink* stream) {
-  CritScope cs(&g_log_crit);
-  LoggingSeverity sev = LS_NONE;
-  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(&g_log_crit);
-  streams_.push_back(std::make_pair(stream, min_sev));
-  UpdateMinLogSeverity();
-}
-
-void LogMessage::RemoveLogToStream(LogSink* stream) {
-  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) {
-  LoggingSeverity current_level = LS_VERBOSE;
-  LoggingSeverity debug_level = GetLogToDebug();
-
-  std::vector<std::string> tokens;
-  tokenize(params, ' ', &tokens);
-
-  for (const std::string& token : tokens) {
-    if (token.empty())
-      continue;
-
-    // Logging features
-    if (token == "tstamp") {
-      LogTimestamps();
-    } else if (token == "thread") {
-      LogThreads();
-
-    // Logging levels
-    } else if (token == "sensitive") {
-      current_level = LS_SENSITIVE;
-    } else if (token == "verbose") {
-      current_level = LS_VERBOSE;
-    } else if (token == "info") {
-      current_level = LS_INFO;
-    } else if (token == "warning") {
-      current_level = LS_WARNING;
-    } else if (token == "error") {
-      current_level = LS_ERROR;
-    } else if (token == "none") {
-      current_level = LS_NONE;
-
-    // Logging targets
-    } else if (token == "debug") {
-      debug_level = current_level;
-    }
-  }
-
-#if defined(WEBRTC_WIN)
-  if ((LS_NONE != debug_level) && !::IsDebuggerPresent()) {
-    // First, attempt to attach to our parent's console... so if you invoke
-    // from the command line, we'll see the output there.  Otherwise, create
-    // our own console window.
-    // Note: These methods fail if a console already exists, which is fine.
-    bool success = false;
-    typedef BOOL (WINAPI* PFN_AttachConsole)(DWORD);
-    if (HINSTANCE kernel32 = ::LoadLibrary(L"kernel32.dll")) {
-      // AttachConsole is defined on WinXP+.
-      if (PFN_AttachConsole attach_console = reinterpret_cast<PFN_AttachConsole>
-            (::GetProcAddress(kernel32, "AttachConsole"))) {
-        success = (FALSE != attach_console(ATTACH_PARENT_PROCESS));
-      }
-      ::FreeLibrary(kernel32);
-    }
-    if (!success) {
-      ::AllocConsole();
-    }
-  }
-#endif  // WEBRTC_WIN
-
-  LogToDebug(debug_level);
-}
-
-void LogMessage::UpdateMinLogSeverity() EXCLUSIVE_LOCKS_REQUIRED(g_log_crit) {
-  LoggingSeverity min_sev = dbg_sev_;
-  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(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 != nullptr && domain != nullptr) {
-    Boolean exists_and_is_valid;
-    Boolean should_log =
-        CFPreferencesGetAppBooleanValue(key, domain, &exists_and_is_valid);
-    // If the key doesn't exist or is invalid or is false, we will not log to
-    // stderr.
-    log_to_stderr = exists_and_is_valid && should_log;
-  }
-  if (key != nullptr) {
-    CFRelease(key);
-  }
-#endif
-#if defined(WEBRTC_WIN)
-  // Always log to the debugger.
-  // Perhaps stderr should be controlled by a preference, as on Mac?
-  OutputDebugStringA(str.c_str());
-  if (log_to_stderr) {
-    // This handles dynamically allocated consoles, too.
-    if (HANDLE error_handle = ::GetStdHandle(STD_ERROR_HANDLE)) {
-      log_to_stderr = false;
-      DWORD written = 0;
-      ::WriteFile(error_handle, str.data(), static_cast<DWORD>(str.size()),
-                  &written, 0);
-    }
-  }
-#endif  // WEBRTC_WIN
-#if defined(WEBRTC_ANDROID)
-  // Android's logging facility uses severity to log messages but we
-  // need to map libjingle's severity levels to Android ones first.
-  // Also write to stderr which maybe available to executable started
-  // from the shell.
-  int prio;
-  switch (severity) {
-    case LS_SENSITIVE:
-      __android_log_write(ANDROID_LOG_INFO, tag.c_str(), "SENSITIVE");
-      if (log_to_stderr) {
-        fprintf(stderr, "SENSITIVE");
-        fflush(stderr);
-      }
-      return;
-    case LS_VERBOSE:
-      prio = ANDROID_LOG_VERBOSE;
-      break;
-    case LS_INFO:
-      prio = ANDROID_LOG_INFO;
-      break;
-    case LS_WARNING:
-      prio = ANDROID_LOG_WARN;
-      break;
-    case LS_ERROR:
-      prio = ANDROID_LOG_ERROR;
-      break;
-    default:
-      prio = ANDROID_LOG_UNKNOWN;
-  }
-
-  int size = str.size();
-  int line = 0;
-  int idx = 0;
-  const int max_lines = size / kMaxLogLineSize + 1;
-  if (max_lines == 1) {
-    __android_log_print(prio, tag.c_str(), "%.*s", size, str.c_str());
-  } else {
-    while (size > 0) {
-      const int len = std::min(size, kMaxLogLineSize);
-      // Use the size of the string in the format (str may have \0 in the
-      // middle).
-      __android_log_print(prio, tag.c_str(), "[%d/%d] %.*s",
-                          line + 1, max_lines,
-                          len, str.c_str() + idx);
-      idx += len;
-      size -= len;
-      ++line;
-    }
-  }
-#endif  // WEBRTC_ANDROID
-  if (log_to_stderr) {
-    fprintf(stderr, "%s", str.c_str());
-    fflush(stderr);
-  }
-}
-
-//////////////////////////////////////////////////////////////////////
-// Logging Helpers
-//////////////////////////////////////////////////////////////////////
-
-void LogMultiline(LoggingSeverity level, const char* label, bool input,
-                  const void* data, size_t len, bool hex_mode,
-                  LogMultilineState* state) {
-  if (!LOG_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]
-                   << " consecutive unprintable ##";
-      state->unprintable_count_[input] = 0;
-    }
-    return;
-  }
-
-  // The ctype classification functions want unsigned chars.
-  const unsigned char* udata = static_cast<const unsigned char*>(data);
-
-  if (hex_mode) {
-    const size_t LINE_SIZE = 24;
-    char hex_line[LINE_SIZE * 9 / 4 + 2], asc_line[LINE_SIZE + 1];
-    while (len > 0) {
-      memset(asc_line, ' ', sizeof(asc_line));
-      memset(hex_line, ' ', sizeof(hex_line));
-      size_t line_len = std::min(len, LINE_SIZE);
-      for (size_t i = 0; i < line_len; ++i) {
-        unsigned char ch = udata[i];
-        asc_line[i] = isprint(ch) ? ch : '.';
-        hex_line[i*2 + i/4] = hex_encode(ch >> 4);
-        hex_line[i*2 + i/4 + 1] = hex_encode(ch & 0xf);
-      }
-      asc_line[sizeof(asc_line)-1] = 0;
-      hex_line[sizeof(hex_line)-1] = 0;
-      LOG_V(level) << label << direction
-                   << asc_line << " " << hex_line << " ";
-      udata += line_len;
-      len -= line_len;
-    }
-    return;
-  }
-
-  size_t consecutive_unprintable = state ? state->unprintable_count_[input] : 0;
-
-  const unsigned char* end = udata + len;
-  while (udata < end) {
-    const unsigned char* line = udata;
-    const unsigned char* end_of_line = strchrn<unsigned char>(udata,
-                                                              end - udata,
-                                                              '\n');
-    if (!end_of_line) {
-      udata = end_of_line = end;
-    } else {
-      udata = end_of_line + 1;
-    }
-
-    bool is_printable = true;
-
-    // If we are in unprintable mode, we need to see a line of at least
-    // kMinPrintableLine characters before we'll switch back.
-    const ptrdiff_t kMinPrintableLine = 4;
-    if (consecutive_unprintable && ((end_of_line - line) < kMinPrintableLine)) {
-      is_printable = false;
-    } else {
-      // Determine if the line contains only whitespace and printable
-      // characters.
-      bool is_entirely_whitespace = true;
-      for (const unsigned char* pos = line; pos < end_of_line; ++pos) {
-        if (isspace(*pos))
-          continue;
-        is_entirely_whitespace = false;
-        if (!isprint(*pos)) {
-          is_printable = false;
-          break;
-        }
-      }
-      // Treat an empty line following unprintable data as unprintable.
-      if (consecutive_unprintable && is_entirely_whitespace) {
-        is_printable = false;
-      }
-    }
-    if (!is_printable) {
-      consecutive_unprintable += (udata - line);
-      continue;
-    }
-    // Print out the current line, but prefix with a count of prior unprintable
-    // characters.
-    if (consecutive_unprintable) {
-      LOG_V(level) << label << direction << "## " << consecutive_unprintable
-                  << " consecutive unprintable ##";
-      consecutive_unprintable = 0;
-    }
-    // Strip off trailing whitespace.
-    while ((end_of_line > line) && isspace(*(end_of_line-1))) {
-      --end_of_line;
-    }
-    // Filter out any private data
-    std::string substr(reinterpret_cast<const char*>(line), end_of_line - line);
-    std::string::size_type pos_private = substr.find("Email");
-    if (pos_private == std::string::npos) {
-      pos_private = substr.find("Passwd");
-    }
-    if (pos_private == std::string::npos) {
-      LOG_V(level) << label << direction << substr;
-    } else {
-      LOG_V(level) << label << direction << "## omitted for privacy ##";
-    }
-  }
-
-  if (state) {
-    state->unprintable_count_[input] = consecutive_unprintable;
-  }
-}
-
-//////////////////////////////////////////////////////////////////////
-
-}  // namespace rtc