diff --git a/audio/BUILD.gn b/audio/BUILD.gn
index f6a30bac8f..5b5c723c4f 100644
--- a/audio/BUILD.gn
+++ b/audio/BUILD.gn
@@ -69,7 +69,6 @@ rtc_static_library("audio") {
     "../modules/audio_device",
     "../modules/audio_processing",
     "../modules/bitrate_controller:bitrate_controller",
-    "../modules/congestion_controller:congestion_controller",
     "../modules/pacing:pacing",
     "../modules/remote_bitrate_estimator:remote_bitrate_estimator",
     "../modules/rtp_rtcp",
diff --git a/audio/audio_send_stream.cc b/audio/audio_send_stream.cc
index 0a5fc58581..5de079bb18 100644
--- a/audio/audio_send_stream.cc
+++ b/audio/audio_send_stream.cc
@@ -19,8 +19,6 @@
 #include "audio/conversion.h"
 #include "call/rtp_transport_controller_send_interface.h"
 #include "modules/audio_coding/codecs/cng/audio_encoder_cng.h"
-#include "modules/bitrate_controller/include/bitrate_controller.h"
-#include "modules/congestion_controller/include/send_side_congestion_controller.h"
 #include "modules/pacing/paced_sender.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/event.h"
@@ -138,7 +136,6 @@ AudioSendStream::AudioSendStream(
   RTC_DCHECK(channel_proxy_);
   RTC_DCHECK(bitrate_allocator_);
   RTC_DCHECK(transport);
-  RTC_DCHECK(transport->send_side_cc());
   RTC_DCHECK(overall_call_lifetime_);
 
   channel_proxy_->SetRtcEventLog(event_log_);
@@ -152,14 +149,14 @@ AudioSendStream::AudioSendStream(
 
   pacer_thread_checker_.DetachFromThread();
   // Signal congestion controller this object is ready for OnPacket* callbacks.
-  transport_->send_side_cc()->RegisterPacketFeedbackObserver(this);
+  transport_->RegisterPacketFeedbackObserver(this);
 }
 
 AudioSendStream::~AudioSendStream() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   RTC_LOG(LS_INFO) << "~AudioSendStream: " << config_.rtp.ssrc;
   RTC_DCHECK(!sending_);
-  transport_->send_side_cc()->DeRegisterPacketFeedbackObserver(this);
+  transport_->DeRegisterPacketFeedbackObserver(this);
   channel_proxy_->RegisterTransport(nullptr);
   channel_proxy_->ResetSenderCongestionControlObjects();
   channel_proxy_->SetRtcEventLog(nullptr);
@@ -257,9 +254,8 @@ void AudioSendStream::ConfigureStream(
       // Probing in application limited region is only used in combination with
       // send side congestion control, wich depends on feedback packets which
       // requires transport sequence numbers to be enabled.
-      stream->transport_->send_side_cc()->EnablePeriodicAlrProbing(true);
-      bandwidth_observer =
-          stream->transport_->send_side_cc()->GetBandwidthObserver();
+      stream->transport_->EnablePeriodicAlrProbing(true);
+      bandwidth_observer = stream->transport_->GetBandwidthObserver();
     }
 
     channel_proxy->RegisterSenderCongestionControlObjects(stream->transport_,
@@ -455,8 +451,7 @@ void AudioSendStream::OnPacketFeedbackVector(
 
 void AudioSendStream::SetTransportOverhead(int transport_overhead_per_packet) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  transport_->send_side_cc()->SetTransportOverhead(
-      transport_overhead_per_packet);
+  transport_->SetTransportOverhead(transport_overhead_per_packet);
   channel_proxy_->SetTransportOverhead(transport_overhead_per_packet);
 }
 
diff --git a/call/call.cc b/call/call.cc
index e19051d177..338a135900 100644
--- a/call/call.cc
+++ b/call/call.cc
@@ -35,6 +35,7 @@
 #include "logging/rtc_event_log/rtc_event_log.h"
 #include "logging/rtc_event_log/rtc_stream_config.h"
 #include "modules/bitrate_controller/include/bitrate_controller.h"
+#include "modules/congestion_controller/include/network_changed_observer.h"
 #include "modules/congestion_controller/include/receive_side_congestion_controller.h"
 #include "modules/rtp_rtcp/include/flexfec_receiver.h"
 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
@@ -163,7 +164,7 @@ namespace internal {
 class Call : public webrtc::Call,
              public PacketReceiver,
              public RecoveredPacketReceiver,
-             public SendSideCongestionController::Observer,
+             public NetworkChangedObserver,
              public BitrateAllocator::LimitObserver {
  public:
   Call(const Call::Config& config,
@@ -451,15 +452,14 @@ Call::Call(const Call::Config& config,
     RTC_DCHECK_GE(config.bitrate_config.max_bitrate_bps,
                   config.bitrate_config.start_bitrate_bps);
   }
-  transport_send->send_side_cc()->RegisterNetworkObserver(this);
+  transport_send->RegisterNetworkObserver(this);
   transport_send_ = std::move(transport_send);
-  transport_send_->send_side_cc()->SignalNetworkState(kNetworkDown);
-  transport_send_->send_side_cc()->SetBweBitrates(
-      config_.bitrate_config.min_bitrate_bps,
-      config_.bitrate_config.start_bitrate_bps,
-      config_.bitrate_config.max_bitrate_bps);
+  transport_send_->OnNetworkAvailability(false);
+  transport_send_->SetBweBitrates(config_.bitrate_config.min_bitrate_bps,
+                                  config_.bitrate_config.start_bitrate_bps,
+                                  config_.bitrate_config.max_bitrate_bps);
   call_stats_->RegisterStatsObserver(&receive_side_cc_);
-  call_stats_->RegisterStatsObserver(transport_send_->send_side_cc());
+  call_stats_->RegisterStatsObserver(transport_send_->GetCallStatsObserver());
 
   // We have to attach the pacer to the pacer thread before starting the
   // module process thread to avoid a race accessing the process thread
@@ -471,7 +471,7 @@ Call::Call(const Call::Config& config,
 
   module_process_thread_->RegisterModule(call_stats_.get(), RTC_FROM_HERE);
   module_process_thread_->RegisterModule(&receive_side_cc_, RTC_FROM_HERE);
-  module_process_thread_->RegisterModule(transport_send_->send_side_cc(),
+  module_process_thread_->RegisterModule(transport_send_->GetModule(),
                                          RTC_FROM_HERE);
   module_process_thread_->Start();
 }
@@ -489,7 +489,7 @@ Call::~Call() {
   // the pacer thread being stopped to avoid a race when accessing the
   // pacer thread object on the module process thread at the same time as
   // the pacer thread is stopped.
-  module_process_thread_->DeRegisterModule(transport_send_->send_side_cc());
+  module_process_thread_->DeRegisterModule(transport_send_->GetModule());
   pacer_thread_->Stop();
   pacer_thread_->DeRegisterModule(transport_send_->pacer());
   pacer_thread_->DeRegisterModule(
@@ -498,10 +498,9 @@ Call::~Call() {
   module_process_thread_->DeRegisterModule(call_stats_.get());
   module_process_thread_->Stop();
   call_stats_->DeregisterStatsObserver(&receive_side_cc_);
-  call_stats_->DeregisterStatsObserver(transport_send_->send_side_cc());
+  call_stats_->DeregisterStatsObserver(transport_send_->GetCallStatsObserver());
 
-  int64_t first_sent_packet_ms =
-      transport_send_->send_side_cc()->GetFirstPacketTimeMs();
+  int64_t first_sent_packet_ms = transport_send_->GetFirstPacketTimeMs();
   // Only update histograms after process threads have been shut down, so that
   // they won't try to concurrently update stats.
   {
@@ -930,15 +929,14 @@ Call::Stats Call::GetStats() const {
   Stats stats;
   // Fetch available send/receive bitrates.
   uint32_t send_bandwidth = 0;
-  transport_send_->send_side_cc()->AvailableBandwidth(&send_bandwidth);
+  transport_send_->AvailableBandwidth(&send_bandwidth);
   std::vector<unsigned int> ssrcs;
   uint32_t recv_bandwidth = 0;
   receive_side_cc_.GetRemoteBitrateEstimator(false)->LatestEstimate(
       &ssrcs, &recv_bandwidth);
   stats.send_bandwidth_bps = send_bandwidth;
   stats.recv_bandwidth_bps = recv_bandwidth;
-  stats.pacer_delay_ms =
-      transport_send_->send_side_cc()->GetPacerQueuingDelayMs();
+  stats.pacer_delay_ms = transport_send_->GetPacerQueuingDelayMs();
   stats.rtt_ms = call_stats_->rtcp_rtt_stats()->LastProcessedRtt();
   {
     rtc::CritScope cs(&bitrate_crit_);
@@ -1019,9 +1017,9 @@ void Call::UpdateCurrentBitrateConfig(const rtc::Optional<int>& new_start) {
                 << "calling SetBweBitrates with args ("
                 << updated.min_bitrate_bps << ", " << updated.start_bitrate_bps
                 << ", " << updated.max_bitrate_bps << ")";
-  transport_send_->send_side_cc()->SetBweBitrates(updated.min_bitrate_bps,
-                                                  updated.start_bitrate_bps,
-                                                  updated.max_bitrate_bps);
+  transport_send_->SetBweBitrates(updated.min_bitrate_bps,
+                                  updated.start_bitrate_bps,
+                                  updated.max_bitrate_bps);
   if (!new_start) {
     updated.start_bitrate_bps = config_.bitrate_config.start_bitrate_bps;
   }
@@ -1138,7 +1136,7 @@ void Call::OnNetworkRouteChanged(const std::string& transport_name,
         << " bps,  max: " << config_.bitrate_config.start_bitrate_bps
         << " bps.";
     RTC_DCHECK_GT(config_.bitrate_config.start_bitrate_bps, 0);
-    transport_send_->send_side_cc()->OnNetworkRouteChanged(
+    transport_send_->OnNetworkRouteChanged(
         network_route, config_.bitrate_config.start_bitrate_bps,
         config_.bitrate_config.min_bitrate_bps,
         config_.bitrate_config.max_bitrate_bps);
@@ -1174,13 +1172,13 @@ void Call::UpdateAggregateNetworkState() {
   RTC_LOG(LS_INFO) << "UpdateAggregateNetworkState: aggregate_state="
                    << (aggregate_state == kNetworkUp ? "up" : "down");
 
-  transport_send_->send_side_cc()->SignalNetworkState(aggregate_state);
+  transport_send_->OnNetworkAvailability(aggregate_state == kNetworkUp);
 }
 
 void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
   video_send_delay_stats_->OnSentPacket(sent_packet.packet_id,
                                         clock_->TimeInMilliseconds());
-  transport_send_->send_side_cc()->OnSentPacket(sent_packet);
+  transport_send_->OnSentPacket(sent_packet);
 }
 
 void Call::OnNetworkChanged(uint32_t target_bitrate_bps,
diff --git a/call/fake_rtp_transport_controller_send.h b/call/fake_rtp_transport_controller_send.h
index dda2e5f645..b797a352bd 100644
--- a/call/fake_rtp_transport_controller_send.h
+++ b/call/fake_rtp_transport_controller_send.h
@@ -33,10 +33,6 @@ class FakeRtpTransportControllerSend
 
   PacketRouter* packet_router() override { return packet_router_; }
 
-  SendSideCongestionController* send_side_cc() override {
-    return send_side_cc_;
-  }
-
   TransportFeedbackObserver* transport_feedback_observer() override {
     return send_side_cc_;
   }
@@ -56,6 +52,65 @@ class FakeRtpTransportControllerSend
     keepalive_ = keepalive_config;
   }
 
+  Module* GetModule() override { return send_side_cc_; }
+  CallStatsObserver* GetCallStatsObserver() override { return send_side_cc_; }
+  void RegisterPacketFeedbackObserver(
+      PacketFeedbackObserver* observer) override {
+    send_side_cc_->RegisterPacketFeedbackObserver(observer);
+  }
+  void DeRegisterPacketFeedbackObserver(
+      PacketFeedbackObserver* observer) override {
+    send_side_cc_->DeRegisterPacketFeedbackObserver(observer);
+  }
+  void RegisterNetworkObserver(NetworkChangedObserver* observer) override {
+    send_side_cc_->RegisterNetworkObserver(observer);
+  }
+  void DeRegisterNetworkObserver(NetworkChangedObserver* observer) override {
+    send_side_cc_->RegisterNetworkObserver(observer);
+  }
+  void SetBweBitrates(int min_bitrate_bps,
+                      int start_bitrate_bps,
+                      int max_bitrate_bps) override {
+    send_side_cc_->SetBweBitrates(min_bitrate_bps, start_bitrate_bps,
+                                  max_bitrate_bps);
+  }
+  void OnNetworkRouteChanged(const rtc::NetworkRoute& network_route,
+                             int start_bitrate_bps,
+                             int min_bitrate_bps,
+                             int max_bitrate_bps) override {
+    send_side_cc_->OnNetworkRouteChanged(network_route, start_bitrate_bps,
+                                         min_bitrate_bps, max_bitrate_bps);
+  }
+  void OnNetworkAvailability(bool network_available) override {
+    send_side_cc_->SignalNetworkState(network_available ? kNetworkUp
+                                                        : kNetworkDown);
+  }
+  void SetTransportOverhead(
+      size_t transport_overhead_bytes_per_packet) override {
+    send_side_cc_->SetTransportOverhead(transport_overhead_bytes_per_packet);
+  }
+  RtcpBandwidthObserver* GetBandwidthObserver() override {
+    return send_side_cc_->GetBandwidthObserver();
+  }
+  bool AvailableBandwidth(uint32_t* bandwidth) const override {
+    return send_side_cc_->AvailableBandwidth(bandwidth);
+  }
+  int64_t GetPacerQueuingDelayMs() const override {
+    return send_side_cc_->GetPacerQueuingDelayMs();
+  }
+  int64_t GetFirstPacketTimeMs() const override {
+    return send_side_cc_->GetFirstPacketTimeMs();
+  }
+  RateLimiter* GetRetransmissionRateLimiter() override {
+    return send_side_cc_->GetRetransmissionRateLimiter();
+  }
+  void EnablePeriodicAlrProbing(bool enable) override {
+    send_side_cc_->EnablePeriodicAlrProbing(enable);
+  }
+  void OnSentPacket(const rtc::SentPacket& sent_packet) override {
+    send_side_cc_->OnSentPacket(sent_packet);
+  }
+
  private:
   PacketRouter* packet_router_;
   PacedSender* paced_sender_;
diff --git a/call/rtp_transport_controller_send.cc b/call/rtp_transport_controller_send.cc
index 090c261e4e..f203c4e6f8 100644
--- a/call/rtp_transport_controller_send.cc
+++ b/call/rtp_transport_controller_send.cc
@@ -26,10 +26,6 @@ PacedSender* RtpTransportControllerSend::pacer() {
   return &pacer_;
 }
 
-SendSideCongestionController* RtpTransportControllerSend::send_side_cc() {
-  return &send_side_cc_;
-}
-
 TransportFeedbackObserver*
 RtpTransportControllerSend::transport_feedback_observer() {
   return &send_side_cc_;
@@ -53,5 +49,71 @@ void RtpTransportControllerSend::SetKeepAliveConfig(
     const RtpKeepAliveConfig& config) {
   keepalive_ = config;
 }
+Module* RtpTransportControllerSend::GetModule() {
+  return &send_side_cc_;
+}
+CallStatsObserver* RtpTransportControllerSend::GetCallStatsObserver() {
+  return &send_side_cc_;
+}
+void RtpTransportControllerSend::RegisterPacketFeedbackObserver(
+    PacketFeedbackObserver* observer) {
+  send_side_cc_.RegisterPacketFeedbackObserver(observer);
+}
+void RtpTransportControllerSend::DeRegisterPacketFeedbackObserver(
+    PacketFeedbackObserver* observer) {
+  send_side_cc_.DeRegisterPacketFeedbackObserver(observer);
+}
+void RtpTransportControllerSend::RegisterNetworkObserver(
+    NetworkChangedObserver* observer) {
+  send_side_cc_.RegisterNetworkObserver(observer);
+}
+void RtpTransportControllerSend::DeRegisterNetworkObserver(
+    NetworkChangedObserver* observer) {
+  send_side_cc_.DeRegisterNetworkObserver(observer);
+}
+void RtpTransportControllerSend::SetBweBitrates(int min_bitrate_bps,
+                                                int start_bitrate_bps,
+                                                int max_bitrate_bps) {
+  send_side_cc_.SetBweBitrates(min_bitrate_bps, start_bitrate_bps,
+                               max_bitrate_bps);
+}
+void RtpTransportControllerSend::OnNetworkRouteChanged(
+    const rtc::NetworkRoute& network_route,
+    int start_bitrate_bps,
+    int min_bitrate_bps,
+    int max_bitrate_bps) {
+  send_side_cc_.OnNetworkRouteChanged(network_route, start_bitrate_bps,
+                                      min_bitrate_bps, max_bitrate_bps);
+}
+void RtpTransportControllerSend::OnNetworkAvailability(bool network_available) {
+  send_side_cc_.SignalNetworkState(network_available ? kNetworkUp
+                                                     : kNetworkDown);
+}
+void RtpTransportControllerSend::SetTransportOverhead(
+    size_t transport_overhead_bytes_per_packet) {
+  send_side_cc_.SetTransportOverhead(transport_overhead_bytes_per_packet);
+}
+RtcpBandwidthObserver* RtpTransportControllerSend::GetBandwidthObserver() {
+  return send_side_cc_.GetBandwidthObserver();
+}
+bool RtpTransportControllerSend::AvailableBandwidth(uint32_t* bandwidth) const {
+  return send_side_cc_.AvailableBandwidth(bandwidth);
+}
+int64_t RtpTransportControllerSend::GetPacerQueuingDelayMs() const {
+  return send_side_cc_.GetPacerQueuingDelayMs();
+}
+int64_t RtpTransportControllerSend::GetFirstPacketTimeMs() const {
+  return send_side_cc_.GetFirstPacketTimeMs();
+}
+RateLimiter* RtpTransportControllerSend::GetRetransmissionRateLimiter() {
+  return send_side_cc_.GetRetransmissionRateLimiter();
+}
+void RtpTransportControllerSend::EnablePeriodicAlrProbing(bool enable) {
+  send_side_cc_.EnablePeriodicAlrProbing(enable);
+}
+void RtpTransportControllerSend::OnSentPacket(
+    const rtc::SentPacket& sent_packet) {
+  send_side_cc_.OnSentPacket(sent_packet);
+}
 
 }  // namespace webrtc
diff --git a/call/rtp_transport_controller_send.h b/call/rtp_transport_controller_send.h
index 45d6db0fee..2ae4ce6d39 100644
--- a/call/rtp_transport_controller_send.h
+++ b/call/rtp_transport_controller_send.h
@@ -35,7 +35,6 @@ class RtpTransportControllerSend : public RtpTransportControllerSendInterface {
   // In addition the PacedSender should be driven by this class, either
   // by owning the process thread, or later by using a task queue.
   PacedSender* pacer() override;
-  SendSideCongestionController* send_side_cc() override;
   TransportFeedbackObserver* transport_feedback_observer() override;
   RtpPacketSender* packet_sender() override;
   const RtpKeepAliveConfig& keepalive_config() const override;
@@ -44,6 +43,31 @@ class RtpTransportControllerSend : public RtpTransportControllerSendInterface {
                                      int max_padding_bitrate_bps) override;
 
   void SetKeepAliveConfig(const RtpKeepAliveConfig& config);
+  Module* GetModule() override;
+  CallStatsObserver* GetCallStatsObserver() override;
+  void RegisterPacketFeedbackObserver(
+      PacketFeedbackObserver* observer) override;
+  void DeRegisterPacketFeedbackObserver(
+      PacketFeedbackObserver* observer) override;
+  void RegisterNetworkObserver(NetworkChangedObserver* observer) override;
+  void DeRegisterNetworkObserver(NetworkChangedObserver* observer) override;
+  void SetBweBitrates(int min_bitrate_bps,
+                      int start_bitrate_bps,
+                      int max_bitrate_bps) override;
+  void OnNetworkRouteChanged(const rtc::NetworkRoute& network_route,
+                             int start_bitrate_bps,
+                             int min_bitrate_bps,
+                             int max_bitrate_bps) override;
+  void OnNetworkAvailability(bool network_available) override;
+  void SetTransportOverhead(
+      size_t transport_overhead_bytes_per_packet) override;
+  RtcpBandwidthObserver* GetBandwidthObserver() override;
+  bool AvailableBandwidth(uint32_t* bandwidth) const override;
+  int64_t GetPacerQueuingDelayMs() const override;
+  int64_t GetFirstPacketTimeMs() const override;
+  RateLimiter* GetRetransmissionRateLimiter() override;
+  void EnablePeriodicAlrProbing(bool enable) override;
+  void OnSentPacket(const rtc::SentPacket& sent_packet) override;
 
  private:
   PacketRouter packet_router_;
diff --git a/call/rtp_transport_controller_send_interface.h b/call/rtp_transport_controller_send_interface.h
index 7b0dbefd14..d8f58db0e8 100644
--- a/call/rtp_transport_controller_send_interface.h
+++ b/call/rtp_transport_controller_send_interface.h
@@ -10,14 +10,25 @@
 
 #ifndef CALL_RTP_TRANSPORT_CONTROLLER_SEND_INTERFACE_H_
 #define CALL_RTP_TRANSPORT_CONTROLLER_SEND_INTERFACE_H_
+#include <stddef.h>
+#include <stdint.h>
 
+namespace rtc {
+struct SentPacket;
+struct NetworkRoute;
+}  // namespace rtc
 namespace webrtc {
 
+class CallStatsObserver;
+class NetworkChangedObserver;
+class Module;
 class PacedSender;
+class PacketFeedbackObserver;
 class PacketRouter;
+class RateLimiter;
+class RtcpBandwidthObserver;
 class RtpPacketSender;
 struct RtpKeepAliveConfig;
-class SendSideCongestionController;
 class TransportFeedbackObserver;
 
 // An RtpTransportController should own everything related to the RTP
@@ -48,8 +59,6 @@ class RtpTransportControllerSendInterface {
   virtual ~RtpTransportControllerSendInterface() {}
   virtual PacketRouter* packet_router() = 0;
   virtual PacedSender* pacer() = 0;
-  // Currently returning the same pointer, but with different types.
-  virtual SendSideCongestionController* send_side_cc() = 0;
   virtual TransportFeedbackObserver* transport_feedback_observer() = 0;
 
   virtual RtpPacketSender* packet_sender() = 0;
@@ -66,6 +75,33 @@ class RtpTransportControllerSendInterface {
   // pad unless there is real packets to send.
   virtual void SetAllocatedSendBitrateLimits(int min_send_bitrate_bps,
                                              int max_padding_bitrate_bps) = 0;
+
+  virtual Module* GetModule() = 0;
+  virtual CallStatsObserver* GetCallStatsObserver() = 0;
+
+  virtual void RegisterPacketFeedbackObserver(
+      PacketFeedbackObserver* observer) = 0;
+  virtual void DeRegisterPacketFeedbackObserver(
+      PacketFeedbackObserver* observer) = 0;
+  virtual void RegisterNetworkObserver(NetworkChangedObserver* observer) = 0;
+  virtual void DeRegisterNetworkObserver(NetworkChangedObserver* observer) = 0;
+  virtual void SetBweBitrates(int min_bitrate_bps,
+                              int start_bitrate_bps,
+                              int max_bitrate_bps) = 0;
+  virtual void OnNetworkRouteChanged(const rtc::NetworkRoute& network_route,
+                                     int start_bitrate_bps,
+                                     int min_bitrate_bps,
+                                     int max_bitrate_bps) = 0;
+  virtual void OnNetworkAvailability(bool network_available) = 0;
+  virtual void SetTransportOverhead(
+      size_t transport_overhead_bytes_per_packet) = 0;
+  virtual RtcpBandwidthObserver* GetBandwidthObserver() = 0;
+  virtual bool AvailableBandwidth(uint32_t* bandwidth) const = 0;
+  virtual int64_t GetPacerQueuingDelayMs() const = 0;
+  virtual int64_t GetFirstPacketTimeMs() const = 0;
+  virtual RateLimiter* GetRetransmissionRateLimiter() = 0;
+  virtual void EnablePeriodicAlrProbing(bool enable) = 0;
+  virtual void OnSentPacket(const rtc::SentPacket& sent_packet) = 0;
 };
 
 }  // namespace webrtc
diff --git a/modules/congestion_controller/BUILD.gn b/modules/congestion_controller/BUILD.gn
index 23f5333dd9..6709c858de 100644
--- a/modules/congestion_controller/BUILD.gn
+++ b/modules/congestion_controller/BUILD.gn
@@ -20,6 +20,7 @@ rtc_static_library("congestion_controller") {
   visibility = [ "*" ]
   configs += [ ":bwe_test_logging" ]
   sources = [
+    "include/network_changed_observer.h",
     "include/receive_side_congestion_controller.h",
     "include/send_side_congestion_controller.h",
     "probe_controller.cc",
diff --git a/modules/congestion_controller/include/mock/mock_congestion_observer.h b/modules/congestion_controller/include/mock/mock_congestion_observer.h
index c6883d976b..d9c24a23ca 100644
--- a/modules/congestion_controller/include/mock/mock_congestion_observer.h
+++ b/modules/congestion_controller/include/mock/mock_congestion_observer.h
@@ -11,13 +11,13 @@
 #ifndef MODULES_CONGESTION_CONTROLLER_INCLUDE_MOCK_MOCK_CONGESTION_OBSERVER_H_
 #define MODULES_CONGESTION_CONTROLLER_INCLUDE_MOCK_MOCK_CONGESTION_OBSERVER_H_
 
-#include "modules/congestion_controller/include/send_side_congestion_controller.h"
+#include "modules/congestion_controller/include/network_changed_observer.h"
 #include "test/gmock.h"
 
 namespace webrtc {
 namespace test {
 
-class MockCongestionObserver : public SendSideCongestionController::Observer {
+class MockCongestionObserver : public NetworkChangedObserver {
  public:
   MOCK_METHOD4(OnNetworkChanged,
                void(uint32_t bitrate_bps,
diff --git a/modules/congestion_controller/include/network_changed_observer.h b/modules/congestion_controller/include/network_changed_observer.h
new file mode 100644
index 0000000000..bb95a3d703
--- /dev/null
+++ b/modules/congestion_controller/include/network_changed_observer.h
@@ -0,0 +1,34 @@
+/*
+ *  Copyright (c) 2018 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.
+ */
+
+#ifndef MODULES_CONGESTION_CONTROLLER_INCLUDE_NETWORK_CHANGED_OBSERVER_H_
+#define MODULES_CONGESTION_CONTROLLER_INCLUDE_NETWORK_CHANGED_OBSERVER_H_
+
+#include <stdint.h>
+
+namespace webrtc {
+
+// Observer class for bitrate changes announced due to change in bandwidth
+// estimate or due to that the send pacer is full. Fraction loss and rtt is
+// also part of this callback to allow the observer to optimize its settings
+// for different types of network environments. The bitrate does not include
+// packet headers and is measured in bits per second.
+class NetworkChangedObserver {
+ public:
+  virtual void OnNetworkChanged(uint32_t bitrate_bps,
+                                uint8_t fraction_loss,  // 0 - 255.
+                                int64_t rtt_ms,
+                                int64_t probing_interval_ms) = 0;
+
+ protected:
+  virtual ~NetworkChangedObserver() {}
+};
+}  // namespace webrtc
+#endif  // MODULES_CONGESTION_CONTROLLER_INCLUDE_NETWORK_CHANGED_OBSERVER_H_
diff --git a/modules/congestion_controller/include/send_side_congestion_controller.h b/modules/congestion_controller/include/send_side_congestion_controller.h
index 2707cc340d..d08c05dd83 100644
--- a/modules/congestion_controller/include/send_side_congestion_controller.h
+++ b/modules/congestion_controller/include/send_side_congestion_controller.h
@@ -16,6 +16,7 @@
 
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/congestion_controller/delay_based_bwe.h"
+#include "modules/congestion_controller/include/network_changed_observer.h"
 #include "modules/congestion_controller/transport_feedback_adapter.h"
 #include "modules/include/module.h"
 #include "modules/include/module_common_types.h"
@@ -42,21 +43,7 @@ class SendSideCongestionController : public CallStatsObserver,
                                      public Module,
                                      public TransportFeedbackObserver {
  public:
-  // Observer class for bitrate changes announced due to change in bandwidth
-  // estimate or due to that the send pacer is full. Fraction loss and rtt is
-  // also part of this callback to allow the observer to optimize its settings
-  // for different types of network environments. The bitrate does not include
-  // packet headers and is measured in bits per second.
-  class Observer {
-   public:
-    virtual void OnNetworkChanged(uint32_t bitrate_bps,
-                                  uint8_t fraction_loss,  // 0 - 255.
-                                  int64_t rtt_ms,
-                                  int64_t probing_interval_ms) = 0;
-
-   protected:
-    virtual ~Observer() {}
-  };
+  using Observer = NetworkChangedObserver;
   SendSideCongestionController(const Clock* clock,
                                Observer* observer,
                                RtcEventLog* event_log,
diff --git a/modules/congestion_controller/send_side_congestion_controller_unittest.cc b/modules/congestion_controller/send_side_congestion_controller_unittest.cc
index 67d2c402c4..cc672071d2 100644
--- a/modules/congestion_controller/send_side_congestion_controller_unittest.cc
+++ b/modules/congestion_controller/send_side_congestion_controller_unittest.cc
@@ -85,7 +85,7 @@ class SendSideCongestionControllerTest : public ::testing::Test {
 
   // Allows us to track the target bitrate, without prescribing the exact
   // iterations when this would hapen, like a mock would.
-  class TargetBitrateObserver : public SendSideCongestionController::Observer {
+  class TargetBitrateObserver : public NetworkChangedObserver {
    public:
     explicit TargetBitrateObserver(SendSideCongestionControllerTest* owner)
         : owner_(owner) {}
diff --git a/modules/congestion_controller/transport_feedback_adapter.h b/modules/congestion_controller/transport_feedback_adapter.h
index 2e9bf7ced2..dfd926414e 100644
--- a/modules/congestion_controller/transport_feedback_adapter.h
+++ b/modules/congestion_controller/transport_feedback_adapter.h
@@ -49,7 +49,7 @@ class TransportFeedbackAdapter {
   std::vector<PacketFeedback> GetTransportFeedbackVector() const;
   rtc::Optional<int64_t> GetMinFeedbackLoopRtt() const;
 
-  void SetTransportOverhead(int transport_overhead_bytes_per_packet);
+  void SetTransportOverhead(size_t transport_overhead_bytes_per_packet);
 
   void SetNetworkIds(uint16_t local_id, uint16_t remote_id);
 
diff --git a/rtc_base/networkroute.h b/rtc_base/networkroute.h
index 07cba6324c..5800ef8484 100644
--- a/rtc_base/networkroute.h
+++ b/rtc_base/networkroute.h
@@ -11,6 +11,8 @@
 #ifndef RTC_BASE_NETWORKROUTE_H_
 #define RTC_BASE_NETWORKROUTE_H_
 
+#include <stdint.h>
+
 // TODO(honghaiz): Make a directory that describes the interfaces and structs
 // the media code can rely on and the network code can implement, and both can
 // depend on that, but not depend on each other. Then, move this file to that
diff --git a/rtc_tools/event_log_visualizer/analyzer.cc b/rtc_tools/event_log_visualizer/analyzer.cc
index c32c676b38..0249ec4cc5 100644
--- a/rtc_tools/event_log_visualizer/analyzer.cc
+++ b/rtc_tools/event_log_visualizer/analyzer.cc
@@ -671,7 +671,7 @@ EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log)
                << " (LOG_START, LOG_END) segments in log.";
 }
 
-class BitrateObserver : public SendSideCongestionController::Observer,
+class BitrateObserver : public NetworkChangedObserver,
                         public RemoteBitrateObserver {
  public:
   BitrateObserver() : last_bitrate_bps_(0), bitrate_updated_(false) {}
diff --git a/video/BUILD.gn b/video/BUILD.gn
index 0a7b331f63..52c8af29ae 100644
--- a/video/BUILD.gn
+++ b/video/BUILD.gn
@@ -81,7 +81,6 @@ rtc_static_library("video") {
     "../logging:rtc_event_log_api",
     "../modules:module_api",
     "../modules/bitrate_controller",
-    "../modules/congestion_controller",
     "../modules/pacing",
     "../modules/remote_bitrate_estimator",
     "../modules/rtp_rtcp",
diff --git a/video/video_send_stream.cc b/video/video_send_stream.cc
index 3d59bc25b9..f49f5a001c 100644
--- a/video/video_send_stream.cc
+++ b/video/video_send_stream.cc
@@ -22,7 +22,6 @@
 #include "common_types.h"  // NOLINT(build/include)
 #include "common_video/include/video_bitrate_allocator.h"
 #include "modules/bitrate_controller/include/bitrate_controller.h"
-#include "modules/congestion_controller/include/send_side_congestion_controller.h"
 #include "modules/pacing/packet_router.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "modules/rtp_rtcp/source/rtp_sender.h"
@@ -790,7 +789,7 @@ VideoSendStreamImpl::VideoSendStreamImpl(
       encoder_feedback_(Clock::GetRealTimeClock(),
                         config_->rtp.ssrcs,
                         video_stream_encoder),
-      bandwidth_observer_(transport->send_side_cc()->GetBandwidthObserver()),
+      bandwidth_observer_(transport->GetBandwidthObserver()),
       rtp_rtcp_modules_(CreateRtpRtcpModules(
           config_->send_transport,
           &encoder_feedback_,
@@ -801,7 +800,7 @@ VideoSendStreamImpl::VideoSendStreamImpl(
           stats_proxy_,
           send_delay_stats,
           event_log,
-          transport->send_side_cc()->GetRetransmissionRateLimiter(),
+          transport->GetRetransmissionRateLimiter(),
           this,
           config_->rtp.ssrcs.size(),
           transport->keepalive_config(),
@@ -822,7 +821,7 @@ VideoSendStreamImpl::VideoSendStreamImpl(
   RTC_DCHECK(!config_->rtp.ssrcs.empty());
   RTC_DCHECK(call_stats_);
   RTC_DCHECK(transport_);
-  RTC_DCHECK(transport_->send_side_cc());
+  RTC_DCHECK(transport_);
   RTC_DCHECK_GT(encoder_max_bitrate_bps_, 0);
 
   RTC_CHECK(AlrExperimentSettings::MaxOneFieldTrialEnabled());
@@ -838,7 +837,7 @@ VideoSendStreamImpl::VideoSendStreamImpl(
           AlrExperimentSettings::kStrictPacingAndProbingExperimentName);
     }
     if (alr_settings) {
-      transport->send_side_cc()->EnablePeriodicAlrProbing(true);
+      transport->EnablePeriodicAlrProbing(true);
       transport->pacer()->SetPacingFactor(alr_settings->pacing_factor);
       configured_pacing_factor_ = alr_settings->pacing_factor;
       transport->pacer()->SetQueueTimeLimit(alr_settings->max_paced_queue_time);
@@ -846,7 +845,7 @@ VideoSendStreamImpl::VideoSendStreamImpl(
   }
 
   if (config_->periodic_alr_bandwidth_probing) {
-    transport->send_side_cc()->EnablePeriodicAlrProbing(true);
+    transport->EnablePeriodicAlrProbing(true);
   }
 
   // RTP/RTCP initialization.
@@ -890,7 +889,7 @@ VideoSendStreamImpl::VideoSendStreamImpl(
   fec_controller_->SetProtectionCallback(this);
   // Signal congestion controller this object is ready for OnPacket* callbacks.
   if (fec_controller_->UseLossVectorMask()) {
-    transport_->send_side_cc()->RegisterPacketFeedbackObserver(this);
+    transport_->RegisterPacketFeedbackObserver(this);
   }
 
   RTC_DCHECK(config_->encoder_settings.encoder);
@@ -936,7 +935,7 @@ VideoSendStreamImpl::~VideoSendStreamImpl() {
       << "VideoSendStreamImpl::Stop not called";
   RTC_LOG(LS_INFO) << "~VideoSendStreamInternal: " << config_->ToString();
   if (fec_controller_->UseLossVectorMask()) {
-    transport_->send_side_cc()->DeRegisterPacketFeedbackObserver(this);
+    transport_->DeRegisterPacketFeedbackObserver(this);
   }
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     transport_->packet_router()->RemoveSendRtpModule(rtp_rtcp);
@@ -1424,8 +1423,7 @@ void VideoSendStreamImpl::SetTransportOverhead(
 
   transport_overhead_bytes_per_packet_ = transport_overhead_bytes_per_packet;
 
-  transport_->send_side_cc()->SetTransportOverhead(
-      transport_overhead_bytes_per_packet_);
+  transport_->SetTransportOverhead(transport_overhead_bytes_per_packet_);
 
   size_t rtp_packet_size =
       std::min(config_->rtp.max_packet_size,