diff --git a/webrtc/call/bitrate_estimator_tests.cc b/webrtc/call/bitrate_estimator_tests.cc
index 50de542..d8ac9b4 100644
--- a/webrtc/call/bitrate_estimator_tests.cc
+++ b/webrtc/call/bitrate_estimator_tests.cc
@@ -277,8 +277,8 @@
       RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId));
   receiver_log_.PushExpectedLogLine(kSingleStreamLog);
   receiver_log_.PushExpectedLogLine(kSingleStreamLog);
-  receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
   receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
+  receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
   streams_.push_back(new Stream(this, false));
   EXPECT_TRUE(receiver_log_.Wait());
 }
@@ -293,8 +293,8 @@
 
   video_send_config_.rtp.extensions[0] =
       RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId);
-  receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
   receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
+  receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
   streams_.push_back(new Stream(this, false));
   EXPECT_TRUE(receiver_log_.Wait());
 }
@@ -309,16 +309,16 @@
 
   video_send_config_.rtp.extensions[0] =
       RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId);
-  receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
   receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
+  receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
   streams_.push_back(new Stream(this, false));
   EXPECT_TRUE(receiver_log_.Wait());
 
   video_send_config_.rtp.extensions[0] =
       RtpExtension(RtpExtension::kTOffset, kTOFExtensionId);
+  receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
   receiver_log_.PushExpectedLogLine(
       "WrappingBitrateEstimator: Switching to transmission time offset RBE.");
-  receiver_log_.PushExpectedLogLine(kSingleStreamLog);
   streams_.push_back(new Stream(this, false));
   streams_[0]->StopSending();
   streams_[1]->StopSending();
diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc
index 927a978..9a4c106 100644
--- a/webrtc/video/video_send_stream.cc
+++ b/webrtc/video/video_send_stream.cc
@@ -24,10 +24,7 @@
 #include "webrtc/modules/pacing/packet_router.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/video/call_stats.h"
-#include "webrtc/video/encoder_state_feedback.h"
 #include "webrtc/video/video_capture_input.h"
-#include "webrtc/video/vie_channel.h"
-#include "webrtc/video/vie_encoder.h"
 #include "webrtc/video/vie_remb.h"
 #include "webrtc/video_send_stream.h"
 
@@ -148,8 +145,33 @@
           this,
           config.post_encode_callback,
           &stats_proxy_),
-      encoder_feedback_(new EncoderStateFeedback()),
-      use_config_bitrate_(true) {
+      vie_encoder_(num_cpu_cores,
+                   module_process_thread_,
+                   &stats_proxy_,
+                   config.pre_encode_callback,
+                   &overuse_detector_,
+                   congestion_controller_->pacer(),
+                   &payload_router_,
+                   bitrate_allocator),
+      vcm_(vie_encoder_.vcm()),
+      vie_channel_(config.send_transport,
+                   module_process_thread_,
+                   &payload_router_,
+                   nullptr,
+                   encoder_feedback_.GetRtcpIntraFrameObserver(),
+                   congestion_controller_->GetBitrateController()
+                       ->CreateRtcpBandwidthObserver(),
+                   congestion_controller_->GetTransportFeedbackObserver(),
+                   nullptr,
+                   call_stats_->rtcp_rtt_stats(),
+                   congestion_controller_->pacer(),
+                   congestion_controller_->packet_router(),
+                   config_.rtp.ssrcs.size(),
+                   true),
+      input_(&vie_encoder_,
+             config_.local_renderer,
+             &stats_proxy_,
+             &overuse_detector_) {
   LOG(LS_INFO) << "VideoSendStream: " << config_.ToString();
 
   RTC_DCHECK(!config_.rtp.ssrcs.empty());
@@ -158,42 +180,14 @@
   RTC_DCHECK(congestion_controller_);
   RTC_DCHECK(remb_);
 
-  // Set up Call-wide sequence numbers, if configured for this send stream.
-  TransportFeedbackObserver* transport_feedback_observer = nullptr;
-  for (const RtpExtension& extension : config.rtp.extensions) {
-    if (extension.name == RtpExtension::kTransportSequenceNumber) {
-      transport_feedback_observer =
-          congestion_controller_->GetTransportFeedbackObserver();
-      break;
-    }
-  }
+  RTC_CHECK(vie_encoder_.Init());
+  RTC_CHECK(vie_channel_.Init() == 0);
 
-  const std::vector<uint32_t>& ssrcs = config.rtp.ssrcs;
+  vcm_->RegisterProtectionCallback(vie_channel_.vcm_protection_callback());
 
-  vie_encoder_.reset(new ViEEncoder(
-      num_cpu_cores, module_process_thread_, &stats_proxy_,
-      config.pre_encode_callback, &overuse_detector_,
-      congestion_controller_->pacer(), &payload_router_, bitrate_allocator));
-  vcm_ = vie_encoder_->vcm();
-  RTC_CHECK(vie_encoder_->Init());
+  call_stats_->RegisterStatsObserver(vie_channel_.GetStatsObserver());
 
-  vie_channel_.reset(new ViEChannel(
-      config.send_transport, module_process_thread_, &payload_router_, nullptr,
-      encoder_feedback_->GetRtcpIntraFrameObserver(),
-      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);
-
-  vcm_->RegisterProtectionCallback(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);
+  vie_encoder_.SetSsrcs(std::vector<uint32_t>(1, config_.rtp.ssrcs[0]));
 
   for (size_t i = 0; i < config_.rtp.extensions.size(); ++i) {
     const std::string& extension = config_.rtp.extensions[i].name;
@@ -202,19 +196,19 @@
     RTC_DCHECK_GE(id, 1);
     RTC_DCHECK_LE(id, 14);
     if (extension == RtpExtension::kTOffset) {
-      RTC_CHECK_EQ(0, vie_channel_->SetSendTimestampOffsetStatus(true, id));
+      RTC_CHECK_EQ(0, vie_channel_.SetSendTimestampOffsetStatus(true, id));
     } else if (extension == RtpExtension::kAbsSendTime) {
-      RTC_CHECK_EQ(0, vie_channel_->SetSendAbsoluteSendTimeStatus(true, id));
+      RTC_CHECK_EQ(0, vie_channel_.SetSendAbsoluteSendTimeStatus(true, id));
     } else if (extension == RtpExtension::kVideoRotation) {
-      RTC_CHECK_EQ(0, vie_channel_->SetSendVideoRotationStatus(true, id));
+      RTC_CHECK_EQ(0, vie_channel_.SetSendVideoRotationStatus(true, id));
     } else if (extension == RtpExtension::kTransportSequenceNumber) {
-      RTC_CHECK_EQ(0, vie_channel_->SetSendTransportSequenceNumber(true, id));
+      RTC_CHECK_EQ(0, vie_channel_.SetSendTransportSequenceNumber(true, id));
     } else {
       RTC_NOTREACHED() << "Registering unsupported RTP extension.";
     }
   }
 
-  RtpRtcp* rtp_module = vie_channel_->rtp_rtcp();
+  RtpRtcp* rtp_module = vie_channel_.rtp_rtcp();
   remb_->AddRembSender(rtp_module);
   rtp_module->SetREMBStatus(true);
 
@@ -222,49 +216,45 @@
   const bool enable_protection_nack = config_.rtp.nack.rtp_history_ms > 0;
   const bool enable_protection_fec = config_.rtp.fec.red_payload_type != -1;
   // TODO(changbin): Should set RTX for RED mapping in RTP sender in future.
-  vie_channel_->SetProtectionMode(enable_protection_nack, enable_protection_fec,
+  vie_channel_.SetProtectionMode(enable_protection_nack, enable_protection_fec,
                                   config_.rtp.fec.red_payload_type,
                                   config_.rtp.fec.ulpfec_payload_type);
-  vie_encoder_->SetProtectionMethod(enable_protection_nack,
+  vie_encoder_.SetProtectionMethod(enable_protection_nack,
                                     enable_protection_fec);
 
   ConfigureSsrcs();
 
-  vie_channel_->SetRTCPCName(config_.rtp.c_name.c_str());
-
-  input_.reset(new internal::VideoCaptureInput(
-      vie_encoder_.get(), config_.local_renderer, &stats_proxy_,
-      &overuse_detector_));
+  vie_channel_.SetRTCPCName(config_.rtp.c_name.c_str());
 
   // 28 to match packet overhead in ModuleRtpRtcpImpl.
   RTC_DCHECK_LE(config_.rtp.max_packet_size, static_cast<size_t>(0xFFFF - 28));
-  vie_channel_->SetMTU(static_cast<uint16_t>(config_.rtp.max_packet_size + 28));
+  vie_channel_.SetMTU(static_cast<uint16_t>(config_.rtp.max_packet_size + 28));
 
   RTC_DCHECK(config.encoder_settings.encoder != nullptr);
   RTC_DCHECK_GE(config.encoder_settings.payload_type, 0);
   RTC_DCHECK_LE(config.encoder_settings.payload_type, 127);
-  RTC_CHECK_EQ(0, vie_encoder_->RegisterExternalEncoder(
+  RTC_CHECK_EQ(0, vie_encoder_.RegisterExternalEncoder(
                       config.encoder_settings.encoder,
                       config.encoder_settings.payload_type,
                       config.encoder_settings.internal_source));
 
   RTC_CHECK(ReconfigureVideoEncoder(encoder_config));
 
-  vie_channel_->RegisterSendSideDelayObserver(&stats_proxy_);
+  vie_channel_.RegisterSendSideDelayObserver(&stats_proxy_);
 
   if (config_.post_encode_callback)
-    vie_encoder_->RegisterPostEncodeImageCallback(&encoded_frame_proxy_);
+    vie_encoder_.RegisterPostEncodeImageCallback(&encoded_frame_proxy_);
 
   if (config_.suspend_below_min_bitrate)
-    vie_encoder_->SuspendBelowMinBitrate();
+    vie_encoder_.SuspendBelowMinBitrate();
 
-  encoder_feedback_->AddEncoder(ssrcs, vie_encoder_.get());
+  encoder_feedback_.AddEncoder(config_.rtp.ssrcs, &vie_encoder_);
 
-  vie_channel_->RegisterSendChannelRtcpStatisticsCallback(&stats_proxy_);
-  vie_channel_->RegisterSendChannelRtpStatisticsCallback(&stats_proxy_);
-  vie_channel_->RegisterRtcpPacketTypeCounterObserver(&stats_proxy_);
-  vie_channel_->RegisterSendBitrateObserver(&stats_proxy_);
-  vie_channel_->RegisterSendFrameCountObserver(&stats_proxy_);
+  vie_channel_.RegisterSendChannelRtcpStatisticsCallback(&stats_proxy_);
+  vie_channel_.RegisterSendChannelRtpStatisticsCallback(&stats_proxy_);
+  vie_channel_.RegisterRtcpPacketTypeCounterObserver(&stats_proxy_);
+  vie_channel_.RegisterSendBitrateObserver(&stats_proxy_);
+  vie_channel_.RegisterSendFrameCountObserver(&stats_proxy_);
 
   module_process_thread_->RegisterModule(&overuse_detector_);
 }
@@ -276,53 +266,49 @@
   // 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);
-  vie_channel_->RegisterSendChannelRtpStatisticsCallback(nullptr);
-  vie_channel_->RegisterSendChannelRtcpStatisticsCallback(nullptr);
+  vie_channel_.RegisterSendFrameCountObserver(nullptr);
+  vie_channel_.RegisterSendBitrateObserver(nullptr);
+  vie_channel_.RegisterRtcpPacketTypeCounterObserver(nullptr);
+  vie_channel_.RegisterSendChannelRtpStatisticsCallback(nullptr);
+  vie_channel_.RegisterSendChannelRtcpStatisticsCallback(nullptr);
 
-  // Remove capture input (thread) so that it's not running after the current
-  // channel is deleted.
-  input_.reset();
-
-  vie_encoder_->DeRegisterExternalEncoder(
+  vie_encoder_.DeRegisterExternalEncoder(
       config_.encoder_settings.payload_type);
 
-  call_stats_->DeregisterStatsObserver(vie_channel_->GetStatsObserver());
+  call_stats_->DeregisterStatsObserver(vie_channel_.GetStatsObserver());
 
-  RtpRtcp* rtp_module = vie_channel_->rtp_rtcp();
+  RtpRtcp* rtp_module = vie_channel_.rtp_rtcp();
   rtp_module->SetREMBStatus(false);
   remb_->RemoveRembSender(rtp_module);
 
   // Remove the feedback, stop all encoding threads and processing. This must be
   // done before deleting the channel.
-  encoder_feedback_->RemoveEncoder(vie_encoder_.get());
+  encoder_feedback_.RemoveEncoder(&vie_encoder_);
 
-  uint32_t remote_ssrc = vie_channel_->GetRemoteSSRC();
+  uint32_t remote_ssrc = vie_channel_.GetRemoteSSRC();
   congestion_controller_->GetRemoteBitrateEstimator(false)->RemoveStream(
       remote_ssrc);
 }
 
 VideoCaptureInput* VideoSendStream::Input() {
-  return input_.get();
+  return &input_;
 }
 
 void VideoSendStream::Start() {
   transport_adapter_.Enable();
-  vie_encoder_->Pause();
-  if (vie_channel_->StartSend() == 0) {
+  vie_encoder_.Pause();
+  if (vie_channel_.StartSend() == 0) {
     // Was not already started, trigger a keyframe.
-    vie_encoder_->SendKeyFrame();
+    vie_encoder_.SendKeyFrame();
   }
-  vie_encoder_->Restart();
-  vie_channel_->StartReceive();
+  vie_encoder_.Restart();
+  vie_channel_.StartReceive();
 }
 
 void VideoSendStream::Stop() {
   // TODO(pbos): Make sure the encoder stops here.
-  vie_channel_->StopSend();
-  vie_channel_->StopReceive();
+  vie_channel_.StopSend();
+  vie_channel_.StopReceive();
   transport_adapter_.Disable();
 }
 
@@ -472,15 +458,14 @@
   stats_proxy_.SetContentType(config.content_type);
 
   RTC_DCHECK_GE(config.min_transmit_bitrate_bps, 0);
-  vie_encoder_->SetMinTransmitBitrate(config.min_transmit_bitrate_bps / 1000);
+  vie_encoder_.SetMinTransmitBitrate(config.min_transmit_bitrate_bps / 1000);
 
   encoder_config_ = config;
-  use_config_bitrate_ = false;
   return true;
 }
 
 bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
-  return vie_channel_->ReceivedRTCPPacket(packet, length) == 0;
+  return vie_channel_.ReceivedRTCPPacket(packet, length) == 0;
 }
 
 VideoSendStream::Stats VideoSendStream::GetStats() {
@@ -498,14 +483,14 @@
 }
 
 void VideoSendStream::ConfigureSsrcs() {
-  vie_channel_->SetSSRC(config_.rtp.ssrcs.front(), kViEStreamTypeNormal, 0);
+  vie_channel_.SetSSRC(config_.rtp.ssrcs.front(), kViEStreamTypeNormal, 0);
   for (size_t i = 0; i < config_.rtp.ssrcs.size(); ++i) {
     uint32_t ssrc = config_.rtp.ssrcs[i];
-    vie_channel_->SetSSRC(ssrc, kViEStreamTypeNormal,
+    vie_channel_.SetSSRC(ssrc, kViEStreamTypeNormal,
                           static_cast<unsigned char>(i));
     RtpStateMap::iterator it = suspended_ssrcs_.find(ssrc);
     if (it != suspended_ssrcs_.end())
-      vie_channel_->SetRtpStateForSsrc(ssrc, it->second);
+      vie_channel_.SetRtpStateForSsrc(ssrc, it->second);
   }
 
   if (config_.rtp.rtx.ssrcs.empty()) {
@@ -516,19 +501,19 @@
   RTC_DCHECK_EQ(config_.rtp.rtx.ssrcs.size(), config_.rtp.ssrcs.size());
   for (size_t i = 0; i < config_.rtp.rtx.ssrcs.size(); ++i) {
     uint32_t ssrc = config_.rtp.rtx.ssrcs[i];
-    vie_channel_->SetSSRC(config_.rtp.rtx.ssrcs[i], kViEStreamTypeRtx,
+    vie_channel_.SetSSRC(config_.rtp.rtx.ssrcs[i], kViEStreamTypeRtx,
                           static_cast<unsigned char>(i));
     RtpStateMap::iterator it = suspended_ssrcs_.find(ssrc);
     if (it != suspended_ssrcs_.end())
-      vie_channel_->SetRtpStateForSsrc(ssrc, it->second);
+      vie_channel_.SetRtpStateForSsrc(ssrc, it->second);
   }
 
   RTC_DCHECK_GE(config_.rtp.rtx.payload_type, 0);
-  vie_channel_->SetRtxSendPayloadType(config_.rtp.rtx.payload_type,
+  vie_channel_.SetRtxSendPayloadType(config_.rtp.rtx.payload_type,
                                       config_.encoder_settings.payload_type);
   if (config_.rtp.fec.red_payload_type != -1 &&
       config_.rtp.fec.red_rtx_payload_type != -1) {
-    vie_channel_->SetRtxSendPayloadType(config_.rtp.fec.red_rtx_payload_type,
+    vie_channel_.SetRtxSendPayloadType(config_.rtp.fec.red_rtx_payload_type,
                                         config_.rtp.fec.red_payload_type);
   }
 }
@@ -537,12 +522,12 @@
   std::map<uint32_t, RtpState> rtp_states;
   for (size_t i = 0; i < config_.rtp.ssrcs.size(); ++i) {
     uint32_t ssrc = config_.rtp.ssrcs[i];
-    rtp_states[ssrc] = vie_channel_->GetRtpStateForSsrc(ssrc);
+    rtp_states[ssrc] = vie_channel_.GetRtpStateForSsrc(ssrc);
   }
 
   for (size_t i = 0; i < config_.rtp.rtx.ssrcs.size(); ++i) {
     uint32_t ssrc = config_.rtp.rtx.ssrcs[i];
-    rtp_states[ssrc] = vie_channel_->GetRtpStateForSsrc(ssrc);
+    rtp_states[ssrc] = vie_channel_.GetRtpStateForSsrc(ssrc);
   }
 
   return rtp_states;
@@ -553,10 +538,10 @@
   // When it goes down, disable RTCP afterwards. This ensures that any packets
   // sent due to the network state changed will not be dropped.
   if (state == kNetworkUp)
-    vie_channel_->SetRTCPMode(config_.rtp.rtcp_mode);
-  vie_encoder_->SetNetworkTransmissionState(state == kNetworkUp);
+    vie_channel_.SetRTCPMode(config_.rtp.rtcp_mode);
+  vie_encoder_.SetNetworkTransmissionState(state == kNetworkUp);
   if (state == kNetworkDown)
-    vie_channel_->SetRTCPMode(RtcpMode::kOff);
+    vie_channel_.SetRTCPMode(RtcpMode::kOff);
 }
 
 int64_t VideoSendStream::GetRtt() const {
@@ -566,7 +551,7 @@
   uint32_t extended_max_sequence_number;
   uint32_t jitter;
   int64_t rtt_ms;
-  if (vie_channel_->GetSendRtcpStatistics(&frac_lost, &cumulative_lost,
+  if (vie_channel_.GetSendRtcpStatistics(&frac_lost, &cumulative_lost,
                                           &extended_max_sequence_number,
                                           &jitter, &rtt_ms) == 0) {
     return rtt_ms;
@@ -575,7 +560,7 @@
 }
 
 int VideoSendStream::GetPaddingNeededBps() const {
-  return vie_encoder_->GetPaddingNeededBps();
+  return vie_encoder_.GetPaddingNeededBps();
 }
 
 bool VideoSendStream::SetSendCodec(VideoCodec video_codec) {
@@ -593,14 +578,14 @@
     video_codec.maxBitrate = kEncoderMinBitrate;
 
   // Stop the media flow while reconfiguring.
-  vie_encoder_->Pause();
+  vie_encoder_.Pause();
 
-  if (vie_encoder_->SetEncoder(video_codec) != 0) {
+  if (vie_encoder_.SetEncoder(video_codec) != 0) {
     LOG(LS_ERROR) << "Failed to set encoder.";
     return false;
   }
 
-  if (vie_channel_->SetSendCodec(video_codec, false) != 0) {
+  if (vie_channel_.SetSendCodec(video_codec, false) != 0) {
     LOG(LS_ERROR) << "Failed to set send codec.";
     return false;
   }
@@ -609,13 +594,12 @@
   // to send on all SSRCs at once etc.)
   std::vector<uint32_t> used_ssrcs = config_.rtp.ssrcs;
   used_ssrcs.resize(static_cast<size_t>(video_codec.numberOfSimulcastStreams));
-  vie_encoder_->SetSsrcs(used_ssrcs);
+  vie_encoder_.SetSsrcs(used_ssrcs);
 
   // Restart the media flow
-  vie_encoder_->Restart();
+  vie_encoder_.Restart();
 
   return true;
 }
-
 }  // namespace internal
 }  // namespace webrtc
diff --git a/webrtc/video/video_send_stream.h b/webrtc/video/video_send_stream.h
index 11d5e6d..4359e60 100644
--- a/webrtc/video/video_send_stream.h
+++ b/webrtc/video/video_send_stream.h
@@ -19,9 +19,12 @@
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/video/encoded_frame_callback_adapter.h"
+#include "webrtc/video/encoder_state_feedback.h"
 #include "webrtc/video/payload_router.h"
 #include "webrtc/video/send_statistics_proxy.h"
 #include "webrtc/video/video_capture_input.h"
+#include "webrtc/video/vie_channel.h"
+#include "webrtc/video/vie_encoder.h"
 #include "webrtc/video_receive_stream.h"
 #include "webrtc/video_send_stream.h"
 
@@ -30,7 +33,6 @@
 class BitrateAllocator;
 class CallStats;
 class CongestionController;
-class EncoderStateFeedback;
 class ProcessThread;
 class ViEChannel;
 class ViEEncoder;
@@ -91,19 +93,12 @@
   VieRemb* const remb_;
 
   OveruseFrameDetector overuse_detector_;
-  rtc::scoped_ptr<VideoCaptureInput> input_;
   PayloadRouter payload_router_;
-  rtc::scoped_ptr<ViEEncoder> vie_encoder_;
-  rtc::scoped_ptr<ViEChannel> vie_channel_;
-  // TODO(pbos): Make proper const.
-  // const after construction.
-  VideoCodingModule* vcm_;
-  rtc::scoped_ptr<EncoderStateFeedback> encoder_feedback_;
-
-  // Used as a workaround to indicate that we should be using the configured
-  // start bitrate initially, instead of the one reported by VideoEngine (which
-  // defaults to too high).
-  bool use_config_bitrate_;
+  ViEEncoder vie_encoder_;
+  VideoCodingModule* const vcm_;
+  EncoderStateFeedback encoder_feedback_;
+  ViEChannel vie_channel_;
+  VideoCaptureInput input_;
 };
 }  // namespace internal
 }  // namespace webrtc
diff --git a/webrtc/video/vie_channel.cc b/webrtc/video/vie_channel.cc
index 532979d..1ac2278 100644
--- a/webrtc/video/vie_channel.cc
+++ b/webrtc/video/vie_channel.cc
@@ -638,7 +638,7 @@
   }
 }
 
-RtpState ViEChannel::GetRtpStateForSsrc(uint32_t ssrc) {
+RtpState ViEChannel::GetRtpStateForSsrc(uint32_t ssrc) const {
   RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending());
   RtpState rtp_state;
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
@@ -664,7 +664,7 @@
                                           uint32_t* cumulative_lost,
                                           uint32_t* extended_max,
                                           uint32_t* jitter_samples,
-                                          int64_t* rtt_ms) {
+                                          int64_t* rtt_ms) const {
   // Aggregate the report blocks associated with streams sent on this channel.
   std::vector<RTCPReportBlock> report_blocks;
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
diff --git a/webrtc/video/vie_channel.h b/webrtc/video/vie_channel.h
index f7fc7b2..e9f380e 100644
--- a/webrtc/video/vie_channel.h
+++ b/webrtc/video/vie_channel.h
@@ -112,7 +112,7 @@
   int SetRtxSendPayloadType(int payload_type, int associated_payload_type);
 
   void SetRtpStateForSsrc(uint32_t ssrc, const RtpState& rtp_state);
-  RtpState GetRtpStateForSsrc(uint32_t ssrc);
+  RtpState GetRtpStateForSsrc(uint32_t ssrc) const;
 
   // Sets the CName for the outgoing stream on the channel.
   int32_t SetRTCPCName(const char* rtcp_cname);
@@ -126,7 +126,7 @@
                                 uint32_t* cumulative_lost,
                                 uint32_t* extended_max,
                                 uint32_t* jitter_samples,
-                                int64_t* rtt_ms);
+                                int64_t* rtt_ms) const;
 
   // Called on receipt of RTCP report block from remote side.
   void RegisterSendChannelRtcpStatisticsCallback(
diff --git a/webrtc/video/vie_receiver.cc b/webrtc/video/vie_receiver.cc
index 24c9aad..8fcb380 100644
--- a/webrtc/video/vie_receiver.cc
+++ b/webrtc/video/vie_receiver.cc
@@ -55,9 +55,7 @@
       receiving_ast_enabled_(false),
       receiving_cvo_enabled_(false),
       receiving_tsn_enabled_(false),
-      last_packet_log_ms_(-1) {
-  assert(remote_bitrate_estimator);
-}
+      last_packet_log_ms_(-1) {}
 
 ViEReceiver::~ViEReceiver() {
   UpdateHistograms();
@@ -246,6 +244,7 @@
 bool ViEReceiver::DeliverRtp(const uint8_t* rtp_packet,
                              size_t rtp_packet_length,
                              const PacketTime& packet_time) {
+  RTC_DCHECK(remote_bitrate_estimator_);
   {
     rtc::CritScope lock(&receive_cs_);
     if (!receiving_) {