Remove voe::Statistics.

voice_engine/channel.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 22 matching lines @@
 #include "rtc_base/format_macros.h"
 #include "rtc_base/location.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/rate_limiter.h"
 #include "rtc_base/task_queue.h"
 #include "rtc_base/thread_checker.h"
 #include "rtc_base/timeutils.h"
 #include "system_wrappers/include/field_trial.h"
 #include "system_wrappers/include/metrics.h"
 #include "system_wrappers/include/trace.h"
-#include "voice_engine/statistics.h"
 #include "voice_engine/utility.h"
 
 namespace webrtc {
 namespace voe {
 
 namespace {
 
 constexpr double kAudioSampleDurationSeconds = 0.01;
 constexpr int64_t kMaxRetransmissionWindowMs = 1000;
 constexpr int64_t kMinRetransmissionWindowMs = 30;
@@ skipping 386 matching lines @@
 
   // Push data from ACM to RTP/RTCP-module to deliver audio frame for
   // packetization.
   // This call will trigger Transport::SendPacket() from the RTP/RTCP module.
   if (!_rtpRtcpModule->SendOutgoingData(
           (FrameType&)frameType, payloadType, timeStamp,
           // Leaving the time when this frame was
           // received from the capture device as
           // undefined for voice for now.
           -1, payloadData, payloadSize, fragmentation, nullptr, nullptr)) {
-    _engineStatisticsPtr->SetLastError(
-        VE_RTP_RTCP_MODULE_ERROR, kTraceWarning,
-        "Channel::SendData() failed to send data to RTP/RTCP module");
+    LOG(LS_ERROR) <<
+        "Channel::SendData() failed to send data to RTP/RTCP module";
     return -1;
   }
 
   return 0;
 }
 
 bool Channel::SendRtp(const uint8_t* data,
                       size_t len,
                       const PacketOptions& options) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SendPacket(channel=%d, len=%" PRIuS ")", len);
 
   rtc::CritScope cs(&_callbackCritSect);
 
   if (_transportPtr == NULL) {
     WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, _channelId),
                  "Channel::SendPacket() failed to send RTP packet due to"
                  " invalid transport object");
     return false;
   }
 
   uint8_t* bufferToSendPtr = (uint8_t*)data;
   size_t bufferLength = len;
 
   if (!_transportPtr->SendRtp(bufferToSendPtr, bufferLength, options)) {
-    std::string transport_name =
-        _externalTransport ? "external transport" : "WebRtc sockets";
-    WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, _channelId),
-                 "Channel::SendPacket() RTP transmission using %s failed",
-                 transport_name.c_str());
+    LOG(LS_ERROR) << "Channel::SendPacket() RTP transmission failed";
     return false;
   }
   return true;
 }
 
 bool Channel::SendRtcp(const uint8_t* data, size_t len) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SendRtcp(len=%" PRIuS ")", len);
 
   rtc::CritScope cs(&_callbackCritSect);
   if (_transportPtr == NULL) {
     WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, _channelId),
                  "Channel::SendRtcp() failed to send RTCP packet"
                  " due to invalid transport object");
     return false;
   }
 
   uint8_t* bufferToSendPtr = (uint8_t*)data;
   size_t bufferLength = len;
 
   int n = _transportPtr->SendRtcp(bufferToSendPtr, bufferLength);
   if (n < 0) {
-    std::string transport_name =
-        _externalTransport ? "external transport" : "WebRtc sockets";
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
-                 "Channel::SendRtcp() transmission using %s failed",
-                 transport_name.c_str());
+    LOG(LS_ERROR) << "Channel::SendRtcp() transmission failed";
     return false;
   }
   return true;
 }
 
 void Channel::OnIncomingSSRCChanged(uint32_t ssrc) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::OnIncomingSSRCChanged(SSRC=%d)", ssrc);
 
   // Update ssrc so that NTP for AV sync can be updated.
@@ skipping 29 matching lines @@
   audio_coding_->Codec(payloadName, &dummyCodec, frequency, channels);
   receiveCodec.pacsize = dummyCodec.pacsize;
 
   // Register the new codec to the ACM
   if (!audio_coding_->RegisterReceiveCodec(receiveCodec.pltype,
                                            CodecInstToSdp(receiveCodec))) {
     WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                  "Channel::OnInitializeDecoder() invalid codec ("
                  "pt=%d, name=%s) received - 1",
                  payloadType, payloadName);
-    _engineStatisticsPtr->SetLastError(VE_AUDIO_CODING_MODULE_ERROR);
     return -1;
   }
 
   return 0;
 }
 
 int32_t Channel::OnReceivedPayloadData(const uint8_t* payloadData,
                                        size_t payloadSize,
                                        const WebRtcRTPHeader* rtpHeader) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::OnReceivedPayloadData(payloadSize=%" PRIuS
                ","
                " payloadType=%u, audioChannel=%" PRIuS ")",
                payloadSize, rtpHeader->header.payloadType,
                rtpHeader->type.Audio.channel);
 
   if (!channel_state_.Get().playing) {
     // Avoid inserting into NetEQ when we are not playing. Count the
     // packet as discarded.
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
                  "received packet is discarded since playing is not"
                  " activated");
     return 0;
   }
 
   // Push the incoming payload (parsed and ready for decoding) into the ACM
   if (audio_coding_->IncomingPacket(payloadData, payloadSize, *rtpHeader) !=
       0) {
-    _engineStatisticsPtr->SetLastError(
-        VE_AUDIO_CODING_MODULE_ERROR, kTraceWarning,
-        "Channel::OnReceivedPayloadData() unable to push data to the ACM");
+    LOG(LS_ERROR) <<
+        "Channel::OnReceivedPayloadData() unable to push data to the ACM";
     return -1;
   }
 
   int64_t round_trip_time = 0;
   _rtpRtcpModule->RTT(rtp_receiver_->SSRC(), &round_trip_time, NULL, NULL,
                       NULL);
 
   std::vector<uint16_t> nack_list = audio_coding_->GetNackList(round_trip_time);
   if (!nack_list.empty()) {
     // Can't use nack_list.data() since it's not supported by all
@@ skipping 151 matching lines @@
       rtp_payload_registry_(new RTPPayloadRegistry()),
       rtp_receive_statistics_(
           ReceiveStatistics::Create(Clock::GetRealTimeClock())),
       rtp_receiver_(
           RtpReceiver::CreateAudioReceiver(Clock::GetRealTimeClock(),
                                            this,
                                            this,
                                            rtp_payload_registry_.get())),
       telephone_event_handler_(rtp_receiver_->GetTelephoneEventHandler()),
       _outputAudioLevel(),
-      _externalTransport(false),
       _timeStamp(0),  // This is just an offset, RTP module will add it's own
                       // random offset
       ntp_estimator_(Clock::GetRealTimeClock()),
       playout_timestamp_rtp_(0),
       playout_delay_ms_(0),
       send_sequence_number_(0),
       rtp_ts_wraparound_handler_(new rtc::TimestampWrapAroundHandler()),
       capture_start_rtp_time_stamp_(-1),
       capture_start_ntp_time_ms_(-1),
-      _engineStatisticsPtr(NULL),
       _moduleProcessThreadPtr(NULL),
       _audioDeviceModulePtr(NULL),
-      _callbackCritSectPtr(NULL),
       _transportPtr(NULL),
       input_mute_(false),
       previous_frame_muted_(false),
       _outputGain(1.0f),
       _includeAudioLevelIndication(false),
       transport_overhead_per_packet_(0),
       rtp_overhead_per_packet_(0),
       _outputSpeechType(AudioFrame::kNormalSpeech),
       rtcp_observer_(new VoERtcpObserver(this)),
       associate_send_channel_(ChannelOwner(nullptr)),
@@ skipping 42 matching lines @@
 
 int32_t Channel::Init() {
   RTC_DCHECK(construction_thread_.CalledOnValidThread());
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::Init()");
 
   channel_state_.Reset();
 
   // --- Initial sanity
 
-  if ((_engineStatisticsPtr == NULL) || (_moduleProcessThreadPtr == NULL)) {
+  if (_moduleProcessThreadPtr == NULL) {
     WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, _channelId),
                  "Channel::Init() must call SetEngineInformation() first");
     return -1;
   }
 
   // --- Add modules to process thread (for periodic schedulation)
 
   _moduleProcessThreadPtr->RegisterModule(_rtpRtcpModule.get(), RTC_FROM_HERE);
 
   // --- ACM initialization
 
   if (audio_coding_->InitializeReceiver() == -1) {
-    _engineStatisticsPtr->SetLastError(
-        VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
-        "Channel::Init() unable to initialize the ACM - 1");
+    LOG(LS_ERROR) << "Channel::Init() unable to initialize the ACM - 1";
     return -1;
   }
 
   // --- RTP/RTCP module initialization
 
   // Ensure that RTCP is enabled by default for the created channel.
   // Note that, the module will keep generating RTCP until it is explicitly
   // disabled by the user.
   // After StopListen (when no sockets exists), RTCP packets will no longer
   // be transmitted since the Transport object will then be invalid.
   telephone_event_handler_->SetTelephoneEventForwardToDecoder(true);
   // RTCP is enabled by default.
   _rtpRtcpModule->SetRTCPStatus(RtcpMode::kCompound);
   // --- Register all permanent callbacks
   if (audio_coding_->RegisterTransportCallback(this) == -1) {
-    _engineStatisticsPtr->SetLastError(
-        VE_CANNOT_INIT_CHANNEL, kTraceError,
-        "Channel::Init() callbacks not registered");
+    LOG(LS_ERROR) << "Channel::Init() callbacks not registered";
     return -1;
   }
 
   return 0;
 }
 
 void Channel::Terminate() {
   RTC_DCHECK(construction_thread_.CalledOnValidThread());
   // Must be called on the same thread as Init().
   WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, _channelId),
@@ skipping 14 matching lines @@
                  " (Audio coding module)");
   }
 
   // De-register modules in process thread
   if (_moduleProcessThreadPtr)
     _moduleProcessThreadPtr->DeRegisterModule(_rtpRtcpModule.get());
 
   // End of modules shutdown
 }
 
-int32_t Channel::SetEngineInformation(Statistics& engineStatistics,
-                                      ProcessThread& moduleProcessThread,
+int32_t Channel::SetEngineInformation(ProcessThread& moduleProcessThread,
                                       AudioDeviceModule& audioDeviceModule,
-                                      rtc::CriticalSection* callbackCritSect,
                                       rtc::TaskQueue* encoder_queue) {
   RTC_DCHECK(encoder_queue);
   RTC_DCHECK(!encoder_queue_);
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetEngineInformation()");
-  _engineStatisticsPtr = &engineStatistics;
   _moduleProcessThreadPtr = &moduleProcessThread;
   _audioDeviceModulePtr = &audioDeviceModule;
-  _callbackCritSectPtr = callbackCritSect;
   encoder_queue_ = encoder_queue;
   return 0;
 }
 
 void Channel::SetSink(std::unique_ptr<AudioSinkInterface> sink) {
   rtc::CritScope cs(&_callbackCritSect);
   audio_sink_ = std::move(sink);
 }
 
 const rtc::scoped_refptr<AudioDecoderFactory>&
@@ skipping 38 matching lines @@
     rtc::CritScope cs(&encoder_queue_lock_);
     encoder_queue_is_active_ = true;
   }
   // Resume the previous sequence number which was reset by StopSend(). This
   // needs to be done before |sending| is set to true on the RTP/RTCP module.
   if (send_sequence_number_) {
     _rtpRtcpModule->SetSequenceNumber(send_sequence_number_);
   }
   _rtpRtcpModule->SetSendingMediaStatus(true);
   if (_rtpRtcpModule->SetSendingStatus(true) != 0) {
-    _engineStatisticsPtr->SetLastError(
-        VE_RTP_RTCP_MODULE_ERROR, kTraceError,
-        "StartSend() RTP/RTCP failed to start sending");
+    LOG(LS_ERROR) << "StartSend() RTP/RTCP failed to start sending";
     _rtpRtcpModule->SetSendingMediaStatus(false);
     rtc::CritScope cs(&_callbackCritSect);
     channel_state_.SetSending(false);
     return -1;
   }
 
   return 0;
 }
 
 void Channel::StopSend() {
@@ skipping 26 matching lines @@
   // the next StartSend(). This is needed for restarting device, otherwise
   // it might cause libSRTP to complain about packets being replayed.
   // TODO(xians): Remove this workaround after RtpRtcpModule's refactoring
   // CL is landed. See issue
   // https://code.google.com/p/webrtc/issues/detail?id=2111 .
   send_sequence_number_ = _rtpRtcpModule->SequenceNumber();
 
   // Reset sending SSRC and sequence number and triggers direct transmission
   // of RTCP BYE
   if (_rtpRtcpModule->SetSendingStatus(false) == -1) {
-    _engineStatisticsPtr->SetLastError(
-        VE_RTP_RTCP_MODULE_ERROR, kTraceWarning,
-        "StartSend() RTP/RTCP failed to stop sending");
+    LOG(LS_ERROR) << "StartSend() RTP/RTCP failed to stop sending";
   }
   _rtpRtcpModule->SetSendingMediaStatus(false);
 }
 
 bool Channel::SetEncoder(int payload_type,
                          std::unique_ptr<AudioEncoder> encoder) {
   RTC_DCHECK_GE(payload_type, 0);
   RTC_DCHECK_LE(payload_type, 127);
   // TODO(ossu): Make CodecInsts up, for now: one for the RTP/RTCP module and
   // one for for us to keep track of sample rate and number of channels, etc.
@@ skipping 152 matching lines @@
 void Channel::SetReceiverFrameLengthRange(int min_frame_length_ms,
                                           int max_frame_length_ms) {
   audio_coding_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
     if (*encoder) {
       (*encoder)->SetReceiverFrameLengthRange(min_frame_length_ms,
                                               max_frame_length_ms);
     }
   });
 }
 
-int32_t Channel::RegisterExternalTransport(Transport* transport) {
-  WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
-               "Channel::RegisterExternalTransport()");
-
+void Channel::RegisterTransport(Transport* transport) {
   rtc::CritScope cs(&_callbackCritSect);
-  if (_externalTransport) {
-    _engineStatisticsPtr->SetLastError(
-        VE_INVALID_OPERATION, kTraceError,
-        "RegisterExternalTransport() external transport already enabled");
-    return -1;
-  }
-  _externalTransport = true;
   _transportPtr = transport;
-  return 0;
-}
-
-int32_t Channel::DeRegisterExternalTransport() {
-  WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
-               "Channel::DeRegisterExternalTransport()");
-
-  rtc::CritScope cs(&_callbackCritSect);
-  if (_transportPtr) {
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
-                 "DeRegisterExternalTransport() all transport is disabled");
-  } else {
-    _engineStatisticsPtr->SetLastError(
-        VE_INVALID_OPERATION, kTraceWarning,
-        "DeRegisterExternalTransport() external transport already "
-        "disabled");
-  }
-  _externalTransport = false;
-  _transportPtr = NULL;
-  return 0;
 }
 
 void Channel::OnRtpPacket(const RtpPacketReceived& packet) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::OnRtpPacket()");
 
   RTPHeader header;
   packet.GetHeader(&header);
 
   // Store playout timestamp for the received RTP packet
@@ skipping 129 matching lines @@
                "Channel::SendTelephoneEventOutband(...)");
   RTC_DCHECK_LE(0, event);
   RTC_DCHECK_GE(255, event);
   RTC_DCHECK_LE(0, duration_ms);
   RTC_DCHECK_GE(65535, duration_ms);
   if (!Sending()) {
     return -1;
   }
   if (_rtpRtcpModule->SendTelephoneEventOutband(
       event, duration_ms, kTelephoneEventAttenuationdB) != 0) {
-    _engineStatisticsPtr->SetLastError(
-        VE_SEND_DTMF_FAILED, kTraceWarning,
-        "SendTelephoneEventOutband() failed to send event");
+    LOG(LS_ERROR) << "SendTelephoneEventOutband() failed to send event";
     return -1;
   }
   return 0;
 }
 
 int Channel::SetSendTelephoneEventPayloadType(int payload_type,
                                               int payload_frequency) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetSendTelephoneEventPayloadType()");
   RTC_DCHECK_LE(0, payload_type);
   RTC_DCHECK_GE(127, payload_type);
   CodecInst codec = {0};
   codec.pltype = payload_type;
   codec.plfreq = payload_frequency;
   memcpy(codec.plname, "telephone-event", 16);
   if (_rtpRtcpModule->RegisterSendPayload(codec) != 0) {
     _rtpRtcpModule->DeRegisterSendPayload(codec.pltype);
     if (_rtpRtcpModule->RegisterSendPayload(codec) != 0) {
-      _engineStatisticsPtr->SetLastError(
-          VE_RTP_RTCP_MODULE_ERROR, kTraceError,
-          "SetSendTelephoneEventPayloadType() failed to register send"
-          "payload type");
+      LOG(LS_ERROR) << "SetSendTelephoneEventPayloadType() failed to register "
+                       "send payload type";
       return -1;
     }
   }
   return 0;
 }
 
 int Channel::SetLocalSSRC(unsigned int ssrc) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetLocalSSRC()");
   if (channel_state_.Get().sending) {
-    _engineStatisticsPtr->SetLastError(VE_ALREADY_SENDING, kTraceError,
-                                       "SetLocalSSRC() already sending");
+    LOG(LS_ERROR) << "SetLocalSSRC() already sending";
     return -1;
   }
   _rtpRtcpModule->SetSSRC(ssrc);
   return 0;
 }
 
 int Channel::GetRemoteSSRC(unsigned int& ssrc) {
   ssrc = rtp_receiver_->SSRC();
   return 0;
 }
@@ skipping 80 matching lines @@
 void Channel::SetRTCPStatus(bool enable) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetRTCPStatus()");
   _rtpRtcpModule->SetRTCPStatus(enable ? RtcpMode::kCompound : RtcpMode::kOff);
 }
 
 int Channel::SetRTCP_CNAME(const char cName[256]) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetRTCP_CNAME()");
   if (_rtpRtcpModule->SetCNAME(cName) != 0) {
-    _engineStatisticsPtr->SetLastError(
-        VE_RTP_RTCP_MODULE_ERROR, kTraceError,
-        "SetRTCP_CNAME() failed to set RTCP CNAME");
+    LOG(LS_ERROR) << "SetRTCP_CNAME() failed to set RTCP CNAME";
     return -1;
   }
   return 0;
 }
 
 int Channel::GetRemoteRTCPReportBlocks(
     std::vector<ReportBlock>* report_blocks) {
   if (report_blocks == NULL) {
-    _engineStatisticsPtr->SetLastError(
-        VE_INVALID_ARGUMENT, kTraceError,
-        "GetRemoteRTCPReportBlock()s invalid report_blocks.");
+    LOG(LS_ERROR) << "GetRemoteRTCPReportBlock()s invalid report_blocks.";
     return -1;
   }
 
   // Get the report blocks from the latest received RTCP Sender or Receiver
   // Report. Each element in the vector contains the sender's SSRC and a
   // report block according to RFC 3550.
   std::vector<RTCPReportBlock> rtcp_report_blocks;
   if (_rtpRtcpModule->RemoteRTCPStat(&rtcp_report_blocks) != 0) {
     return -1;
   }
@@ skipping 237 matching lines @@
 uint32_t Channel::GetDelayEstimate() const {
   rtc::CritScope lock(&video_sync_lock_);
   return audio_coding_->FilteredCurrentDelayMs() + playout_delay_ms_;
 }
 
 int Channel::SetMinimumPlayoutDelay(int delayMs) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetMinimumPlayoutDelay()");
   if ((delayMs < kVoiceEngineMinMinPlayoutDelayMs) ||
       (delayMs > kVoiceEngineMaxMinPlayoutDelayMs)) {
-    _engineStatisticsPtr->SetLastError(
-        VE_INVALID_ARGUMENT, kTraceError,
-        "SetMinimumPlayoutDelay() invalid min delay");
+    LOG(LS_ERROR) << "SetMinimumPlayoutDelay() invalid min delay";
     return -1;
   }
   if (audio_coding_->SetMinimumPlayoutDelay(delayMs) != 0) {
-    _engineStatisticsPtr->SetLastError(
-        VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
-        "SetMinimumPlayoutDelay() failed to set min playout delay");
+    LOG(LS_ERROR) << "SetMinimumPlayoutDelay() failed to set min playout delay";
     return -1;
   }
   return 0;
 }
 
 int Channel::GetPlayoutTimestamp(unsigned int& timestamp) {
   uint32_t playout_timestamp_rtp = 0;
   {
     rtc::CritScope lock(&video_sync_lock_);
     playout_timestamp_rtp = playout_timestamp_rtp_;
   }
   if (playout_timestamp_rtp == 0) {
-    _engineStatisticsPtr->SetLastError(
-        VE_CANNOT_RETRIEVE_VALUE, kTraceStateInfo,
-        "GetPlayoutTimestamp() failed to retrieve timestamp");
+    LOG(LS_ERROR) << "GetPlayoutTimestamp() failed to retrieve timestamp";
     return -1;
   }
   timestamp = playout_timestamp_rtp;
   return 0;
 }
 
 int Channel::GetRtpRtcp(RtpRtcp** rtpRtcpModule,
                         RtpReceiver** rtp_receiver) const {
   *rtpRtcpModule = _rtpRtcpModule.get();
   *rtp_receiver = rtp_receiver_.get();
   return 0;
 }
 
 void Channel::UpdatePlayoutTimestamp(bool rtcp) {
   jitter_buffer_playout_timestamp_ = audio_coding_->PlayoutTimestamp();
 
   if (!jitter_buffer_playout_timestamp_) {
     // This can happen if this channel has not received any RTP packets. In
     // this case, NetEq is not capable of computing a playout timestamp.
     return;
   }
 
   uint16_t delay_ms = 0;
   if (_audioDeviceModulePtr->PlayoutDelay(&delay_ms) == -1) {
     WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                  "Channel::UpdatePlayoutTimestamp() failed to read playout"
                  " delay from the ADM");
-    _engineStatisticsPtr->SetLastError(
-        VE_CANNOT_RETRIEVE_VALUE, kTraceError,
-        "UpdatePlayoutTimestamp() failed to retrieve playout delay");
     return;
   }
 
   RTC_DCHECK(jitter_buffer_playout_timestamp_);
   uint32_t playout_timestamp = *jitter_buffer_playout_timestamp_;
 
   // Remove the playout delay.
   playout_timestamp -= (delay_ms * (GetRtpTimestampRateHz() / 1000));
 
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
@@ skipping 105 matching lines @@
   int64_t min_rtt = 0;
   if (_rtpRtcpModule->RTT(remoteSSRC, &rtt, &avg_rtt, &min_rtt, &max_rtt) !=
       0) {
     return 0;
   }
   return rtt;
 }
 
 }  // namespace voe
 }  // namespace webrtc