diff --git a/webrtc/audio/audio_receive_stream.cc b/webrtc/audio/audio_receive_stream.cc
index ebe271367b..b7311266ef 100644
--- a/webrtc/audio/audio_receive_stream.cc
+++ b/webrtc/audio/audio_receive_stream.cc
@@ -117,8 +117,8 @@ AudioReceiveStream::AudioReceiveStream(
     }
   }
   // Configure bandwidth estimation.
-  channel_proxy_->SetCongestionControlObjects(
-      nullptr, nullptr, congestion_controller->packet_router());
+  channel_proxy_->RegisterReceiverCongestionControlObjects(
+      congestion_controller->packet_router());
   if (config.combined_audio_video_bwe) {
     if (UseSendSideBwe(config)) {
       remote_bitrate_estimator_ =
@@ -134,7 +134,7 @@ AudioReceiveStream::AudioReceiveStream(
 AudioReceiveStream::~AudioReceiveStream() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "~AudioReceiveStream: " << config_.ToString();
-  channel_proxy_->SetCongestionControlObjects(nullptr, nullptr, nullptr);
+  channel_proxy_->ResetCongestionControlObjects();
   if (remote_bitrate_estimator_) {
     remote_bitrate_estimator_->RemoveStream(config_.rtp.remote_ssrc);
   }
diff --git a/webrtc/audio/audio_receive_stream_unittest.cc b/webrtc/audio/audio_receive_stream_unittest.cc
index b241bed6b5..fd88fc83df 100644
--- a/webrtc/audio/audio_receive_stream_unittest.cc
+++ b/webrtc/audio/audio_receive_stream_unittest.cc
@@ -94,13 +94,12 @@ struct ConfigHelper {
           EXPECT_CALL(*channel_proxy_, EnableReceiveTransportSequenceNumber(
                                            kTransportSequenceNumberId))
               .Times(1);
-          EXPECT_CALL(*channel_proxy_, SetCongestionControlObjects(
-                                           nullptr, nullptr, &packet_router_))
+          EXPECT_CALL(*channel_proxy_,
+                      RegisterReceiverCongestionControlObjects(&packet_router_))
               .Times(1);
           EXPECT_CALL(congestion_controller_, packet_router())
               .WillOnce(Return(&packet_router_));
-          EXPECT_CALL(*channel_proxy_,
-                      SetCongestionControlObjects(nullptr, nullptr, nullptr))
+          EXPECT_CALL(*channel_proxy_, ResetCongestionControlObjects())
               .Times(1);
           return channel_proxy_;
         }));
diff --git a/webrtc/audio/audio_send_stream.cc b/webrtc/audio/audio_send_stream.cc
index 35a65521dd..62121c63a5 100644
--- a/webrtc/audio/audio_send_stream.cc
+++ b/webrtc/audio/audio_send_stream.cc
@@ -68,7 +68,7 @@ AudioSendStream::AudioSendStream(
 
   VoiceEngineImpl* voe_impl = static_cast<VoiceEngineImpl*>(voice_engine());
   channel_proxy_ = voe_impl->GetChannelProxy(config_.voe_channel_id);
-  channel_proxy_->SetCongestionControlObjects(
+  channel_proxy_->RegisterSenderCongestionControlObjects(
       congestion_controller->pacer(),
       congestion_controller->GetTransportFeedbackObserver(),
       congestion_controller->packet_router());
@@ -92,7 +92,7 @@ AudioSendStream::AudioSendStream(
 AudioSendStream::~AudioSendStream() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "~AudioSendStream: " << config_.ToString();
-  channel_proxy_->SetCongestionControlObjects(nullptr, nullptr, nullptr);
+  channel_proxy_->ResetCongestionControlObjects();
 }
 
 void AudioSendStream::Start() {
diff --git a/webrtc/audio/audio_send_stream_unittest.cc b/webrtc/audio/audio_send_stream_unittest.cc
index 466c1571ac..a01ef025d3 100644
--- a/webrtc/audio/audio_send_stream_unittest.cc
+++ b/webrtc/audio/audio_send_stream_unittest.cc
@@ -83,13 +83,12 @@ struct ConfigHelper {
                                            kTransportSequenceNumberId))
               .Times(1);
           EXPECT_CALL(*channel_proxy_,
-                      SetCongestionControlObjects(
+                      RegisterSenderCongestionControlObjects(
                           congestion_controller_.pacer(),
                           congestion_controller_.GetTransportFeedbackObserver(),
                           congestion_controller_.packet_router()))
               .Times(1);
-          EXPECT_CALL(*channel_proxy_,
-                      SetCongestionControlObjects(nullptr, nullptr, nullptr))
+          EXPECT_CALL(*channel_proxy_, ResetCongestionControlObjects())
               .Times(1);
           return channel_proxy_;
         }));
diff --git a/webrtc/call/congestion_controller.cc b/webrtc/call/congestion_controller.cc
index 0267d79fca..e548a96999 100644
--- a/webrtc/call/congestion_controller.cc
+++ b/webrtc/call/congestion_controller.cc
@@ -171,9 +171,9 @@ CongestionController::CongestionController(ProcessThread* process_thread,
   call_stats_->RegisterStatsObserver(remote_bitrate_estimator_.get());
 
   pacer_thread_->RegisterModule(pacer_.get());
+  pacer_thread_->RegisterModule(remote_estimator_proxy_.get());
   pacer_thread_->Start();
 
-  process_thread->RegisterModule(remote_estimator_proxy_.get());
   process_thread->RegisterModule(remote_bitrate_estimator_.get());
   process_thread->RegisterModule(bitrate_controller_.get());
 }
@@ -181,9 +181,9 @@ CongestionController::CongestionController(ProcessThread* process_thread,
 CongestionController::~CongestionController() {
   pacer_thread_->Stop();
   pacer_thread_->DeRegisterModule(pacer_.get());
+  pacer_thread_->DeRegisterModule(remote_estimator_proxy_.get());
   process_thread_->DeRegisterModule(bitrate_controller_.get());
   process_thread_->DeRegisterModule(remote_bitrate_estimator_.get());
-  process_thread_->DeRegisterModule(remote_estimator_proxy_.get());
   call_stats_->DeregisterStatsObserver(remote_bitrate_estimator_.get());
   if (transport_feedback_adapter_.get())
     call_stats_->DeregisterStatsObserver(transport_feedback_adapter_.get());
diff --git a/webrtc/modules/pacing/packet_router.cc b/webrtc/modules/pacing/packet_router.cc
index 5fd350834a..e98ab0c2b0 100644
--- a/webrtc/modules/pacing/packet_router.cc
+++ b/webrtc/modules/pacing/packet_router.cc
@@ -18,33 +18,64 @@
 
 namespace webrtc {
 
+namespace {
+void AddModule(RtpRtcp* rtp_module, std::list<RtpRtcp*>* rtp_modules) {
+  RTC_DCHECK(std::find(rtp_modules->begin(), rtp_modules->end(), rtp_module) ==
+             rtp_modules->end());
+  rtp_modules->push_back(rtp_module);
+}
+
+void RemoveModule(RtpRtcp* rtp_module, std::list<RtpRtcp*>* rtp_modules) {
+  RTC_DCHECK(std::find(rtp_modules->begin(), rtp_modules->end(), rtp_module) !=
+             rtp_modules->end());
+  rtp_modules->remove(rtp_module);
+}
+
+bool SendFeedback(rtcp::TransportFeedback* packet,
+                  std::list<RtpRtcp*>* rtp_modules) {
+  for (auto* rtp_module : *rtp_modules) {
+    packet->WithPacketSenderSsrc(rtp_module->SSRC());
+    if (rtp_module->SendFeedbackPacket(*packet))
+      return true;
+  }
+  return false;
+}
+}
+
 PacketRouter::PacketRouter() : transport_seq_(0) {
+  pacer_thread_checker_.DetachFromThread();
 }
 
 PacketRouter::~PacketRouter() {
-  RTC_DCHECK(rtp_modules_.empty());
+  RTC_DCHECK(send_rtp_modules_.empty());
+  RTC_DCHECK(recv_rtp_modules_.empty());
 }
 
-void PacketRouter::AddRtpModule(RtpRtcp* rtp_module) {
-  rtc::CritScope cs(&modules_lock_);
-  RTC_DCHECK(std::find(rtp_modules_.begin(), rtp_modules_.end(), rtp_module) ==
-             rtp_modules_.end());
-  rtp_modules_.push_back(rtp_module);
+void PacketRouter::AddRtpModule(RtpRtcp* rtp_module, bool sender) {
+  rtc::CritScope cs(&modules_crit_);
+  if (sender) {
+    AddModule(rtp_module, &send_rtp_modules_);
+  } else {
+    AddModule(rtp_module, &recv_rtp_modules_);
+  }
 }
 
-void PacketRouter::RemoveRtpModule(RtpRtcp* rtp_module) {
-  rtc::CritScope cs(&modules_lock_);
-  auto it = std::find(rtp_modules_.begin(), rtp_modules_.end(), rtp_module);
-  RTC_DCHECK(it != rtp_modules_.end());
-  rtp_modules_.erase(it);
+void PacketRouter::RemoveRtpModule(RtpRtcp* rtp_module, bool sender) {
+  rtc::CritScope cs(&modules_crit_);
+  if (sender) {
+    RemoveModule(rtp_module, &send_rtp_modules_);
+  } else {
+    RemoveModule(rtp_module, &recv_rtp_modules_);
+  }
 }
 
 bool PacketRouter::TimeToSendPacket(uint32_t ssrc,
                                     uint16_t sequence_number,
                                     int64_t capture_timestamp,
                                     bool retransmission) {
-  rtc::CritScope cs(&modules_lock_);
-  for (auto* rtp_module : rtp_modules_) {
+  RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread());
+  rtc::CritScope cs(&modules_crit_);
+  for (auto* rtp_module : send_rtp_modules_) {
     if (rtp_module->SendingMedia() && ssrc == rtp_module->SSRC()) {
       return rtp_module->TimeToSendPacket(ssrc, sequence_number,
                                           capture_timestamp, retransmission);
@@ -54,9 +85,10 @@ bool PacketRouter::TimeToSendPacket(uint32_t ssrc,
 }
 
 size_t PacketRouter::TimeToSendPadding(size_t bytes_to_send) {
+  RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread());
   size_t total_bytes_sent = 0;
-  rtc::CritScope cs(&modules_lock_);
-  for (RtpRtcp* module : rtp_modules_) {
+  rtc::CritScope cs(&modules_crit_);
+  for (RtpRtcp* module : send_rtp_modules_) {
     if (module->SendingMedia()) {
       size_t bytes_sent =
           module->TimeToSendPadding(bytes_to_send - total_bytes_sent);
@@ -91,12 +123,12 @@ uint16_t PacketRouter::AllocateSequenceNumber() {
 }
 
 bool PacketRouter::SendFeedback(rtcp::TransportFeedback* packet) {
-  rtc::CritScope cs(&modules_lock_);
-  for (auto* rtp_module : rtp_modules_) {
-    packet->WithPacketSenderSsrc(rtp_module->SSRC());
-    if (rtp_module->SendFeedbackPacket(*packet))
-      return true;
-  }
+  RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread());
+  rtc::CritScope cs(&modules_crit_);
+  if (::webrtc::SendFeedback(packet, &recv_rtp_modules_))
+    return true;
+  if (::webrtc::SendFeedback(packet, &send_rtp_modules_))
+    return true;
   return false;
 }
 
diff --git a/webrtc/modules/pacing/packet_router.h b/webrtc/modules/pacing/packet_router.h
index edef1aa9b3..dd58faf4ea 100644
--- a/webrtc/modules/pacing/packet_router.h
+++ b/webrtc/modules/pacing/packet_router.h
@@ -17,6 +17,7 @@
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/thread_annotations.h"
+#include "webrtc/base/thread_checker.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/pacing/paced_sender.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
@@ -36,8 +37,8 @@ class PacketRouter : public PacedSender::Callback,
   PacketRouter();
   virtual ~PacketRouter();
 
-  void AddRtpModule(RtpRtcp* rtp_module);
-  void RemoveRtpModule(RtpRtcp* rtp_module);
+  void AddRtpModule(RtpRtcp* rtp_module, bool sender);
+  void RemoveRtpModule(RtpRtcp* rtp_module, bool sender);
 
   // Implements PacedSender::Callback.
   bool TimeToSendPacket(uint32_t ssrc,
@@ -54,9 +55,10 @@ class PacketRouter : public PacedSender::Callback,
   virtual bool SendFeedback(rtcp::TransportFeedback* packet);
 
  private:
-  rtc::CriticalSection modules_lock_;
-  // Map from ssrc to sending rtp module.
-  std::list<RtpRtcp*> rtp_modules_ GUARDED_BY(modules_lock_);
+  rtc::ThreadChecker pacer_thread_checker_;
+  rtc::CriticalSection modules_crit_;
+  std::list<RtpRtcp*> send_rtp_modules_ GUARDED_BY(modules_crit_);
+  std::list<RtpRtcp*> recv_rtp_modules_ GUARDED_BY(modules_crit_);
 
   volatile int transport_seq_;
 
diff --git a/webrtc/modules/pacing/packet_router_unittest.cc b/webrtc/modules/pacing/packet_router_unittest.cc
index 31acf44b9b..e5e05896c2 100644
--- a/webrtc/modules/pacing/packet_router_unittest.cc
+++ b/webrtc/modules/pacing/packet_router_unittest.cc
@@ -16,6 +16,7 @@
 #include "webrtc/modules/pacing/packet_router.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/base/scoped_ptr.h"
 
 using ::testing::_;
@@ -35,8 +36,8 @@ class PacketRouterTest : public ::testing::Test {
 TEST_F(PacketRouterTest, TimeToSendPacket) {
   MockRtpRtcp rtp_1;
   MockRtpRtcp rtp_2;
-  packet_router_->AddRtpModule(&rtp_1);
-  packet_router_->AddRtpModule(&rtp_2);
+  packet_router_->AddRtpModule(&rtp_1, true);
+  packet_router_->AddRtpModule(&rtp_2, true);
 
   const uint16_t kSsrc1 = 1234;
   uint16_t sequence_number = 17;
@@ -88,7 +89,7 @@ TEST_F(PacketRouterTest, TimeToSendPacket) {
   EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1 + kSsrc2, sequence_number,
                                                timestamp, retransmission));
 
-  packet_router_->RemoveRtpModule(&rtp_1);
+  packet_router_->RemoveRtpModule(&rtp_1, true);
 
   // rtp_1 has been removed, try sending a packet on that ssrc and make sure
   // it is dropped as expected by not expecting any calls to rtp_1.
@@ -98,7 +99,7 @@ TEST_F(PacketRouterTest, TimeToSendPacket) {
   EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number,
                                                timestamp, retransmission));
 
-  packet_router_->RemoveRtpModule(&rtp_2);
+  packet_router_->RemoveRtpModule(&rtp_2, true);
 }
 
 TEST_F(PacketRouterTest, TimeToSendPadding) {
@@ -109,8 +110,8 @@ TEST_F(PacketRouterTest, TimeToSendPadding) {
   EXPECT_CALL(rtp_1, SSRC()).WillRepeatedly(Return(kSsrc1));
   MockRtpRtcp rtp_2;
   EXPECT_CALL(rtp_2, SSRC()).WillRepeatedly(Return(kSsrc2));
-  packet_router_->AddRtpModule(&rtp_1);
-  packet_router_->AddRtpModule(&rtp_2);
+  packet_router_->AddRtpModule(&rtp_1, true);
+  packet_router_->AddRtpModule(&rtp_2, true);
 
   // Default configuration, sending padding on all modules sending media,
   // ordered by SSRC.
@@ -146,7 +147,7 @@ TEST_F(PacketRouterTest, TimeToSendPadding) {
   EXPECT_CALL(rtp_2, TimeToSendPadding(_)).Times(0);
   EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes));
 
-  packet_router_->RemoveRtpModule(&rtp_1);
+  packet_router_->RemoveRtpModule(&rtp_1, true);
 
   // rtp_1 has been removed, try sending padding and make sure rtp_1 isn't asked
   // to send by not expecting any calls. Instead verify rtp_2 is called.
@@ -154,7 +155,7 @@ TEST_F(PacketRouterTest, TimeToSendPadding) {
   EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes)).Times(1);
   EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes));
 
-  packet_router_->RemoveRtpModule(&rtp_2);
+  packet_router_->RemoveRtpModule(&rtp_2, true);
 }
 
 TEST_F(PacketRouterTest, AllocateSequenceNumbers) {
@@ -169,4 +170,19 @@ TEST_F(PacketRouterTest, AllocateSequenceNumbers) {
     EXPECT_EQ(static_cast<uint16_t>(expected_unwrapped_seq & 0xFFFF), seq);
   }
 }
+
+TEST_F(PacketRouterTest, SendFeedback) {
+  MockRtpRtcp rtp_1;
+  MockRtpRtcp rtp_2;
+  packet_router_->AddRtpModule(&rtp_1, false);
+  packet_router_->AddRtpModule(&rtp_2, true);
+
+  rtcp::TransportFeedback feedback;
+  EXPECT_CALL(rtp_1, SendFeedbackPacket(_)).Times(1);
+  packet_router_->SendFeedback(&feedback);
+  packet_router_->RemoveRtpModule(&rtp_1, false);
+  EXPECT_CALL(rtp_2, SendFeedbackPacket(_)).Times(1);
+  packet_router_->SendFeedback(&feedback);
+  packet_router_->RemoveRtpModule(&rtp_2, true);
+}
 }  // namespace webrtc
diff --git a/webrtc/test/mock_voe_channel_proxy.h b/webrtc/test/mock_voe_channel_proxy.h
index a0ec4b2405..f5c87334cc 100644
--- a/webrtc/test/mock_voe_channel_proxy.h
+++ b/webrtc/test/mock_voe_channel_proxy.h
@@ -29,10 +29,13 @@ class MockVoEChannelProxy : public voe::ChannelProxy {
   MOCK_METHOD2(SetReceiveAudioLevelIndicationStatus, void(bool enable, int id));
   MOCK_METHOD1(EnableSendTransportSequenceNumber, void(int id));
   MOCK_METHOD1(EnableReceiveTransportSequenceNumber, void(int id));
-  MOCK_METHOD3(SetCongestionControlObjects,
+  MOCK_METHOD3(RegisterSenderCongestionControlObjects,
                void(RtpPacketSender* rtp_packet_sender,
                     TransportFeedbackObserver* transport_feedback_observer,
-                    PacketRouter* seq_num_allocator));
+                    PacketRouter* packet_router));
+  MOCK_METHOD1(RegisterReceiverCongestionControlObjects,
+               void(PacketRouter* packet_router));
+  MOCK_METHOD0(ResetCongestionControlObjects, void());
   MOCK_CONST_METHOD0(GetRTCPStatistics, CallStatistics());
   MOCK_CONST_METHOD0(GetRemoteRTCPReportBlocks, std::vector<ReportBlock>());
   MOCK_CONST_METHOD0(GetNetworkStatistics, NetworkStatistics());
diff --git a/webrtc/video/vie_channel.cc b/webrtc/video/vie_channel.cc
index b1b0f0c4b8..7c13a7c3df 100644
--- a/webrtc/video/vie_channel.cc
+++ b/webrtc/video/vie_channel.cc
@@ -150,7 +150,7 @@ int32_t ViEChannel::Init() {
     for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
       rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_);
   }
-  packet_router_->AddRtpModule(rtp_rtcp_modules_[0]);
+  packet_router_->AddRtpModule(rtp_rtcp_modules_[0], sender_);
   if (sender_) {
     std::list<RtpRtcp*> send_rtp_modules(1, rtp_rtcp_modules_[0]);
     send_payload_router_->SetSendingRtpModules(send_rtp_modules);
@@ -179,7 +179,7 @@ ViEChannel::~ViEChannel() {
   module_process_thread_->DeRegisterModule(&vie_sync_);
   send_payload_router_->SetSendingRtpModules(std::list<RtpRtcp*>());
   for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i)
-    packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i]);
+    packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i], sender_);
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     module_process_thread_->DeRegisterModule(rtp_rtcp);
     delete rtp_rtcp;
@@ -400,12 +400,12 @@ int32_t ViEChannel::SetSendCodec(const VideoCodec& video_codec,
   // Deregister previously registered modules.
   for (size_t i = num_active_modules; i < num_prev_active_modules; ++i) {
     module_process_thread_->DeRegisterModule(rtp_rtcp_modules_[i]);
-    packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i]);
+    packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i], sender_);
   }
   // Register new active modules.
   for (size_t i = num_prev_active_modules; i < num_active_modules; ++i) {
     module_process_thread_->RegisterModule(rtp_rtcp_modules_[i]);
-    packet_router_->AddRtpModule(rtp_rtcp_modules_[i]);
+    packet_router_->AddRtpModule(rtp_rtcp_modules_[i], sender_);
   }
   return 0;
 }
diff --git a/webrtc/voice_engine/channel.cc b/webrtc/voice_engine/channel.cc
index d5f10bfdf8..148ef81d78 100644
--- a/webrtc/voice_engine/channel.cc
+++ b/webrtc/voice_engine/channel.cc
@@ -124,6 +124,12 @@ class RtpPacketSenderProxy : public RtpPacketSender {
     rtp_packet_sender_ = rtp_packet_sender;
   }
 
+  bool HasPacketSender() const {
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
+    rtc::CritScope lock(&crit_);
+    return rtp_packet_sender_ != nullptr;
+  }
+
   // Implements RtpPacketSender.
   void InsertPacket(Priority priority,
                     uint32_t ssrc,
@@ -813,12 +819,9 @@ Channel::Channel(int32_t channelId,
       network_predictor_(new NetworkPredictor(Clock::GetRealTimeClock())),
       associate_send_channel_(ChannelOwner(nullptr)),
       pacing_enabled_(config.Get<VoicePacing>().enabled),
-      feedback_observer_proxy_(pacing_enabled_ ? new TransportFeedbackProxy()
-                                               : nullptr),
-      seq_num_allocator_proxy_(
-          pacing_enabled_ ? new TransportSequenceNumberProxy() : nullptr),
-      rtp_packet_sender_proxy_(pacing_enabled_ ? new RtpPacketSenderProxy()
-                                               : nullptr) {
+      feedback_observer_proxy_(new TransportFeedbackProxy()),
+      seq_num_allocator_proxy_(new TransportSequenceNumberProxy()),
+      rtp_packet_sender_proxy_(new RtpPacketSenderProxy()) {
   WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::Channel() - ctor");
   AudioCodingModule::Config acm_config;
@@ -843,10 +846,12 @@ Channel::Channel(int32_t channelId,
   configuration.audio_messages = this;
   configuration.receive_statistics = rtp_receive_statistics_.get();
   configuration.bandwidth_callback = rtcp_observer_.get();
-  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();
+  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;
 
   _rtpRtcpModule.reset(RtpRtcp::CreateRtpRtcp(configuration));
@@ -2582,32 +2587,40 @@ void Channel::EnableReceiveTransportSequenceNumber(int id) {
   RTC_DCHECK(ret);
 }
 
-void Channel::SetCongestionControlObjects(
+void Channel::RegisterSenderCongestionControlObjects(
     RtpPacketSender* rtp_packet_sender,
     TransportFeedbackObserver* transport_feedback_observer,
     PacketRouter* packet_router) {
-  RTC_DCHECK(packet_router != nullptr || packet_router_ != nullptr);
-  if (transport_feedback_observer) {
-    RTC_DCHECK(feedback_observer_proxy_.get());
-    feedback_observer_proxy_->SetTransportFeedbackObserver(
-        transport_feedback_observer);
-  }
-  if (rtp_packet_sender) {
-    RTC_DCHECK(rtp_packet_sender_proxy_.get());
-    rtp_packet_sender_proxy_->SetPacketSender(rtp_packet_sender);
-  }
-  if (seq_num_allocator_proxy_.get()) {
-    seq_num_allocator_proxy_->SetSequenceNumberAllocator(packet_router);
-  }
-  _rtpRtcpModule->SetStorePacketsStatus(rtp_packet_sender != nullptr, 600);
-  if (packet_router != nullptr) {
-    packet_router->AddRtpModule(_rtpRtcpModule.get());
-  } else {
-    packet_router_->RemoveRtpModule(_rtpRtcpModule.get());
-  }
+  RTC_DCHECK(rtp_packet_sender);
+  RTC_DCHECK(transport_feedback_observer);
+  RTC_DCHECK(packet_router && !packet_router_);
+  feedback_observer_proxy_->SetTransportFeedbackObserver(
+      transport_feedback_observer);
+  seq_num_allocator_proxy_->SetSequenceNumberAllocator(packet_router);
+  rtp_packet_sender_proxy_->SetPacketSender(rtp_packet_sender);
+  _rtpRtcpModule->SetStorePacketsStatus(true, 600);
+  packet_router->AddRtpModule(_rtpRtcpModule.get(), true);
   packet_router_ = packet_router;
 }
 
+void Channel::RegisterReceiverCongestionControlObjects(
+    PacketRouter* packet_router) {
+  RTC_DCHECK(packet_router && !packet_router_);
+  packet_router->AddRtpModule(_rtpRtcpModule.get(), false);
+  packet_router_ = packet_router;
+}
+
+void Channel::ResetCongestionControlObjects() {
+  RTC_DCHECK(packet_router_);
+  _rtpRtcpModule->SetStorePacketsStatus(false, 600);
+  feedback_observer_proxy_->SetTransportFeedbackObserver(nullptr);
+  seq_num_allocator_proxy_->SetSequenceNumberAllocator(nullptr);
+  const bool sender = rtp_packet_sender_proxy_->HasPacketSender();
+  packet_router_->RemoveRtpModule(_rtpRtcpModule.get(), sender);
+  packet_router_ = nullptr;
+  rtp_packet_sender_proxy_->SetPacketSender(nullptr);
+}
+
 void Channel::SetRTCPStatus(bool enable) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetRTCPStatus()");
diff --git a/webrtc/voice_engine/channel.h b/webrtc/voice_engine/channel.h
index 14bfc2bba0..889214b0aa 100644
--- a/webrtc/voice_engine/channel.h
+++ b/webrtc/voice_engine/channel.h
@@ -339,10 +339,12 @@ class Channel
   void EnableSendTransportSequenceNumber(int id);
   void EnableReceiveTransportSequenceNumber(int id);
 
-  void SetCongestionControlObjects(
-      RtpPacketSender* rtp_packet_sender,
-      TransportFeedbackObserver* transport_feedback_observer,
-      PacketRouter* packet_router);
+    void RegisterSenderCongestionControlObjects(
+        RtpPacketSender* rtp_packet_sender,
+        TransportFeedbackObserver* transport_feedback_observer,
+        PacketRouter* packet_router);
+    void RegisterReceiverCongestionControlObjects(PacketRouter* packet_router);
+    void ResetCongestionControlObjects();
 
   void SetRTCPStatus(bool enable);
   int GetRTCPStatus(bool& enabled);
diff --git a/webrtc/voice_engine/channel_proxy.cc b/webrtc/voice_engine/channel_proxy.cc
index 15a21512fb..1e2281aef4 100644
--- a/webrtc/voice_engine/channel_proxy.cc
+++ b/webrtc/voice_engine/channel_proxy.cc
@@ -79,15 +79,26 @@ void ChannelProxy::EnableReceiveTransportSequenceNumber(int id) {
   channel()->EnableReceiveTransportSequenceNumber(id);
 }
 
-void ChannelProxy::SetCongestionControlObjects(
+void ChannelProxy::RegisterSenderCongestionControlObjects(
     RtpPacketSender* rtp_packet_sender,
     TransportFeedbackObserver* transport_feedback_observer,
     PacketRouter* packet_router) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  channel()->SetCongestionControlObjects(
+  channel()->RegisterSenderCongestionControlObjects(
       rtp_packet_sender, transport_feedback_observer, packet_router);
 }
 
+void ChannelProxy::RegisterReceiverCongestionControlObjects(
+    PacketRouter* packet_router) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  channel()->RegisterReceiverCongestionControlObjects(packet_router);
+}
+
+void ChannelProxy::ResetCongestionControlObjects() {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  channel()->ResetCongestionControlObjects();
+}
+
 CallStatistics ChannelProxy::GetRTCPStatistics() const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   CallStatistics stats = {0};
diff --git a/webrtc/voice_engine/channel_proxy.h b/webrtc/voice_engine/channel_proxy.h
index 9a931600f4..9d6839c8de 100644
--- a/webrtc/voice_engine/channel_proxy.h
+++ b/webrtc/voice_engine/channel_proxy.h
@@ -51,10 +51,13 @@ class ChannelProxy {
   virtual void SetReceiveAudioLevelIndicationStatus(bool enable, int id);
   virtual void EnableSendTransportSequenceNumber(int id);
   virtual void EnableReceiveTransportSequenceNumber(int id);
-  virtual void SetCongestionControlObjects(
+  virtual void RegisterSenderCongestionControlObjects(
       RtpPacketSender* rtp_packet_sender,
       TransportFeedbackObserver* transport_feedback_observer,
       PacketRouter* packet_router);
+  virtual void RegisterReceiverCongestionControlObjects(
+      PacketRouter* packet_router);
+  virtual void ResetCongestionControlObjects();
 
   virtual CallStatistics GetRTCPStatistics() const;
   virtual std::vector<ReportBlock> GetRemoteRTCPReportBlocks() const;