Move RtcEventLog object from inside VoiceEngine to Call.

webrtc/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.
  */
 
 #include "webrtc/voice_engine/channel.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/common.h"
 #include "webrtc/config.h"
+#include "webrtc/call/rtc_event_log.h"
 #include "webrtc/modules/audio_device/include/audio_device.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/pacing/packet_router.h"
 #include "webrtc/modules/rtp_rtcp/include/receive_statistics.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_payload_registry.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h"
 #include "webrtc/modules/utility/include/audio_frame_operations.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/voice_engine/include/voe_base.h"
 #include "webrtc/voice_engine/include/voe_external_media.h"
 #include "webrtc/voice_engine/include/voe_rtp_rtcp.h"
 #include "webrtc/voice_engine/output_mixer.h"
 #include "webrtc/voice_engine/statistics.h"
 #include "webrtc/voice_engine/transmit_mixer.h"
 #include "webrtc/voice_engine/utility.h"
 
 #if defined(_WIN32)
 #include <Qos.h>
 #endif
 
 namespace webrtc {
 namespace voe {
 
+class RtcEventLogProxy : public webrtc::RtcEventLog {

[the sun, 2016/03/21 13:03:09]

final

[ivoc, 2016/03/22 13:44:55]

Done.

+ public:
+  RtcEventLogProxy() : event_log_(nullptr) {}
+
+  void SetBufferDuration(int64_t buffer_duration_us) {

[the sun, 2016/03/21 13:03:09]

"override" here and below

[ivoc, 2016/03/22 13:44:55]

Done.

+    rtc::CritScope lock(&crit_);
+    if (event_log_) {
+      event_log_->SetBufferDuration(buffer_duration_us);
+    }
+  }
+
+  void StartLogging(const std::string& file_name, int duration_ms) {

[the sun, 2016/03/21 13:03:09]

It seems to me this method will never be called on the proxy object. Only the
Log... functions will ever be called from the components the proxy is give to,
right?

If that's correct, remove the code and add RTC_NOTREACHED.

[ivoc, 2016/03/22 13:44:55]

You're correct, done.

+    rtc::CritScope lock(&crit_);
+    if (event_log_) {
+      event_log_->StartLogging(file_name, duration_ms);
+    }
+  }
+
+  bool StartLogging(rtc::PlatformFile log_file, int64_t max_size_bytes) {
+    rtc::CritScope lock(&crit_);
+    if (event_log_) {
+      return event_log_->StartLogging(log_file, max_size_bytes);
+    }
+    return false;
+  }
+
+  bool StartLogging(rtc::PlatformFile log_file) {
+    rtc::CritScope lock(&crit_);
+    if (event_log_) {
+      return event_log_->StartLogging(log_file);
+    }
+    return false;
+  }
+
+  void StopLogging() {
+    rtc::CritScope lock(&crit_);
+    if (event_log_) {
+      event_log_->StopLogging();
+    }
+  }
+
+  void LogVideoReceiveStreamConfig(
+      const webrtc::VideoReceiveStream::Config& config) {
+    rtc::CritScope lock(&crit_);
+    RTC_DCHECK(event_log_);
+    event_log_->LogVideoReceiveStreamConfig(config);
+  }
+
+  void LogVideoSendStreamConfig(const webrtc::VideoSendStream::Config& config) {
+    rtc::CritScope lock(&crit_);
+    RTC_DCHECK(event_log_);
+    event_log_->LogVideoSendStreamConfig(config);
+  }
+
+  void LogRtpHeader(webrtc::PacketDirection direction,
+                    webrtc::MediaType media_type,
+                    const uint8_t* header,
+                    size_t packet_length) {
+    rtc::CritScope lock(&crit_);
+    RTC_DCHECK(event_log_);

[the sun, 2016/03/21 13:03:09]

I don't see why you can DCHECK here but have to use a conditional above. Please
explain?

[ivoc, 2016/03/22 13:44:55]

I was thinking about the lifetimes of the AudioReceiveStream compared to the
lifetime of the objects calling the LogX() functions (i.e. VoE Channel). I
thought it might be possible for the LogX functions to be called after the
AudioReceiveStream is destroyed (which replaces the event_log_ with a nullptr),
but before the VoE Channel is destroyed.
Thinking about it a bit more, there should probably be conditionals everywhere
to prevent this issue.

[the sun, 2016/03/23 10:26:44]

Well, that, and we must also account for the scenario where the Channel is used
without an AudioSend/ReceiveStream.

+    event_log_->LogRtpHeader(direction, media_type, header, packet_length);
+  }
+
+  void LogRtcpPacket(webrtc::PacketDirection direction,
+                     webrtc::MediaType media_type,
+                     const uint8_t* packet,
+                     size_t length) {
+    rtc::CritScope lock(&crit_);
+    RTC_DCHECK(event_log_);
+    event_log_->LogRtcpPacket(direction, media_type, packet, length);
+  }
+
+  void LogAudioPlayout(uint32_t ssrc) {
+    rtc::CritScope lock(&crit_);
+    if (event_log_) {
+      event_log_->LogAudioPlayout(ssrc);
+    }
+  }
+
+  void LogBwePacketLossEvent(int32_t bitrate,
+                             uint8_t fraction_loss,
+                             int32_t total_packets) {
+    rtc::CritScope lock(&crit_);
+    RTC_DCHECK(event_log_);
+    event_log_->LogBwePacketLossEvent(bitrate, fraction_loss, total_packets);
+  }
+
+  static bool ParseRtcEventLog(const std::string& file_name,

[the sun, 2016/03/21 13:03:09]

Remove

[ivoc, 2016/03/22 13:44:55]

Done.

+                               webrtc::rtclog::EventStream* result);
+
+  void SetEventLog(RtcEventLog* event_log) {
+    rtc::CritScope lock(&crit_);
+    event_log_ = event_log;
+  }
+
+ private:
+  rtc::CriticalSection crit_;
+  RtcEventLog* event_log_ GUARDED_BY(crit_);

[the sun, 2016/03/21 13:03:09]

RTC_DISALLOW_COPY_AND_ASSIGN

[ivoc, 2016/03/22 13:44:55]

Done.

+};
+
 class TransportFeedbackProxy : public TransportFeedbackObserver {
  public:
   TransportFeedbackProxy() : feedback_observer_(nullptr) {
     pacer_thread_.DetachFromThread();
     network_thread_.DetachFromThread();
   }
 
   void SetTransportFeedbackObserver(
       TransportFeedbackObserver* feedback_observer) {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 427 matching lines @@
     return false;
   }
   header.payload_type_frequency =
       rtp_payload_registry_->GetPayloadTypeFrequency(header.payloadType);
   if (header.payload_type_frequency < 0)
     return false;
   return ReceivePacket(rtp_packet, rtp_packet_length, header, false);
 }
 
 int32_t Channel::GetAudioFrame(int32_t id, AudioFrame* audioFrame) {
-  if (event_log_) {
-    unsigned int ssrc;
-    RTC_CHECK_EQ(GetLocalSSRC(ssrc), 0);
-    event_log_->LogAudioPlayout(ssrc);
-  }
+  unsigned int ssrc;
+  RTC_CHECK_EQ(GetLocalSSRC(ssrc), 0);
+  event_log_->LogAudioPlayout(ssrc);
   // Get 10ms raw PCM data from the ACM (mixer limits output frequency)
   if (audio_coding_->PlayoutData10Ms(audioFrame->sample_rate_hz_, audioFrame) ==
       -1) {
     WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, _channelId),
                  "Channel::GetAudioFrame() PlayoutData10Ms() failed!");
     // In all likelihood, the audio in this frame is garbage. We return an
     // error so that the audio mixer module doesn't add it to the mix. As
     // a result, it won't be played out and the actions skipped here are
     // irrelevant.
     return -1;
@@ skipping 155 matching lines @@
       }
     }
   }
 
   return (highestNeeded);
 }
 
 int32_t Channel::CreateChannel(Channel*& channel,
                                int32_t channelId,
                                uint32_t instanceId,
-                               RtcEventLog* const event_log,
                                const Config& config) {
   WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(instanceId, channelId),
                "Channel::CreateChannel(channelId=%d, instanceId=%d)", channelId,
                instanceId);
 
-  channel = new Channel(channelId, instanceId, event_log, config);
+  channel = new Channel(channelId, instanceId, config);
   if (channel == NULL) {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(instanceId, channelId),
                  "Channel::CreateChannel() unable to allocate memory for"
                  " channel");
     return -1;
   }
   return 0;
 }
 
 void Channel::PlayNotification(int32_t id, uint32_t durationMs) {
@@ skipping 36 matching lines @@
   assert(id == _outputFileRecorderId);
 
   rtc::CritScope cs(&_fileCritSect);
 
   _outputFileRecording = false;
   WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::RecordFileEnded() => output file recorder module is"
                " shutdown");
 }
 
-Channel::Channel(int32_t channelId,
-                 uint32_t instanceId,
-                 RtcEventLog* const event_log,
-                 const Config& config)
+Channel::Channel(int32_t channelId, uint32_t instanceId, const Config& config)
     : _instanceId(instanceId),
       _channelId(channelId),
-      event_log_(event_log),
+      event_log_(new RtcEventLogProxy()),
       rtp_header_parser_(RtpHeaderParser::Create()),
       rtp_payload_registry_(
           new RTPPayloadRegistry(RTPPayloadStrategy::CreateStrategy(true))),
       rtp_receive_statistics_(
           ReceiveStatistics::Create(Clock::GetRealTimeClock())),
       rtp_receiver_(
           RtpReceiver::CreateAudioReceiver(Clock::GetRealTimeClock(),
                                            this,
                                            this,
                                            this,
@@ skipping 88 matching lines @@
   configuration.outgoing_transport = this;
   configuration.audio_messages = this;
   configuration.receive_statistics = rtp_receive_statistics_.get();
   configuration.bandwidth_callback = rtcp_observer_.get();
   if (pacing_enabled_) {
     configuration.paced_sender = rtp_packet_sender_proxy_.get();
     configuration.transport_sequence_number_allocator =
         seq_num_allocator_proxy_.get();
     configuration.transport_feedback_callback = feedback_observer_proxy_.get();
   }
-  configuration.event_log = event_log;
+  configuration.event_log = &*event_log_;

[the sun, 2016/03/21 13:03:09]

nit: add () around *event_log_ for clarity.

[ivoc, 2016/03/22 13:44:55]

Done.

 
   _rtpRtcpModule.reset(RtpRtcp::CreateRtpRtcp(configuration));
 
   statistics_proxy_.reset(new StatisticsProxy(_rtpRtcpModule->SSRC()));
   rtp_receive_statistics_->RegisterRtcpStatisticsCallback(
       statistics_proxy_.get());
 
   Config audioproc_config;
   audioproc_config.Set<ExperimentalAgc>(new ExperimentalAgc(false));
   rx_audioproc_.reset(AudioProcessing::Create(audioproc_config));
@@ skipping 2213 matching lines @@
   rtc::CritScope lock(&assoc_send_channel_lock_);
   Channel* channel = associate_send_channel_.channel();
   if (channel && channel->ChannelId() == channel_id) {
     // If this channel is associated with a send channel of the specified
     // Channel ID, disassociate with it.
     ChannelOwner ref(NULL);
     associate_send_channel_ = ref;
   }
 }
 
+void Channel::SetRtcEventLog(RtcEventLog* event_log) {
+  event_log_->SetEventLog(event_log);
+}
+
 int Channel::RegisterExternalMediaProcessing(ProcessingTypes type,
                                              VoEMediaProcess& processObject) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::RegisterExternalMediaProcessing()");
 
   rtc::CritScope cs(&_callbackCritSect);
 
   if (kPlaybackPerChannel == type) {
     if (_outputExternalMediaCallbackPtr) {
       _engineStatisticsPtr->SetLastError(
@@ skipping 551 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