Delete all log messages depending on system_wrappers.

webrtc/modules/audio_coding/acm2/audio_coding_module.cc

 /*
  *  Copyright (c) 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.
  */
 
@@ skipping 742 matching lines @@
   // TODO(henrik.lundin): This condition should probably be
   //   in_frame.num_channels_ > encoder_stack_->NumChannels()
   const bool down_mix =
       in_frame.num_channels_ == 2 && encoder_stack_->NumChannels() == 1;
 
   if (!first_10ms_data_) {
     expected_in_ts_ = in_frame.timestamp_;
     expected_codec_ts_ = in_frame.timestamp_;
     first_10ms_data_ = true;
   } else if (in_frame.timestamp_ != expected_in_ts_) {
-    LOG(LS_WARNING) << "Unexpected input timestamp: " << in_frame.timestamp_
-                    << ", expected: " << expected_in_ts_;
     expected_codec_ts_ +=
         (in_frame.timestamp_ - expected_in_ts_) *
         static_cast<uint32_t>(
             static_cast<double>(encoder_stack_->SampleRateHz()) /
             static_cast<double>(in_frame.sample_rate_hz_));
     expected_in_ts_ = in_frame.timestamp_;
   }
 
 
   if (!down_mix && !resample) {
@@ skipping 197 matching lines @@
   receiver_.SetCodecs(codecs);
 }
 
 bool AudioCodingModuleImpl::RegisterReceiveCodec(
     int rtp_payload_type,
     const SdpAudioFormat& audio_format) {
   rtc::CritScope lock(&acm_crit_sect_);
   RTC_DCHECK(receiver_initialized_);
 
   if (!acm2::RentACodec::IsPayloadTypeValid(rtp_payload_type)) {
-    LOG_F(LS_ERROR) << "Invalid payload-type " << rtp_payload_type
-                    << " for decoder.";
     return false;
   }
 
   return receiver_.AddCodec(rtp_payload_type, audio_format);
 }
 
 int AudioCodingModuleImpl::RegisterReceiveCodec(const CodecInst& codec) {
   rtc::CritScope lock(&acm_crit_sect_);
   auto* ef = encoder_factory_.get();
   return RegisterReceiveCodecUnlocked(
       codec, [&] { return ef->rent_a_codec.RentIsacDecoder(codec.plfreq); });
 }
 
 int AudioCodingModuleImpl::RegisterReceiveCodec(
     const CodecInst& codec,
     rtc::FunctionView<std::unique_ptr<AudioDecoder>()> isac_factory) {
   rtc::CritScope lock(&acm_crit_sect_);
   return RegisterReceiveCodecUnlocked(codec, isac_factory);
 }
 
 int AudioCodingModuleImpl::RegisterReceiveCodecUnlocked(
     const CodecInst& codec,
     rtc::FunctionView<std::unique_ptr<AudioDecoder>()> isac_factory) {
   RTC_DCHECK(receiver_initialized_);
   if (codec.channels > 2) {
-    LOG_F(LS_ERROR) << "Unsupported number of channels: " << codec.channels;
     return -1;
   }
 
   auto codec_id = acm2::RentACodec::CodecIdByParams(codec.plname, codec.plfreq,
                                                     codec.channels);
   if (!codec_id) {
-    LOG_F(LS_ERROR) << "Wrong codec params to be registered as receive codec";
     return -1;
   }
   auto codec_index = acm2::RentACodec::CodecIndexFromId(*codec_id);
   RTC_CHECK(codec_index) << "Invalid codec ID: " << static_cast<int>(*codec_id);
 
   // Check if the payload-type is valid.
   if (!acm2::RentACodec::IsPayloadTypeValid(codec.pltype)) {
-    LOG_F(LS_ERROR) << "Invalid payload type " << codec.pltype << " for "
-                    << codec.plname;
     return -1;
   }
 
   AudioDecoder* isac_decoder = nullptr;
   if (STR_CASE_CMP(codec.plname, "isac") == 0) {
     std::unique_ptr<AudioDecoder>& saved_isac_decoder =
         codec.plfreq == 16000 ? isac_decoder_16k_ : isac_decoder_32k_;
     if (!saved_isac_decoder) {
       saved_isac_decoder = isac_factory();
     }
     isac_decoder = saved_isac_decoder.get();
   }
   return receiver_.AddCodec(*codec_index, codec.pltype, codec.channels,
                             codec.plfreq, isac_decoder, codec.plname);
 }
 
 int AudioCodingModuleImpl::RegisterExternalReceiveCodec(
     int rtp_payload_type,
     AudioDecoder* external_decoder,
     int sample_rate_hz,
     int num_channels,
     const std::string& name) {
   rtc::CritScope lock(&acm_crit_sect_);
   RTC_DCHECK(receiver_initialized_);
   if (num_channels > 2 || num_channels < 0) {
-    LOG_F(LS_ERROR) << "Unsupported number of channels: " << num_channels;
     return -1;
   }
 
   // Check if the payload-type is valid.
   if (!acm2::RentACodec::IsPayloadTypeValid(rtp_payload_type)) {
-    LOG_F(LS_ERROR) << "Invalid payload-type " << rtp_payload_type
-                    << " for external decoder.";
     return -1;
   }
 
   return receiver_.AddCodec(-1 /* external */, rtp_payload_type, num_channels,
                             sample_rate_hz, external_decoder, name);
 }
 
 // Get current received codec.
 int AudioCodingModuleImpl::ReceiveCodec(CodecInst* current_codec) const {
   rtc::CritScope lock(&acm_crit_sect_);
@@ skipping 292 matching lines @@
 // Checks the validity of the parameters of the given codec
 bool AudioCodingModule::IsCodecValid(const CodecInst& codec) {
   bool valid = acm2::RentACodec::IsCodecValid(codec);
   if (!valid)
     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, -1,
                  "Invalid codec setting");
   return valid;
 }
 
 }  // namespace webrtc