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

webrtc/voice_engine/channel_manager.cc

 /*
  *  Copyright (c) 2011 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 27 matching lines @@
 
   channel_ref_ = other.channel_ref_;
   ++channel_ref_->ref_count;
 
   return *this;
 }
 
 ChannelOwner::ChannelRef::ChannelRef(class Channel* channel)
     : channel(channel), ref_count(1) {}
 
-ChannelManager::ChannelManager(uint32_t instance_id, const Config& config)
+ChannelManager::ChannelManager(uint32_t instance_id,
+                               const Config& config,
+                               RtcEventLog* const event_log)
     : instance_id_(instance_id),
       last_channel_id_(-1),
       lock_(CriticalSectionWrapper::CreateCriticalSection()),
-      config_(config) {}
+      config_(config),
+      event_log_(event_log) {
+}
 
 ChannelOwner ChannelManager::CreateChannel() {
-  return CreateChannelInternal(config_);
+  return CreateChannelInternal(config_, event_log_);
 }
 
-ChannelOwner ChannelManager::CreateChannel(const Config& external_config) {
-  return CreateChannelInternal(external_config);
+ChannelOwner ChannelManager::CreateChannel(const Config& external_config,
+                                           RtcEventLog* const event_log) {

[Henrik Grunell WebRTC, 2015/08/12 12:43:45]

Will we ever use another event log than the one given in the ctor? Could we let
ChannelManager own it and remove it from SharedData?

[ivoc, 2015/08/12 13:16:41]

That is certainly an option, do you think it would be better to let
ChannelManager own it than SharedData? 

[Henrik Grunell WebRTC, 2015/08/12 15:29:53]

I think the raw pointer should be avoided if not necessary, which it isn't then.
If we let SharedData or ChannelManager own doesn't matter that much.

[ivoc, 2015/08/13 07:49:23]

I'm not sure what you mean exactly by avoiding the raw pointer, do you mean
passing a scoped_ptr or scoped_ref_ptr instead in the constructors? 

[Henrik Grunell WebRTC, 2015/08/13 08:13:55]

I mean having a scoped_ptr only at one place only.

[ivoc, 2015/08/13 13:33:43]

Ah okay, that is a good point. I moved the RtcEventLog from SharedData to
ChannelManager to solve this. 

+  return CreateChannelInternal(external_config, event_log);
 }
 
-ChannelOwner ChannelManager::CreateChannelInternal(const Config& config) {
+ChannelOwner ChannelManager::CreateChannelInternal(
+    const Config& config,
+    RtcEventLog* const event_log) {
   Channel* channel;
-  Channel::CreateChannel(channel, ++last_channel_id_, instance_id_, config);
+  Channel::CreateChannel(channel, ++last_channel_id_, instance_id_, event_log,
+                         config);
   ChannelOwner channel_owner(channel);
 
   CriticalSectionScoped crit(lock_.get());
 
   channels_.push_back(channel_owner);
 
   return channel_owner;
 }
 
 ChannelOwner ChannelManager::GetChannel(int32_t channel_id) {
@@ skipping 67 matching lines @@
 bool ChannelManager::Iterator::IsValid() {
   return iterator_pos_ < channels_.size();
 }
 
 void ChannelManager::Iterator::Increment() {
   ++iterator_pos_;
 }
 
 }  // namespace voe
 }  // namespace webrtc