Hooked up RtcEventLog. It lives in Voice Engine and pointers are propagated to ACM and Call.

webrtc/video/call.cc

Index: webrtc/video/call.cc
diff --git a/webrtc/video/call.cc b/webrtc/video/call.cc
index a2f07aa590f24e20e09e90db512517cd167bf881..5bd879e0e845e731213ea33fa99ab58a62b9ad00 100644
--- a/webrtc/video/call.cc
+++ b/webrtc/video/call.cc
@@ -32,8 +32,10 @@
 #include "webrtc/system_wrappers/interface/trace.h"
 #include "webrtc/system_wrappers/interface/trace_event.h"
 #include "webrtc/video/audio_receive_stream.h"
+#include "webrtc/video/rtc_event_log.h"
 #include "webrtc/video/video_receive_stream.h"
 #include "webrtc/video/video_send_stream.h"
+#include "webrtc/voice_engine/include/voe_base.h"
 
 namespace webrtc {
 
@@ -143,6 +145,8 @@ class Call : public webrtc::Call, public PacketReceiver {
 
   VideoSendStream::RtpStateMap suspended_video_send_ssrcs_;
 
+  RtcEventLog* event_log_;
+
   DISALLOW_COPY_AND_ASSIGN(Call);
 };
 }  // namespace internal
@@ -172,6 +176,11 @@ Call::Call(const Call::Config& config)
     DCHECK_GE(config.bitrate_config.max_bitrate_bps,
               config.bitrate_config.start_bitrate_bps);
   }
+  if (config.voice_engine) {
+    VoEBase* voe_base = VoEBase::GetInterface(config.voice_engine);
+    event_log_ = voe_base->GetEventLog();
+    voe_base->Release();

[terelius, 2015/07/30 12:34:43]

I don't understand what 'sub-API' means in the documentation for GetInterface
and Release, so I have no idea whether it is safe to call Release while still
holding a pointer to the object. It seems to go against the idea of reference
counting...

In any case, GetInterface is allowed to fail and return a null pointer according
to the documentation. I think it we should test for this before setting
event_log_ abd calling Release

[ivoc, 2015/07/30 15:10:23]

Good point on null pointer, I added a check. 

About the GetInterface() and Release() calls, I still think this is the way the
VoE sub-APIs are supposed to be used, based on other examples in the codebase. I
suggest we wait for Henrik to return from his vacation and have a look at this,
and leave it as is for now.

+  }
 
   Trace::CreateTrace();
   module_process_thread_->Start();
@@ -268,6 +277,9 @@ webrtc::VideoSendStream* Call::CreateVideoSendStream(
   }
   video_send_streams_.insert(send_stream);
 
+  if (event_log_)
+    event_log_->LogVideoSendStreamConfig(config);
+
   if (!network_enabled_)
     send_stream->SignalNetworkState(kNetworkDown);
   return send_stream;
@@ -334,6 +346,9 @@ webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
   if (!network_enabled_)
     receive_stream->SignalNetworkState(kNetworkDown);
 
+  if (event_log_)
+    event_log_->LogVideoReceiveStreamConfig(config);
+
   return receive_stream;
 }
 
@@ -495,15 +510,21 @@ PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type,
   if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
     ReadLockScoped read_lock(*receive_crit_);
     for (VideoReceiveStream* stream : video_receive_streams_) {
-      if (stream->DeliverRtcp(packet, length))
+      if (stream->DeliverRtcp(packet, length)) {
         rtcp_delivered = true;
+        if (event_log_)
+          event_log_->LogRtcpPacket(true, media_type, packet, length);
+      }
     }
   }
   if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
     ReadLockScoped read_lock(*send_crit_);
     for (VideoSendStream* stream : video_send_streams_) {
-      if (stream->DeliverRtcp(packet, length))
+      if (stream->DeliverRtcp(packet, length)) {
         rtcp_delivered = true;
+        if (event_log_)
+          event_log_->LogRtcpPacket(false, media_type, packet, length);
+      }
     }
   }
   return rtcp_delivered ? DELIVERY_OK : DELIVERY_PACKET_ERROR;
@@ -518,6 +539,10 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
 
   uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(&packet[8]);
 
+  // TODO(ivoc): This should be updated once the splitting of the header is done
+  //             in the RtcEventLog.
+  if (event_log_)
+    event_log_->LogRtpHeader(true, media_type, packet, 20, length);
   ReadLockScoped read_lock(*receive_crit_);
   if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
     auto it = audio_receive_ssrcs_.find(ssrc);