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 14 matching lines @@
 #include "webrtc/base/constructormagic.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 {

[stefan-webrtc, 2017/02/17 11:59:28]

Maybe create a new file for this already?

[nisse-webrtc, 2017/02/17 12:35:14]

Could do that. Then I'd need to declare it (or at least some way to create it)
in the header file.

+ 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();
+  }
+
+ 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.

[stefan-webrtc, 2017/02/17 11:59:28]

Doesn't this just mean that we're creating the RtpTransportController in the
wrong place? If we create Call and/or the BandwidthAllocator before the
RtpTransportController this wouldn't be a problem, right? Seems to me that we
might want to enforce that call order.

[nisse-webrtc, 2017/02/17 12:35:14]

That would make sense for now, but longer term, I think one should be able to
create the transport and pass it to the Call constructor. And then one would
need to register the CongestionController's observer later, in some way.

+  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());
-  module_process_thread_->RegisterModule(congestion_controller_.get());
-  pacer_thread_->RegisterModule(congestion_controller_->pacer());
+  module_process_thread_->RegisterModule(transport_->congestion_controller());
+  pacer_thread_->RegisterModule(transport_->congestion_controller()->pacer());
   pacer_thread_->RegisterModule(
-      congestion_controller_->GetRemoteBitrateEstimator(true));
+      transport_->congestion_controller()->GetRemoteBitrateEstimator(true));
   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 43 matching lines @@
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
 
   bool protected_by_flexfec = false;
   {
     ReadLockScoped read_lock(*receive_crit_);
     protected_by_flexfec =
         flexfec_receive_ssrcs_media_.find(configuration.rtp.remote_ssrc) !=
         flexfec_receive_ssrcs_media_.end();
   }
   VideoReceiveStream* receive_stream = new VideoReceiveStream(
-      num_cpu_cores_, protected_by_flexfec,
-      &packet_router_, std::move(configuration), module_process_thread_.get(),
-      call_stats_.get(), &remb_);
+      num_cpu_cores_, protected_by_flexfec, 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))

[stefan-webrtc, 2017/02/17 11:59:28]

What would it take to get rid of GetRemoteBitrateEstimator? Would it be enough
to expose methods on CongestionController, such as, RemoveStream(uint32_t id)
and LatestEstimate() (which probably should be called
GetEstimatedRecvBandwidth() or something)?

I think that would be a nice cleanup.

[nisse-webrtc, 2017/02/17 12:35:14]

I agree this could use some cleanup, but that's for another cl.

It's also not clear to me which methods should be advertised by
CongestionController, and which should be attached to the
RtpTransportController.

       ->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 204 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