Define RtpTransportControllerSendInterface.

webrtc/call/call.cc

 /*
  *  Copyright (c) 2013 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 15 matching lines @@
 #include "webrtc/base/location.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/optional.h"
 #include "webrtc/base/task_queue.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/call/bitrate_allocator.h"
 #include "webrtc/call/call.h"
 #include "webrtc/call/flexfec_receive_stream_impl.h"
+#include "webrtc/call/rtp_transport_controller.h"
 #include "webrtc/config.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/congestion_controller/include/congestion_controller.h"
 #include "webrtc/modules/pacing/paced_sender.h"
 #include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
@@ skipping 34 matching lines @@
 }
 
 bool UseSendSideBwe(const AudioReceiveStream::Config& config) {
   return UseSendSideBwe(config.rtp.extensions, config.rtp.transport_cc);
 }
 
 bool UseSendSideBwe(const FlexfecReceiveStream::Config& config) {
   return UseSendSideBwe(config.rtp_header_extensions, config.transport_cc);
 }
 
+class RtpTransportController : public RtpTransportControllerSendInterface {
+ public:
+  RtpTransportController(Clock* clock, webrtc::RtcEventLog* event_log);
+  void InitCongestionControl(CongestionController::Observer* observer);
+  VieRemb* remb() override { return &remb_; }
+  PacketRouter* packet_router() override { return &packet_router_; }
+  CongestionController* congestion_controller() override {
+    return congestion_controller_.get();
+  }
+  TransportFeedbackObserver* transport_feedback_observer() override {
+    return congestion_controller_.get();
+  }
+  RtpPacketSender* packet_sender() override {
+    return congestion_controller_->pacer();
+  }
+
+ private:
+  Clock* const clock_;
+  webrtc::RtcEventLog* const event_log_;
+  VieRemb remb_;
+  PacketRouter packet_router_;
+  // Construction delayed until InitCongestionControl, since the
+  // CongestionController wants its observer as a construction time
+  // argument, and setting it later seems no-trivial.
+  std::unique_ptr<CongestionController> congestion_controller_;
+};
+
+RtpTransportController::RtpTransportController(Clock* clock,
+                                               webrtc::RtcEventLog* event_log)
+    : clock_(clock), event_log_(event_log), remb_(clock) {}
+
+void RtpTransportController::InitCongestionControl(
+    CongestionController::Observer* observer) {
+  // Must be called only once.
+  RTC_CHECK(!congestion_controller_);
+  congestion_controller_.reset(new CongestionController(
+      clock_, observer, &remb_, event_log_, &packet_router_));
+}
+
 }  // namespace
 
 namespace internal {
 
 class Call : public webrtc::Call,
              public PacketReceiver,
              public RecoveredPacketReceiver,
              public CongestionController::Observer,
              public BitrateAllocator::LimitObserver {
  public:
-  explicit Call(const Call::Config& config);
+  Call(const Call::Config& config,
+       std::unique_ptr<RtpTransportController> transport);
   virtual ~Call();
 
   // Implements webrtc::Call.
   PacketReceiver* Receiver() override;
 
   webrtc::AudioSendStream* CreateAudioSendStream(
       const webrtc::AudioSendStream::Config& config) override;
   void DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) override;
 
   webrtc::AudioReceiveStream* CreateAudioReceiveStream(
@@ skipping 153 matching lines @@
   // TODO(holmer): Remove this lock once BitrateController no longer calls
   // OnNetworkChanged from multiple threads.
   rtc::CriticalSection bitrate_crit_;
   uint32_t min_allocated_send_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
   uint32_t configured_max_padding_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
   AvgCounter estimated_send_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
   AvgCounter pacer_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
 
   std::map<std::string, rtc::NetworkRoute> network_routes_;
 
-  VieRemb remb_;
-  PacketRouter packet_router_;
-  // TODO(nisse): Could be a direct member, except for constness
-  // issues with GetRemoteBitrateEstimator (and maybe others).
-  const std::unique_ptr<CongestionController> congestion_controller_;
+  std::unique_ptr<RtpTransportController> transport_;
   const std::unique_ptr<SendDelayStats> video_send_delay_stats_;
   const int64_t start_ms_;
   // TODO(perkj): |worker_queue_| is supposed to replace
   // |module_process_thread_|.
   // |worker_queue| is defined last to ensure all pending tasks are cancelled
   // and deleted before any other members.
   rtc::TaskQueue worker_queue_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(Call);
 };
 }  // namespace internal
 
 std::string Call::Stats::ToString(int64_t time_ms) const {
   std::stringstream ss;
   ss << "Call stats: " << time_ms << ", {";
   ss << "send_bw_bps: " << send_bandwidth_bps << ", ";
   ss << "recv_bw_bps: " << recv_bandwidth_bps << ", ";
   ss << "max_pad_bps: " << max_padding_bitrate_bps << ", ";
   ss << "pacer_delay_ms: " << pacer_delay_ms << ", ";
   ss << "rtt_ms: " << rtt_ms;
   ss << '}';
   return ss.str();
 }
 
 Call* Call::Create(const Call::Config& config) {
-  return new internal::Call(config);
+  return new internal::Call(
+      config,
+      std::unique_ptr<RtpTransportController>(new RtpTransportController(
+          Clock::GetRealTimeClock(), config.event_log)));
 }
 
 namespace internal {
 
-Call::Call(const Call::Config& config)
+Call::Call(const Call::Config& config,
+           std::unique_ptr<RtpTransportController> transport)
     : clock_(Clock::GetRealTimeClock()),
       num_cpu_cores_(CpuInfo::DetectNumberOfCores()),
       module_process_thread_(ProcessThread::Create("ModuleProcessThread")),
       pacer_thread_(ProcessThread::Create("PacerThread")),
       call_stats_(new CallStats(clock_)),
       bitrate_allocator_(new BitrateAllocator(this)),
       config_(config),
       audio_network_state_(kNetworkDown),
       video_network_state_(kNetworkDown),
       receive_crit_(RWLockWrapper::CreateRWLock()),
       send_crit_(RWLockWrapper::CreateRWLock()),
       event_log_(config.event_log),
       first_packet_sent_ms_(-1),
       received_bytes_per_second_counter_(clock_, nullptr, true),
       received_audio_bytes_per_second_counter_(clock_, nullptr, true),
       received_video_bytes_per_second_counter_(clock_, nullptr, true),
       received_rtcp_bytes_per_second_counter_(clock_, nullptr, true),
       min_allocated_send_bitrate_bps_(0),
       configured_max_padding_bitrate_bps_(0),
       estimated_send_bitrate_kbps_counter_(clock_, nullptr, true),
       pacer_bitrate_kbps_counter_(clock_, nullptr, true),
-      remb_(clock_),
-      congestion_controller_(new CongestionController(clock_,
-                                                      this,
-                                                      &remb_,
-                                                      event_log_,
-                                                      &packet_router_)),
+      transport_(std::move(transport)),
       video_send_delay_stats_(new SendDelayStats(clock_)),
       start_ms_(clock_->TimeInMilliseconds()),
       worker_queue_("call_worker_queue") {
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   RTC_DCHECK(config.event_log != nullptr);
   RTC_DCHECK_GE(config.bitrate_config.min_bitrate_bps, 0);
   RTC_DCHECK_GT(config.bitrate_config.start_bitrate_bps,
                 config.bitrate_config.min_bitrate_bps);
   if (config.bitrate_config.max_bitrate_bps != -1) {
     RTC_DCHECK_GE(config.bitrate_config.max_bitrate_bps,
                   config.bitrate_config.start_bitrate_bps);
   }
   Trace::CreateTrace();
-  call_stats_->RegisterStatsObserver(congestion_controller_.get());
-
-  congestion_controller_->SignalNetworkState(kNetworkDown);
-  congestion_controller_->SetBweBitrates(
+  transport_->InitCongestionControl(this);
+  transport_->congestion_controller()->SignalNetworkState(kNetworkDown);
+  transport_->congestion_controller()->SetBweBitrates(
       config_.bitrate_config.min_bitrate_bps,
       config_.bitrate_config.start_bitrate_bps,
       config_.bitrate_config.max_bitrate_bps);
+  call_stats_->RegisterStatsObserver(transport_->congestion_controller());
 
   module_process_thread_->Start();
   module_process_thread_->RegisterModule(call_stats_.get(), RTC_FROM_HERE);
-  module_process_thread_->RegisterModule(congestion_controller_.get(),
+  module_process_thread_->RegisterModule(transport_->congestion_controller(),
                                          RTC_FROM_HERE);
-  pacer_thread_->RegisterModule(congestion_controller_->pacer(), RTC_FROM_HERE);
+  pacer_thread_->RegisterModule(transport_->congestion_controller()->pacer(),
+                                RTC_FROM_HERE);
   pacer_thread_->RegisterModule(
-      congestion_controller_->GetRemoteBitrateEstimator(true), RTC_FROM_HERE);
+      transport_->congestion_controller()->GetRemoteBitrateEstimator(true),
+      RTC_FROM_HERE);
   pacer_thread_->Start();
 }
 
 Call::~Call() {
-  RTC_DCHECK(!remb_.InUse());
+  RTC_DCHECK(!transport_->remb()->InUse());
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
 
   RTC_CHECK(audio_send_ssrcs_.empty());
   RTC_CHECK(video_send_ssrcs_.empty());
   RTC_CHECK(video_send_streams_.empty());
   RTC_CHECK(audio_receive_ssrcs_.empty());
   RTC_CHECK(video_receive_ssrcs_.empty());
   RTC_CHECK(video_receive_streams_.empty());
 
   pacer_thread_->Stop();
-  pacer_thread_->DeRegisterModule(congestion_controller_->pacer());
+  pacer_thread_->DeRegisterModule(transport_->congestion_controller()->pacer());
   pacer_thread_->DeRegisterModule(
-      congestion_controller_->GetRemoteBitrateEstimator(true));
-  module_process_thread_->DeRegisterModule(congestion_controller_.get());
+      transport_->congestion_controller()->GetRemoteBitrateEstimator(true));
+  module_process_thread_->DeRegisterModule(transport_->congestion_controller());
   module_process_thread_->DeRegisterModule(call_stats_.get());
   module_process_thread_->Stop();
-  call_stats_->DeregisterStatsObserver(congestion_controller_.get());
+  call_stats_->DeregisterStatsObserver(transport_->congestion_controller());
 
   // Only update histograms after process threads have been shut down, so that
   // they won't try to concurrently update stats.
   {
     rtc::CritScope lock(&bitrate_crit_);
     UpdateSendHistograms();
   }
   UpdateReceiveHistograms();
   UpdateHistograms();
 
@@ skipping 97 matching lines @@
   // RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   return this;
 }
 
 webrtc::AudioSendStream* Call::CreateAudioSendStream(
     const webrtc::AudioSendStream::Config& config) {
   TRACE_EVENT0("webrtc", "Call::CreateAudioSendStream");
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   event_log_->LogAudioSendStreamConfig(config);
   AudioSendStream* send_stream = new AudioSendStream(
-      config, config_.audio_state, &worker_queue_, &packet_router_,
-      congestion_controller_.get(), bitrate_allocator_.get(), event_log_,
-      call_stats_->rtcp_rtt_stats());
+      config, config_.audio_state, &worker_queue_, transport_.get(),
+      bitrate_allocator_.get(), event_log_, call_stats_->rtcp_rtt_stats());
   {
     WriteLockScoped write_lock(*send_crit_);
     RTC_DCHECK(audio_send_ssrcs_.find(config.rtp.ssrc) ==
                audio_send_ssrcs_.end());
     audio_send_ssrcs_[config.rtp.ssrc] = send_stream;
   }
   {
     ReadLockScoped read_lock(*receive_crit_);
     for (const auto& kv : audio_receive_ssrcs_) {
       if (kv.second->config().rtp.local_ssrc == config.rtp.ssrc) {
@@ skipping 32 matching lines @@
   UpdateAggregateNetworkState();
   delete audio_send_stream;
 }
 
 webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream(
     const webrtc::AudioReceiveStream::Config& config) {
   TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream");
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   event_log_->LogAudioReceiveStreamConfig(config);
   AudioReceiveStream* receive_stream = new AudioReceiveStream(
-      &packet_router_, config,
-      config_.audio_state, event_log_);
+      transport_->packet_router(), config, config_.audio_state, event_log_);
   {
     WriteLockScoped write_lock(*receive_crit_);
     RTC_DCHECK(audio_receive_ssrcs_.find(config.rtp.remote_ssrc) ==
                audio_receive_ssrcs_.end());
     audio_receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream;
     receive_rtp_config_[config.rtp.remote_ssrc] =
         ReceiveRtpConfig(config.rtp.extensions, UseSendSideBwe(config));
 
     ConfigureSync(config.sync_group);
   }
@@ skipping 13 matching lines @@
     webrtc::AudioReceiveStream* receive_stream) {
   TRACE_EVENT0("webrtc", "Call::DestroyAudioReceiveStream");
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   RTC_DCHECK(receive_stream != nullptr);
   webrtc::internal::AudioReceiveStream* audio_receive_stream =
       static_cast<webrtc::internal::AudioReceiveStream*>(receive_stream);
   {
     WriteLockScoped write_lock(*receive_crit_);
     const AudioReceiveStream::Config& config = audio_receive_stream->config();
     uint32_t ssrc = config.rtp.remote_ssrc;
-    congestion_controller_->GetRemoteBitrateEstimator(UseSendSideBwe(config))
+    transport_->congestion_controller()
+        ->GetRemoteBitrateEstimator(UseSendSideBwe(config))
         ->RemoveStream(ssrc);
     size_t num_deleted = audio_receive_ssrcs_.erase(ssrc);
     RTC_DCHECK(num_deleted == 1);
     const std::string& sync_group = audio_receive_stream->config().sync_group;
     const auto it = sync_stream_mapping_.find(sync_group);
     if (it != sync_stream_mapping_.end() &&
         it->second == audio_receive_stream) {
       sync_stream_mapping_.erase(it);
       ConfigureSync(sync_group);
     }
@@ skipping 11 matching lines @@
 
   video_send_delay_stats_->AddSsrcs(config);
   event_log_->LogVideoSendStreamConfig(config);
 
   // TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if
   // the call has already started.
   // Copy ssrcs from |config| since |config| is moved.
   std::vector<uint32_t> ssrcs = config.rtp.ssrcs;
   VideoSendStream* send_stream = new VideoSendStream(
       num_cpu_cores_, module_process_thread_.get(), &worker_queue_,
-      call_stats_.get(), congestion_controller_.get(), &packet_router_,
-      bitrate_allocator_.get(), video_send_delay_stats_.get(), &remb_,
-      event_log_, std::move(config), std::move(encoder_config),
-      suspended_video_send_ssrcs_);
+      call_stats_.get(), transport_.get(), bitrate_allocator_.get(),
+      video_send_delay_stats_.get(), event_log_, std::move(config),
+      std::move(encoder_config), suspended_video_send_ssrcs_);
 
   {
     WriteLockScoped write_lock(*send_crit_);
     for (uint32_t ssrc : ssrcs) {
       RTC_DCHECK(video_send_ssrcs_.find(ssrc) == video_send_ssrcs_.end());
       video_send_ssrcs_[ssrc] = send_stream;
     }
     video_send_streams_.insert(send_stream);
   }
   send_stream->SignalNetworkState(video_network_state_);
@@ skipping 36 matching lines @@
   UpdateAggregateNetworkState();
   delete send_stream_impl;
 }
 
 webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
     webrtc::VideoReceiveStream::Config configuration) {
   TRACE_EVENT0("webrtc", "Call::CreateVideoReceiveStream");
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
 
   VideoReceiveStream* receive_stream = new VideoReceiveStream(
-      num_cpu_cores_, &packet_router_, std::move(configuration),
-      module_process_thread_.get(), call_stats_.get(), &remb_);
+      num_cpu_cores_, transport_->packet_router(),
+      std::move(configuration), module_process_thread_.get(), call_stats_.get(),
+      transport_->remb());
 
   const webrtc::VideoReceiveStream::Config& config = receive_stream->config();
   ReceiveRtpConfig receive_config(config.rtp.extensions,
                                   UseSendSideBwe(config));
   {
     WriteLockScoped write_lock(*receive_crit_);
     RTC_DCHECK(video_receive_ssrcs_.find(config.rtp.remote_ssrc) ==
                video_receive_ssrcs_.end());
     video_receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream;
     if (config.rtp.rtx_ssrc) {
@@ skipping 35 matching lines @@
       } else {
         ++it;
       }
     }
     video_receive_streams_.erase(receive_stream_impl);
     RTC_CHECK(receive_stream_impl != nullptr);
     ConfigureSync(receive_stream_impl->config().sync_group);
   }
   const VideoReceiveStream::Config& config = receive_stream_impl->config();
 
-  congestion_controller_->GetRemoteBitrateEstimator(UseSendSideBwe(config))
+  transport_->congestion_controller()
+      ->GetRemoteBitrateEstimator(UseSendSideBwe(config))
       ->RemoveStream(config.rtp.remote_ssrc);
 
   UpdateAggregateNetworkState();
   delete receive_stream_impl;
 }
 
 FlexfecReceiveStream* Call::CreateFlexfecReceiveStream(
     const FlexfecReceiveStream::Config& config) {
   TRACE_EVENT0("webrtc", "Call::CreateFlexfecReceiveStream");
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
@@ skipping 55 matching lines @@
         ++prot_it;
     }
     auto media_it = flexfec_receive_ssrcs_media_.begin();
     while (media_it != flexfec_receive_ssrcs_media_.end()) {
       if (media_it->second == receive_stream_impl)
         media_it = flexfec_receive_ssrcs_media_.erase(media_it);
       else
         ++media_it;
     }
 
-    congestion_controller_->GetRemoteBitrateEstimator(UseSendSideBwe(config))
+    transport_->congestion_controller()
+        ->GetRemoteBitrateEstimator(UseSendSideBwe(config))
         ->RemoveStream(ssrc);
 
     flexfec_receive_streams_.erase(receive_stream_impl);
   }
 
   delete receive_stream_impl;
 }
 
 Call::Stats Call::GetStats() const {
   // TODO(solenberg): Some test cases in EndToEndTest use this from a different
   // thread. Re-enable once that is fixed.
   // RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   Stats stats;
   // Fetch available send/receive bitrates.
   uint32_t send_bandwidth = 0;
-  congestion_controller_->GetBitrateController()->AvailableBandwidth(
-      &send_bandwidth);
+  transport_->congestion_controller()
+      ->GetBitrateController()
+      ->AvailableBandwidth(&send_bandwidth);
   std::vector<unsigned int> ssrcs;
   uint32_t recv_bandwidth = 0;
-  congestion_controller_->GetRemoteBitrateEstimator(false)->LatestEstimate(
-      &ssrcs, &recv_bandwidth);
+  transport_->congestion_controller()
+      ->GetRemoteBitrateEstimator(false)
+      ->LatestEstimate(&ssrcs, &recv_bandwidth);
   stats.send_bandwidth_bps = send_bandwidth;
   stats.recv_bandwidth_bps = recv_bandwidth;
-  stats.pacer_delay_ms = congestion_controller_->GetPacerQueuingDelayMs();
+  stats.pacer_delay_ms =
+      transport_->congestion_controller()->GetPacerQueuingDelayMs();
   stats.rtt_ms = call_stats_->rtcp_rtt_stats()->LastProcessedRtt();
   {
     rtc::CritScope cs(&bitrate_crit_);
     stats.max_padding_bitrate_bps = configured_max_padding_bitrate_bps_;
   }
   return stats;
 }
 
 void Call::SetBitrateConfig(
     const webrtc::Call::Config::BitrateConfig& bitrate_config) {
@@ skipping 12 matching lines @@
     // Nothing new to set, early abort to avoid encoder reconfigurations.
     return;
   }
   config_.bitrate_config.min_bitrate_bps = bitrate_config.min_bitrate_bps;
   // Start bitrate of -1 means we should keep the old bitrate, which there is
   // no point in remembering for the future.
   if (bitrate_config.start_bitrate_bps > 0)
     config_.bitrate_config.start_bitrate_bps = bitrate_config.start_bitrate_bps;
   config_.bitrate_config.max_bitrate_bps = bitrate_config.max_bitrate_bps;
   RTC_DCHECK_NE(bitrate_config.start_bitrate_bps, 0);
-  congestion_controller_->SetBweBitrates(bitrate_config.min_bitrate_bps,
-                                         bitrate_config.start_bitrate_bps,
-                                         bitrate_config.max_bitrate_bps);
+  transport_->congestion_controller()->SetBweBitrates(
+      bitrate_config.min_bitrate_bps, bitrate_config.start_bitrate_bps,
+      bitrate_config.max_bitrate_bps);
 }
 
 void Call::SignalChannelNetworkState(MediaType media, NetworkState state) {
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   switch (media) {
     case MediaType::AUDIO:
       audio_network_state_ = state;
       break;
     case MediaType::VIDEO:
       video_network_state_ = state;
@@ skipping 74 matching lines @@
     kv->second = network_route;
     LOG(LS_INFO) << "Network route changed on transport " << transport_name
                  << ": new local network id " << network_route.local_network_id
                  << " new remote network id " << network_route.remote_network_id
                  << " Reset bitrates to min: "
                  << config_.bitrate_config.min_bitrate_bps
                  << " bps, start: " << config_.bitrate_config.start_bitrate_bps
                  << " bps,  max: " << config_.bitrate_config.start_bitrate_bps
                  << " bps.";
     RTC_DCHECK_GT(config_.bitrate_config.start_bitrate_bps, 0);
-    congestion_controller_->ResetBweAndBitrates(
+    transport_->congestion_controller()->ResetBweAndBitrates(
         config_.bitrate_config.start_bitrate_bps,
         config_.bitrate_config.min_bitrate_bps,
         config_.bitrate_config.max_bitrate_bps);
   }
 }
 
 void Call::UpdateAggregateNetworkState() {
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
 
   bool have_audio = false;
@@ skipping 15 matching lines @@
 
   NetworkState aggregate_state = kNetworkDown;
   if ((have_video && video_network_state_ == kNetworkUp) ||
       (have_audio && audio_network_state_ == kNetworkUp)) {
     aggregate_state = kNetworkUp;
   }
 
   LOG(LS_INFO) << "UpdateAggregateNetworkState: aggregate_state="
                << (aggregate_state == kNetworkUp ? "up" : "down");
 
-  congestion_controller_->SignalNetworkState(aggregate_state);
+  transport_->congestion_controller()->SignalNetworkState(aggregate_state);
 }
 
 void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
   if (first_packet_sent_ms_ == -1)
     first_packet_sent_ms_ = clock_->TimeInMilliseconds();
   video_send_delay_stats_->OnSentPacket(sent_packet.packet_id,
                                         clock_->TimeInMilliseconds());
-  congestion_controller_->OnSentPacket(sent_packet);
+  transport_->congestion_controller()->OnSentPacket(sent_packet);
 }
 
 void Call::OnNetworkChanged(uint32_t target_bitrate_bps,
                             uint8_t fraction_loss,
                             int64_t rtt_ms,
                             int64_t probing_interval_ms) {
   // TODO(perkj): Consider making sure CongestionController operates on
   // |worker_queue_|.
   if (!worker_queue_.IsCurrent()) {
     worker_queue_.PostTask(
@@ skipping 30 matching lines @@
   }
   estimated_send_bitrate_kbps_counter_.Add(target_bitrate_bps / 1000);
   // Pacer bitrate may be higher than bitrate estimate if enforcing min bitrate.
   uint32_t pacer_bitrate_bps =
       std::max(target_bitrate_bps, min_allocated_send_bitrate_bps_);
   pacer_bitrate_kbps_counter_.Add(pacer_bitrate_bps / 1000);
 }
 
 void Call::OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
                                      uint32_t max_padding_bitrate_bps) {
-  congestion_controller_->SetAllocatedSendBitrateLimits(
+  transport_->congestion_controller()->SetAllocatedSendBitrateLimits(
       min_send_bitrate_bps, max_padding_bitrate_bps);
   rtc::CritScope lock(&bitrate_crit_);
   min_allocated_send_bitrate_bps_ = min_send_bitrate_bps;
   configured_max_padding_bitrate_bps_ = max_padding_bitrate_bps;
 }
 
 void Call::ConfigureSync(const std::string& sync_group) {
   // Set sync only if there was no previous one.
   if (sync_group.empty())
     return;
@@ skipping 192 matching lines @@
     // module in the case that some, but not all, have RTCP feedback
     // enabled.
     return;
   }
   // For audio, we only support send side BWE.
   // TODO(nisse): Tests passes MediaType::ANY, see
   // FakeNetworkPipe::Process. We need to treat that as video. Tests
   // should be fixed to use the same MediaType as the production code.
   if (media_type != MediaType::AUDIO ||
       (use_send_side_bwe && header.extension.hasTransportSequenceNumber)) {
-    congestion_controller_->OnReceivedPacket(
+    transport_->congestion_controller()->OnReceivedPacket(
         packet.arrival_time_ms(), packet.payload_size() + packet.padding_size(),
         header);
   }
 }
 
 }  // namespace internal
+
 }  // namespace webrtc