Split CongestionController into send- and receive-side classes.

webrtc/call/call.cc

Index: webrtc/call/call.cc
diff --git a/webrtc/call/call.cc b/webrtc/call/call.cc
index c512d54c73cb5f3839568c8e196350a1902ad3db..a52aa621e8e16e84bc6ad1717df0243dee91fd1b 100644
--- a/webrtc/call/call.cc
+++ b/webrtc/call/call.cc
@@ -36,7 +36,8 @@
 #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/congestion_controller/include/receive_side_congestion_controller.h"
+#include "webrtc/modules/congestion_controller/include/send_side_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"
@@ -94,7 +95,7 @@ namespace internal {
 class Call : public webrtc::Call,
              public PacketReceiver,
              public RecoveredPacketReceiver,
-             public CongestionController::Observer,
+             public SendSideCongestionController::Observer,
              public BitrateAllocator::LimitObserver {
  public:
   explicit Call(const Call::Config& config);
@@ -273,9 +274,8 @@ class Call : public webrtc::Call,
 
   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_;
+  SendSideCongestionController send_side_congestion_controller_;
+  ReceiveSideCongestionController receive_side_congestion_controller_;
   const std::unique_ptr<SendDelayStats> video_send_delay_stats_;
   const int64_t start_ms_;
   // TODO(perkj): |worker_queue_| is supposed to replace
@@ -329,11 +329,11 @@ Call::Call(const Call::Config& config)
       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_)),
+      send_side_congestion_controller_(clock_,
+                                       this,
+                                       event_log_,
+                                       &packet_router_),
+      receive_side_congestion_controller_(clock_, &remb_, &packet_router_),
       video_send_delay_stats_(new SendDelayStats(clock_)),
       start_ms_(clock_->TimeInMilliseconds()),
       worker_queue_("call_worker_queue") {
@@ -347,21 +347,25 @@ Call::Call(const Call::Config& config)
                   config.bitrate_config.start_bitrate_bps);
   }
   Trace::CreateTrace();
-  call_stats_->RegisterStatsObserver(congestion_controller_.get());
+  call_stats_->RegisterStatsObserver(&send_side_congestion_controller_);
 
-  congestion_controller_->SignalNetworkState(kNetworkDown);
-  congestion_controller_->SetBweBitrates(
+  send_side_congestion_controller_.SignalNetworkState(kNetworkDown);
+  send_side_congestion_controller_.SetBweBitrates(
       config_.bitrate_config.min_bitrate_bps,
       config_.bitrate_config.start_bitrate_bps,
       config_.bitrate_config.max_bitrate_bps);
 
   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(&send_side_congestion_controller_,
                                          RTC_FROM_HERE);
-  pacer_thread_->RegisterModule(congestion_controller_->pacer(), RTC_FROM_HERE);
+  module_process_thread_->RegisterModule(&receive_side_congestion_controller_,
+                                         RTC_FROM_HERE);
+  pacer_thread_->RegisterModule(send_side_congestion_controller_.pacer(),
+                                RTC_FROM_HERE);
   pacer_thread_->RegisterModule(
-      congestion_controller_->GetRemoteBitrateEstimator(true), RTC_FROM_HERE);
+      receive_side_congestion_controller_.GetRemoteBitrateEstimator(true),
+      RTC_FROM_HERE);
   pacer_thread_->Start();
 }
 
@@ -377,13 +381,15 @@ Call::~Call() {
   RTC_CHECK(video_receive_streams_.empty());
 
   pacer_thread_->Stop();
-  pacer_thread_->DeRegisterModule(congestion_controller_->pacer());
+  pacer_thread_->DeRegisterModule(send_side_congestion_controller_.pacer());
   pacer_thread_->DeRegisterModule(
-      congestion_controller_->GetRemoteBitrateEstimator(true));
-  module_process_thread_->DeRegisterModule(congestion_controller_.get());
+      receive_side_congestion_controller_.GetRemoteBitrateEstimator(true));
+  module_process_thread_->DeRegisterModule(&send_side_congestion_controller_);
+  module_process_thread_->DeRegisterModule(
+      &receive_side_congestion_controller_);
   module_process_thread_->DeRegisterModule(call_stats_.get());
   module_process_thread_->Stop();
-  call_stats_->DeregisterStatsObserver(congestion_controller_.get());
+  call_stats_->DeregisterStatsObserver(&send_side_congestion_controller_);
 
   // Only update histograms after process threads have been shut down, so that
   // they won't try to concurrently update stats.
@@ -502,7 +508,7 @@ webrtc::AudioSendStream* Call::CreateAudioSendStream(
   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_,
+      &send_side_congestion_controller_, bitrate_allocator_.get(), event_log_,
       call_stats_->rtcp_rtt_stats());
   {
     WriteLockScoped write_lock(*send_crit_);
@@ -591,7 +597,8 @@ void Call::DestroyAudioReceiveStream(
     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))
+    receive_side_congestion_controller_
+        .GetRemoteBitrateEstimator(UseSendSideBwe(config))
         ->RemoveStream(ssrc);
     size_t num_deleted = audio_receive_ssrcs_.erase(ssrc);
     RTC_DCHECK(num_deleted == 1);
@@ -623,7 +630,7 @@ webrtc::VideoSendStream* Call::CreateVideoSendStream(
   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_,
+      call_stats_.get(), &send_side_congestion_controller_, &packet_router_,
       bitrate_allocator_.get(), video_send_delay_stats_.get(), &remb_,
       event_log_, std::move(config), std::move(encoder_config),
       suspended_video_send_ssrcs_);
@@ -740,7 +747,8 @@ void Call::DestroyVideoReceiveStream(
   }
   const VideoReceiveStream::Config& config = receive_stream_impl->config();
 
-  congestion_controller_->GetRemoteBitrateEstimator(UseSendSideBwe(config))
+  receive_side_congestion_controller_
+      .GetRemoteBitrateEstimator(UseSendSideBwe(config))
       ->RemoveStream(config.rtp.remote_ssrc);
 
   UpdateAggregateNetworkState();
@@ -816,7 +824,8 @@ void Call::DestroyFlexfecReceiveStream(FlexfecReceiveStream* receive_stream) {
         ++media_it;
     }
 
-    congestion_controller_->GetRemoteBitrateEstimator(UseSendSideBwe(config))
+    receive_side_congestion_controller_
+        .GetRemoteBitrateEstimator(UseSendSideBwe(config))
         ->RemoveStream(ssrc);
 
     flexfec_receive_streams_.erase(receive_stream_impl);
@@ -832,15 +841,16 @@ Call::Stats Call::GetStats() const {
   Stats stats;
   // Fetch available send/receive bitrates.
   uint32_t send_bandwidth = 0;
-  congestion_controller_->GetBitrateController()->AvailableBandwidth(
+  send_side_congestion_controller_.GetBitrateController()->AvailableBandwidth(
       &send_bandwidth);
   std::vector<unsigned int> ssrcs;
   uint32_t recv_bandwidth = 0;
-  congestion_controller_->GetRemoteBitrateEstimator(false)->LatestEstimate(
-      &ssrcs, &recv_bandwidth);
+  receive_side_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 =
+      send_side_congestion_controller_.GetPacerQueuingDelayMs();
   stats.rtt_ms = call_stats_->rtcp_rtt_stats()->LastProcessedRtt();
   {
     rtc::CritScope cs(&bitrate_crit_);
@@ -873,9 +883,9 @@ void Call::SetBitrateConfig(
     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);
+  send_side_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) {
@@ -970,10 +980,12 @@ 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);
-    congestion_controller_->OnNetworkRouteChanged(
+    send_side_congestion_controller_.OnNetworkRouteChanged(
         network_route, config_.bitrate_config.start_bitrate_bps,
         config_.bitrate_config.min_bitrate_bps,
         config_.bitrate_config.max_bitrate_bps);
+    receive_side_congestion_controller_.OnNetworkRouteChanged(

[stefan-webrtc, 2017/03/17 08:03:32]

We only have to call this if we're using recv-side bwe. Should we put it under a
check like that, or is that just making the code more complicated?

[nisse-webrtc, 2017/03/17 10:49:23]

Do we have any super easy way to check if we're using recv-side bwe (for all
streams)? If not, I think it's best to keep it simple.

But even simpler is to delete the call, as you suggested in your other comment.
So I'm doing that.

+        config_.bitrate_config.start_bitrate_bps);
   }
 }
 
@@ -1006,7 +1018,7 @@ void Call::UpdateAggregateNetworkState() {
   LOG(LS_INFO) << "UpdateAggregateNetworkState: aggregate_state="
                << (aggregate_state == kNetworkUp ? "up" : "down");
 
-  congestion_controller_->SignalNetworkState(aggregate_state);
+  send_side_congestion_controller_.SignalNetworkState(aggregate_state);
 }
 
 void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
@@ -1014,7 +1026,7 @@ void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
     first_packet_sent_ms_ = clock_->TimeInMilliseconds();
   video_send_delay_stats_->OnSentPacket(sent_packet.packet_id,
                                         clock_->TimeInMilliseconds());
-  congestion_controller_->OnSentPacket(sent_packet);
+  send_side_congestion_controller_.OnSentPacket(sent_packet);
 }
 
 void Call::OnNetworkChanged(uint32_t target_bitrate_bps,
@@ -1065,7 +1077,7 @@ void Call::OnNetworkChanged(uint32_t target_bitrate_bps,
 
 void Call::OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
                                      uint32_t max_padding_bitrate_bps) {
-  congestion_controller_->SetAllocatedSendBitrateLimits(
+  send_side_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;
@@ -1278,7 +1290,7 @@ void Call::NotifyBweOfReceivedPacket(const RtpPacketReceived& packet,
   // 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(
+    receive_side_congestion_controller_.OnReceivedPacket(
         packet.arrival_time_ms(), packet.payload_size() + packet.padding_size(),
         header);
   }