Remove SetVideoLogging/SetAudioLogging from ChannelManager and down the stack.

talk/media/webrtc/webrtcvoiceengine.cc

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 37 matching lines @@
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/call/rtc_event_log.h"
 #include "webrtc/common.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
+#include "webrtc/system_wrappers/include/trace.h"
 
 namespace cricket {
 namespace {
 
+const int kDefaultTraceFilter = webrtc::kTraceNone | webrtc::kTraceTerseInfo |
+                                webrtc::kTraceWarning | webrtc::kTraceError |
+                                webrtc::kTraceCritical;
+const int kElevatedTraceFilter = kDefaultTraceFilter | webrtc::kTraceStateInfo |
+                                 webrtc::kTraceInfo;
+
 const int kMaxNumPacketSize = 6;
 struct CodecPref {
   const char* name;
   int clockrate;
   int channels;
   int payload_type;
   bool is_multi_rate;
   int packet_sizes_ms[kMaxNumPacketSize];
 };
 // Note: keep the supported packet sizes in ascending order.
@@ skipping 106 matching lines @@
   return ss.str();
 }
 
 void LogMultiline(rtc::LoggingSeverity sev, char* text) {
   const char* delim = "\r\n";
   for (char* tok = strtok(text, delim); tok; tok = strtok(NULL, delim)) {
     LOG_V(sev) << tok;
   }
 }
 
-// Severity is an integer because it comes is assumed to be from command line.
-int SeverityToFilter(int severity) {
-  int filter = webrtc::kTraceNone;
-  switch (severity) {
-    case rtc::LS_VERBOSE:
-      filter |= webrtc::kTraceAll;
-      FALLTHROUGH();
-    case rtc::LS_INFO:
-      filter |= (webrtc::kTraceStateInfo | webrtc::kTraceInfo);
-      FALLTHROUGH();
-    case rtc::LS_WARNING:
-      filter |= (webrtc::kTraceTerseInfo | webrtc::kTraceWarning);
-      FALLTHROUGH();
-    case rtc::LS_ERROR:
-      filter |= (webrtc::kTraceError | webrtc::kTraceCritical);
-  }
-  return filter;
-}
-
 bool IsCodec(const AudioCodec& codec, const char* ref_name) {
   return (_stricmp(codec.name.c_str(), ref_name) == 0);
 }
 
 bool IsCodec(const webrtc::CodecInst& codec, const char* ref_name) {
   return (_stricmp(codec.plname, ref_name) == 0);
 }
 
 bool IsCodecMultiRate(const webrtc::CodecInst& codec) {
   for (size_t i = 0; i < arraysize(kCodecPrefs); ++i) {
@@ skipping 162 matching lines @@
   options.typing_detection = rtc::Optional<bool>(true);
   options.adjust_agc_delta = rtc::Optional<int>(0);
   options.experimental_agc = rtc::Optional<bool>(false);
   options.extended_filter_aec = rtc::Optional<bool>(false);
   options.delay_agnostic_aec = rtc::Optional<bool>(false);
   options.experimental_ns = rtc::Optional<bool>(false);
   options.aec_dump = rtc::Optional<bool>(false);
   return options;
 }
 
-std::string GetEnableString(bool enable) {
-  return enable ? "enable" : "disable";
-}
-
 webrtc::AudioState::Config MakeAudioStateConfig(VoEWrapper* voe_wrapper) {
   webrtc::AudioState::Config config;
   config.voice_engine = voe_wrapper->engine();
   return config;
 }
 
 std::vector<webrtc::RtpExtension> FindAudioRtpHeaderExtensions(
     const std::vector<RtpHeaderExtension>& extensions) {
   std::vector<webrtc::RtpExtension> result;
   for (const auto& extension : extensions) {
     if (extension.uri == kRtpAbsoluteSenderTimeHeaderExtension ||
         extension.uri == kRtpAudioLevelHeaderExtension) {
       result.push_back({extension.uri, extension.id});
     } else {
       LOG(LS_WARNING) << "Unsupported RTP extension: " << extension.ToString();
     }
   }
   return result;
 }
 } // namespace {
 
 WebRtcVoiceEngine::WebRtcVoiceEngine()
     : voe_wrapper_(new VoEWrapper()),
-      tracing_(new VoETraceWrapper()),
-      audio_state_(webrtc::AudioState::Create(MakeAudioStateConfig(voe()))),
-      log_filter_(SeverityToFilter(kDefaultLogSeverity)) {
+      audio_state_(webrtc::AudioState::Create(MakeAudioStateConfig(voe()))) {
   Construct();
 }
 
-WebRtcVoiceEngine::WebRtcVoiceEngine(VoEWrapper* voe_wrapper,
-                                     VoETraceWrapper* tracing)
-    : voe_wrapper_(voe_wrapper),
-      tracing_(tracing),
-      log_filter_(SeverityToFilter(kDefaultLogSeverity)) {
+WebRtcVoiceEngine::WebRtcVoiceEngine(VoEWrapper* voe_wrapper)
+    : voe_wrapper_(voe_wrapper) {
   Construct();
 }
 
 void WebRtcVoiceEngine::Construct() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+  LOG(LS_VERBOSE) << "WebRtcVoiceEngine::WebRtcVoiceEngine";
+
   signal_thread_checker_.DetachFromThread();
   std::memset(&default_agc_config_, 0, sizeof(default_agc_config_));
-  SetTraceFilter(log_filter_);
-  LOG(LS_VERBOSE) << "WebRtcVoiceEngine::WebRtcVoiceEngine";
-  SetTraceOptions("");
-  if (tracing_->SetTraceCallback(this) == -1) {
-    LOG_RTCERR0(SetTraceCallback);
-  }
+
+  webrtc::Trace::set_level_filter(kDefaultTraceFilter);
+  webrtc::Trace::SetTraceCallback(this);
 
   // Load our audio codec list.
   ConstructCodecs();
 
   // Load our RTP Header extensions.
   rtp_header_extensions_.push_back(
       RtpHeaderExtension(kRtpAudioLevelHeaderExtension,
                          kRtpAudioLevelHeaderExtensionDefaultId));
   rtp_header_extensions_.push_back(
       RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension,
@@ skipping 76 matching lines @@
 }
 
 WebRtcVoiceEngine::~WebRtcVoiceEngine() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   LOG(LS_VERBOSE) << "WebRtcVoiceEngine::~WebRtcVoiceEngine";
   if (adm_) {
     voe_wrapper_.reset();
     adm_->Release();
     adm_ = NULL;
   }
-
-  tracing_->SetTraceCallback(NULL);
+  webrtc::Trace::SetTraceCallback(nullptr);
 }
 
 bool WebRtcVoiceEngine::Init(rtc::Thread* worker_thread) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   RTC_DCHECK(worker_thread == rtc::Thread::Current());
   LOG(LS_INFO) << "WebRtcVoiceEngine::Init";
   bool res = InitInternal();
   if (res) {
     LOG(LS_INFO) << "WebRtcVoiceEngine::Init Done!";
   } else {
     LOG(LS_ERROR) << "WebRtcVoiceEngine::Init failed";
     Terminate();
   }
   return res;
 }
 
 bool WebRtcVoiceEngine::InitInternal() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   // Temporarily turn logging level up for the Init call
-  int old_filter = log_filter_;
-  int extended_filter = log_filter_ | SeverityToFilter(rtc::LS_INFO);
-  SetTraceFilter(extended_filter);
-  SetTraceOptions("");
-
-  // Init WebRtc VoiceEngine.
+  webrtc::Trace::set_level_filter(kElevatedTraceFilter);
   if (voe_wrapper_->base()->Init(adm_) == -1) {
     LOG_RTCERR0_EX(Init, voe_wrapper_->error());
-    SetTraceFilter(old_filter);
     return false;
   }
-
-  SetTraceFilter(old_filter);
-  SetTraceOptions(log_options_);
+  webrtc::Trace::set_level_filter(kDefaultTraceFilter);
 
   // Log the VoiceEngine version info
   char buffer[1024] = "";
   voe_wrapper_->base()->GetVersion(buffer);
   LOG(LS_INFO) << "WebRtc VoiceEngine Version:";
   LogMultiline(rtc::LS_INFO, buffer);
 
   // Save the default AGC configuration settings. This must happen before
   // calling SetOptions or the default will be overwritten.
   if (voe_wrapper_->processing()->GetAgcConfig(default_agc_config_) == -1) {
@@ skipping 554 matching lines @@
   }
   return false;
 }
 
 const std::vector<RtpHeaderExtension>&
 WebRtcVoiceEngine::rtp_header_extensions() const {
   RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
   return rtp_header_extensions_;
 }
 
-void WebRtcVoiceEngine::SetLogging(int min_sev, const char* filter) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  // if min_sev == -1, we keep the current log level.
-  if (min_sev >= 0) {
-    SetTraceFilter(SeverityToFilter(min_sev));
-  }
-  log_options_ = filter;
-  SetTraceOptions(initialized_ ? log_options_ : "");
-}
-
 int WebRtcVoiceEngine::GetLastEngineError() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   return voe_wrapper_->error();
 }
 
-void WebRtcVoiceEngine::SetTraceFilter(int filter) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  log_filter_ = filter;
-  tracing_->SetTraceFilter(filter);
-}
-
-// We suppport three different logging settings for VoiceEngine:
-// 1. Observer callback that goes into talk diagnostic logfile.
-//    Use --logfile and --loglevel
-//
-// 2. Encrypted VoiceEngine log for debugging VoiceEngine.
-//    Use --voice_loglevel --voice_logfilter "tracefile file_name"
-//
-// 3. EC log and dump for debugging QualityEngine.
-//    Use --voice_loglevel --voice_logfilter "recordEC file_name"
-//
-// For more details see: "https://sites.google.com/a/google.com/wavelet/Home/
-//    Magic-Flute--RTC-Engine-/Magic-Flute-Command-Line-Parameters"
-void WebRtcVoiceEngine::SetTraceOptions(const std::string& options) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  // Set encrypted trace file.
-  std::vector<std::string> opts;
-  rtc::tokenize(options, ' ', '"', '"', &opts);
-  std::vector<std::string>::iterator tracefile =
-      std::find(opts.begin(), opts.end(), "tracefile");
-  if (tracefile != opts.end() && ++tracefile != opts.end()) {
-    // Write encrypted debug output (at same loglevel) to file
-    // EncryptedTraceFile no longer supported.
-    if (tracing_->SetTraceFile(tracefile->c_str()) == -1) {
-      LOG_RTCERR1(SetTraceFile, *tracefile);
-    }
-  }
-
-  // Allow trace options to override the trace filter. We default
-  // it to log_filter_ (as a translation of libjingle log levels)
-  // elsewhere, but this allows clients to explicitly set webrtc
-  // log levels.
-  std::vector<std::string>::iterator tracefilter =
-      std::find(opts.begin(), opts.end(), "tracefilter");
-  if (tracefilter != opts.end() && ++tracefilter != opts.end()) {
-    if (!tracing_->SetTraceFilter(rtc::FromString<int>(*tracefilter))) {
-      LOG_RTCERR1(SetTraceFilter, *tracefilter);
-    }
-  }
-
-  // Set AEC dump file
-  std::vector<std::string>::iterator recordEC =
-      std::find(opts.begin(), opts.end(), "recordEC");
-  if (recordEC != opts.end()) {
-    ++recordEC;
-    if (recordEC != opts.end())
-      StartAecDump(recordEC->c_str());
-    else
-      StopAecDump();
-  }
-}
-
 void WebRtcVoiceEngine::Print(webrtc::TraceLevel level, const char* trace,
                               int length) {
   // Note: This callback can happen on any thread!
   rtc::LoggingSeverity sev = rtc::LS_VERBOSE;
   if (level == webrtc::kTraceError || level == webrtc::kTraceCritical)
     sev = rtc::LS_ERROR;
   else if (level == webrtc::kTraceWarning)
     sev = rtc::LS_WARNING;
   else if (level == webrtc::kTraceStateInfo || level == webrtc::kTraceInfo)
     sev = rtc::LS_INFO;
@@ skipping 575 matching lines @@
       return false;
     }
   }
 
   if (IsCodec(send_codec, kOpusCodecName)) {
     // DTX and maxplaybackrate should be set after SetSendCodec. Because current
     // send codec has to be Opus.
 
     // Set Opus internal DTX.
     LOG(LS_INFO) << "Attempt to "
-                 << GetEnableString(enable_opus_dtx)
+                 << (enable_opus_dtx ? "enable" : "disable")
                  << " Opus DTX on channel "
                  << channel;
     if (engine()->voe()->codec()->SetOpusDtx(channel, enable_opus_dtx)) {
       LOG_RTCERR2(SetOpusDtx, channel, enable_opus_dtx);
       return false;
     }
 
     // If opus_max_playback_rate <= 0, the default maximum playback rate
     // (48 kHz) will be used.
     if (opus_max_playback_rate > 0) {
@@ skipping 954 matching lines @@
     } else {
       LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
       return false;
     }
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE