Untangle ViEChannel and ViEEncoder.

webrtc/video/video_send_stream.cc

Index: webrtc/video/video_send_stream.cc
diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc
index 656d5517941754df85a99a073d9634718a46c365..653b2841933a249f8761bc473240e2a2140483d1 100644
--- a/webrtc/video/video_send_stream.cc
+++ b/webrtc/video/video_send_stream.cc
@@ -24,7 +24,6 @@
 #include "webrtc/modules/pacing/packet_router.h"
 #include "webrtc/video/call_stats.h"
 #include "webrtc/video/encoder_state_feedback.h"
-#include "webrtc/video/payload_router.h"
 #include "webrtc/video/video_capture_input.h"
 #include "webrtc/video/vie_channel.h"
 #include "webrtc/video/vie_encoder.h"
@@ -124,7 +123,6 @@ VideoSendStream::VideoSendStream(
       encoded_frame_proxy_(config.post_encode_callback),
       config_(config),
       suspended_ssrcs_(suspended_ssrcs),
-      module_process_thread_(module_process_thread),
       call_stats_(call_stats),
       congestion_controller_(congestion_controller),
       encoder_feedback_(new EncoderStateFeedback()),
@@ -144,28 +142,27 @@ VideoSendStream::VideoSendStream(
 
   const std::vector<uint32_t>& ssrcs = config.rtp.ssrcs;
 
-  vie_encoder_.reset(new ViEEncoder(
-      num_cpu_cores, module_process_thread_, &stats_proxy_,
-      config.pre_encode_callback, congestion_controller_->pacer(),
-      bitrate_allocator));
+  vie_encoder_.reset(new ViEEncoder(num_cpu_cores, module_process_thread,
+                                    &stats_proxy_, config.pre_encode_callback,
+                                    congestion_controller_->pacer(),
+                                    &payload_router_, bitrate_allocator));
+  vcm_ = vie_encoder_->vcm();
   RTC_CHECK(vie_encoder_->Init());
 
   vie_channel_.reset(new ViEChannel(
-      num_cpu_cores, config.send_transport, module_process_thread_,
-      encoder_feedback_->GetRtcpIntraFrameObserver(),
-      congestion_controller_->GetBitrateController()->
-          CreateRtcpBandwidthObserver(),
+      num_cpu_cores, config.send_transport, module_process_thread,
+      &payload_router_, vcm_, encoder_feedback_->GetRtcpIntraFrameObserver(),

[stefan-webrtc, 2016/02/01 19:04:44]

Is there any way we can make things a bit less complex by not passing a vcm_ to
ViEChannel for the send stream? Is this even the same behavior as before where
we created a separate vcm in ViEChannel?

+      congestion_controller_->GetBitrateController()
+          ->CreateRtcpBandwidthObserver(),
       transport_feedback_observer,
       congestion_controller_->GetRemoteBitrateEstimator(false),
       call_stats_->rtcp_rtt_stats(), congestion_controller_->pacer(),
       congestion_controller_->packet_router(), ssrcs.size(), true));
   RTC_CHECK(vie_channel_->Init() == 0);
 
-  call_stats_->RegisterStatsObserver(vie_channel_->GetStatsObserver());
+  vcm_->RegisterProtectionCallback(vie_channel_->vcm_protection_callback());
 
-  vie_encoder_->StartThreadsAndSetSharedMembers(
-      vie_channel_->send_payload_router(),
-      vie_channel_->vcm_protection_callback());
+  call_stats_->RegisterStatsObserver(vie_channel_->GetStatsObserver());
 
   std::vector<uint32_t> first_ssrc(1, ssrcs[0]);
   vie_encoder_->SetSsrcs(first_ssrc);
@@ -207,7 +204,7 @@ VideoSendStream::VideoSendStream(
   vie_channel_->SetRTCPCName(config_.rtp.c_name.c_str());
 
   input_.reset(new internal::VideoCaptureInput(
-      module_process_thread_, vie_encoder_.get(), config_.local_renderer,
+      module_process_thread, vie_encoder_.get(), config_.local_renderer,
       &stats_proxy_, this, config_.encoding_time_observer));
 
   // 28 to match packet overhead in ModuleRtpRtcpImpl.
@@ -244,6 +241,10 @@ VideoSendStream::VideoSendStream(
 
 VideoSendStream::~VideoSendStream() {
   LOG(LS_INFO) << "~VideoSendStream: " << config_.ToString();
+  // Remove vcm_protection_callback (part of vie_channel_) before destroying
+  // ViEChannel. vcm_ is owned by ViEEncoder and the registered callback does
+  // not outlive it.
+  vcm_->RegisterProtectionCallback(nullptr);
   vie_channel_->RegisterSendFrameCountObserver(nullptr);
   vie_channel_->RegisterSendBitrateObserver(nullptr);
   vie_channel_->RegisterRtcpPacketTypeCounterObserver(nullptr);
@@ -265,7 +266,6 @@ VideoSendStream::~VideoSendStream() {
   // done before deleting the channel.
   congestion_controller_->RemoveEncoder(vie_encoder_.get());
   encoder_feedback_->RemoveEncoder(vie_encoder_.get());
-  vie_encoder_->StopThreadsAndRemoveSharedMembers();
 
   uint32_t remote_ssrc = vie_channel_->GetRemoteSSRC();
   congestion_controller_->GetRemoteBitrateEstimator(false)->RemoveStream(