Remove use of ReceiveStreamRtpConfig:transport_cc

With this change, webrtc will send RTCP transport feedback for all received packets that have a transport sequence number, if the header extension
http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions is negotiated.
I.e the SDP attribute a=rtcp-fb:96 transport-cc is ignored.


Change-Id: I95d8d4405dc86a2f872f7883b7bafd623d5f7841

Bug: webrtc:14802
Change-Id: I95d8d4405dc86a2f872f7883b7bafd623d5f7841
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/290403
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Per Kjellander <perkj@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38980}

audio/audio_receive_stream.cc

@@ -38,7 +38,6 @@ std::string AudioReceiveStreamInterface::Config::Rtp::ToString() const {
   rtc::SimpleStringBuilder ss(ss_buf);
   ss << "{remote_ssrc: " << remote_ssrc;
   ss << ", local_ssrc: " << local_ssrc;
-  ss << ", transport_cc: " << (transport_cc ? "on" : "off");
   ss << ", nack: " << nack.ToString();
   ss << ", extensions: [";
   for (size_t i = 0; i < extensions.size(); ++i) {
@@ -209,16 +208,6 @@ void AudioReceiveStreamImpl::Stop() {
   audio_state()->RemoveReceivingStream(this);
 }
 
-bool AudioReceiveStreamImpl::transport_cc() const {
-  RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
-  return config_.rtp.transport_cc;
-}
-
-void AudioReceiveStreamImpl::SetTransportCc(bool transport_cc) {
-  RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
-  config_.rtp.transport_cc = transport_cc;
-}
-
 bool AudioReceiveStreamImpl::IsRunning() const {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
   return playing_;

audio/audio_receive_stream.h

@@ -85,8 +85,6 @@ class AudioReceiveStreamImpl final : public webrtc::AudioReceiveStreamInterface,
   // webrtc::AudioReceiveStreamInterface implementation.
   void Start() override;
   void Stop() override;
-  bool transport_cc() const override;
-  void SetTransportCc(bool transport_cc) override;
   bool IsRunning() const override;
   void SetDepacketizerToDecoderFrameTransformer(
       rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)

audio/audio_receive_stream_unittest.cc

@@ -216,7 +216,7 @@ TEST(AudioReceiveStreamTest, ConfigToString) {
   config.rtp.extensions.push_back(
       RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId));
   EXPECT_EQ(
-      "{rtp: {remote_ssrc: 1234, local_ssrc: 5678, transport_cc: off, nack: "
+      "{rtp: {remote_ssrc: 1234, local_ssrc: 5678, nack: "
       "{rtp_history_ms: 0}, extensions: [{uri: "
       "urn:ietf:params:rtp-hdrext:ssrc-audio-level, id: 3}]}, "
       "rtcp_send_transport: null}",
@@ -234,7 +234,6 @@ TEST(AudioReceiveStreamTest, ConstructDestruct) {
 TEST(AudioReceiveStreamTest, ReceiveRtcpPacket) {
   for (bool use_null_audio_processing : {false, true}) {
     ConfigHelper helper(use_null_audio_processing);
-    helper.config().rtp.transport_cc = true;
     auto recv_stream = helper.CreateAudioReceiveStream();
     std::vector<uint8_t> rtcp_packet = CreateRtcpSenderReport();
     EXPECT_CALL(*helper.channel_receive(),
@@ -403,7 +402,6 @@ TEST(AudioReceiveStreamTest, ReconfigureWithUpdatedConfig) {
     recv_stream->SetDecoderMap(new_config.decoder_map);
 
     EXPECT_CALL(channel_receive, SetNACKStatus(true, 15 + 1)).Times(1);
-    recv_stream->SetTransportCc(new_config.rtp.transport_cc);
     recv_stream->SetNackHistory(300 + 20);
 
     recv_stream->UnregisterFromTransport();

audio/test/audio_bwe_integration_test.cc

@@ -115,7 +115,6 @@ class NoBandwidthDropAfterDtx : public AudioBweTest {
         RtpExtension(RtpExtension::kTransportSequenceNumberUri,
                      kTransportSequenceNumberExtensionId));
     for (AudioReceiveStreamInterface::Config& recv_config : *receive_configs) {
-      recv_config.rtp.transport_cc = true;
       recv_config.rtp.extensions = send_config->rtp.extensions;
       recv_config.rtp.remote_ssrc = send_config->rtp.ssrc;
     }

call/call.cc

@@ -84,11 +84,6 @@ bool HasTransportSequenceNumber(const RtpHeaderExtensionMap& map) {
          map.IsRegistered(kRtpExtensionTransportSequenceNumber02);
 }
 
-bool UseSendSideBwe(const ReceiveStreamInterface* stream) {
-  return stream->transport_cc() &&
-         HasTransportSequenceNumber(stream->GetRtpExtensionMap());
-}
-
 const int* FindKeyByValue(const std::map<int, int>& m, int v) {
   for (const auto& kv : m) {
     if (kv.second == v)
@@ -1553,7 +1548,8 @@ bool Call::IdentifyReceivedPacket(RtpPacketReceived& packet,
   packet.IdentifyExtensions(it->second->GetRtpExtensionMap());
 
   if (use_send_side_bwe) {
-    *use_send_side_bwe = UseSendSideBwe(it->second);
+    *use_send_side_bwe =
+        HasTransportSequenceNumber(it->second->GetRtpExtensionMap());
   }
 
   return true;

call/flexfec_receive_stream_impl.cc

@@ -42,7 +42,6 @@ std::string FlexfecReceiveStream::Config::ToString() const {
     ss << protected_media_ssrcs[i] << ", ";
   if (!protected_media_ssrcs.empty())
     ss << protected_media_ssrcs[i];
-  ss << "], transport_cc: " << (rtp.transport_cc ? "on" : "off");
   ss << ", rtp.extensions: [";
   i = 0;
   for (; i + 1 < rtp.extensions.size(); ++i)
@@ -133,7 +132,6 @@ FlexfecReceiveStreamImpl::FlexfecReceiveStreamImpl(
     RtcpRttStats* rtt_stats)
     : extension_map_(std::move(config.rtp.extensions)),
       remote_ssrc_(config.rtp.remote_ssrc),
-      transport_cc_(config.rtp.transport_cc),
       payload_type_(config.payload_type),
       receiver_(
           MaybeCreateFlexfecReceiver(clock, config, recovered_packet_receiver)),

call/flexfec_receive_stream_impl.h

@@ -69,16 +69,6 @@ class FlexfecReceiveStreamImpl : public FlexfecReceiveStream {
 
   uint32_t remote_ssrc() const { return remote_ssrc_; }
 
-  bool transport_cc() const override {
-    RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
-    return transport_cc_;
-  }
-
-  void SetTransportCc(bool transport_cc) override {
-    RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
-    transport_cc_ = transport_cc;
-  }
-
   void SetRtcpMode(RtcpMode mode) override {
     RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
     rtp_rtcp_->SetRTCPStatus(mode);
@@ -90,7 +80,6 @@ class FlexfecReceiveStreamImpl : public FlexfecReceiveStream {
   RtpHeaderExtensionMap extension_map_;
 
   const uint32_t remote_ssrc_;
-  bool transport_cc_ RTC_GUARDED_BY(packet_sequence_checker_);
 
   // `payload_type_` is initially set to -1, indicating that FlexFec is
   // disabled.

call/flexfec_receive_stream_unittest.cc

@@ -66,7 +66,6 @@ TEST(FlexfecReceiveStreamConfigTest, IsCompleteAndEnabled) {
 
   config.rtp.local_ssrc = 18374743;
   config.rtcp_mode = RtcpMode::kCompound;
-  config.rtp.transport_cc = true;
   config.rtp.extensions.emplace_back(TransportSequenceNumber::Uri(), 7);
   EXPECT_FALSE(config.IsCompleteAndEnabled());
 

call/rampup_tests.cc

@@ -188,17 +188,13 @@ void RampUpTester::ModifyVideoConfigs(
 
   send_config->rtp.extensions.clear();
 
-  bool transport_cc;
   if (extension_type_ == RtpExtension::kAbsSendTimeUri) {
-    transport_cc = false;
     send_config->rtp.extensions.push_back(
         RtpExtension(extension_type_.c_str(), kAbsSendTimeExtensionId));
   } else if (extension_type_ == RtpExtension::kTransportSequenceNumberUri) {
-    transport_cc = true;
     send_config->rtp.extensions.push_back(RtpExtension(
         extension_type_.c_str(), kTransportSequenceNumberExtensionId));
   } else {
-    transport_cc = false;
     send_config->rtp.extensions.push_back(RtpExtension(
         extension_type_.c_str(), kTransmissionTimeOffsetExtensionId));
   }
@@ -221,7 +217,6 @@ void RampUpTester::ModifyVideoConfigs(
 
   size_t i = 0;
   for (VideoReceiveStreamInterface::Config& recv_config : *receive_configs) {
-    recv_config.rtp.transport_cc = transport_cc;
     recv_config.rtp.extensions = send_config->rtp.extensions;
     recv_config.decoders.reserve(1);
     recv_config.decoders[0].payload_type = send_config->rtp.payload_type;
@@ -277,15 +272,12 @@ void RampUpTester::ModifyAudioConfigs(
   send_config->min_bitrate_bps = 6000;
   send_config->max_bitrate_bps = 60000;
 
-  bool transport_cc = false;
   if (extension_type_ == RtpExtension::kTransportSequenceNumberUri) {
-    transport_cc = true;
     send_config->rtp.extensions.push_back(RtpExtension(
         extension_type_.c_str(), kTransportSequenceNumberExtensionId));
   }
 
   for (AudioReceiveStreamInterface::Config& recv_config : *receive_configs) {
-    recv_config.rtp.transport_cc = transport_cc;
     recv_config.rtp.extensions = send_config->rtp.extensions;
     recv_config.rtp.remote_ssrc = send_config->rtp.ssrc;
   }
@@ -301,11 +293,9 @@ void RampUpTester::ModifyFlexfecConfigs(
   (*receive_configs)[0].protected_media_ssrcs = {video_ssrcs_[0]};
   (*receive_configs)[0].rtp.local_ssrc = video_ssrcs_[0];
   if (extension_type_ == RtpExtension::kAbsSendTimeUri) {
-    (*receive_configs)[0].rtp.transport_cc = false;
     (*receive_configs)[0].rtp.extensions.push_back(
         RtpExtension(extension_type_.c_str(), kAbsSendTimeExtensionId));
   } else if (extension_type_ == RtpExtension::kTransportSequenceNumberUri) {
-    (*receive_configs)[0].rtp.transport_cc = true;
     (*receive_configs)[0].rtp.extensions.push_back(RtpExtension(
         extension_type_.c_str(), kTransportSequenceNumberExtensionId));
   }

call/receive_stream.h

@@ -40,12 +40,9 @@ class ReceiveStreamInterface {
     // that the value is read on (i.e. packet delivery).
     uint32_t local_ssrc = 0;
 
-    // Enable feedback for send side bandwidth estimation.
+    // Deprecated. This flag has no effect.
-    // See
+    // TODO(perkj, https://bugs.webrtc.org/14802): Remove this flag once no
-    // https://tools.ietf.org/html/draft-holmer-rmcat-transport-wide-cc-extensions
+    // projects use it.
-    // for details.
-    // This value may change mid-stream and must be done on the same thread
-    // that the value is read on (i.e. packet delivery).
     bool transport_cc = false;
 
     // RTP header extensions used for the received stream.
@@ -59,16 +56,6 @@ class ReceiveStreamInterface {
   virtual void SetRtpExtensions(std::vector<RtpExtension> extensions) = 0;
   virtual RtpHeaderExtensionMap GetRtpExtensionMap() const = 0;
 
-  // Returns a bool for whether feedback for send side bandwidth estimation is
-  // enabled. See
-  // https://tools.ietf.org/html/draft-holmer-rmcat-transport-wide-cc-extensions
-  // for details.
-  // This value may change mid-stream and must be done on the same thread
-  // that the value is read on (i.e. packet delivery).
-  virtual bool transport_cc() const = 0;
-
-  virtual void SetTransportCc(bool transport_cc) = 0;
-
  protected:
   virtual ~ReceiveStreamInterface() {}
 };

call/video_receive_stream.cc

@@ -131,7 +131,6 @@ std::string VideoReceiveStreamInterface::Config::Rtp::ToString() const {
   ss << "{receiver_reference_time_report: "
      << (rtcp_xr.receiver_reference_time_report ? "on" : "off");
   ss << '}';
-  ss << ", transport_cc: " << (transport_cc ? "on" : "off");
   ss << ", lntf: {enabled: " << (lntf.enabled ? "true" : "false") << '}';
   ss << ", nack: {rtp_history_ms: " << nack.rtp_history_ms << '}';
   ss << ", ulpfec_payload_type: " << ulpfec_payload_type;

media/engine/fake_webrtc_call.h

@@ -113,10 +113,6 @@ class FakeAudioReceiveStream final
     config_.sync_group = std::string(sync_group);
   }
 
-  bool transport_cc() const override { return config_.rtp.transport_cc; }
-  void SetTransportCc(bool transport_cc) override {
-    config_.rtp.transport_cc = transport_cc;
-  }
   uint32_t remote_ssrc() const override { return config_.rtp.remote_ssrc; }
   void Start() override { started_ = true; }
   void Stop() override { started_ = false; }
@@ -282,10 +278,6 @@ class FakeVideoReceiveStream final
   // webrtc::VideoReceiveStreamInterface implementation.
   void SetRtpExtensions(std::vector<webrtc::RtpExtension> extensions) override;
   webrtc::RtpHeaderExtensionMap GetRtpExtensionMap() const override;
-  bool transport_cc() const override { return config_.rtp.transport_cc; }
-  void SetTransportCc(bool transport_cc) override {
-    config_.rtp.transport_cc = transport_cc;
-  }
   void SetRtcpMode(webrtc::RtcpMode mode) override {
     config_.rtp.rtcp_mode = mode;
   }
@@ -351,10 +343,6 @@ class FakeFlexfecReceiveStream final : public webrtc::FlexfecReceiveStream {
 
   void SetRtpExtensions(std::vector<webrtc::RtpExtension> extensions) override;
   webrtc::RtpHeaderExtensionMap GetRtpExtensionMap() const override;
-  bool transport_cc() const override { return config_.rtp.transport_cc; }
-  void SetTransportCc(bool transport_cc) override {
-    config_.rtp.transport_cc = transport_cc;
-  }
   void SetRtcpMode(webrtc::RtcpMode mode) override { config_.rtcp_mode = mode; }
 
   int payload_type() const override { return config_.payload_type; }

media/engine/webrtc_video_engine.cc

@@ -998,7 +998,6 @@ bool WebRtcVideoChannel::ApplyChangedParams(
       RTC_DCHECK(kv.second != nullptr);
       kv.second->SetFeedbackParameters(
           HasLntf(send_codec_->codec), HasNack(send_codec_->codec),
-          HasTransportCc(send_codec_->codec),
           send_params_.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize
                                          : webrtc::RtcpMode::kCompound,
           send_codec_->rtx_time);
@@ -1515,10 +1514,6 @@ void WebRtcVideoChannel::ConfigureReceiverRtp(
   if (send_codec_ && send_codec_->rtx_time != -1) {
     config->rtp.nack.rtp_history_ms = send_codec_->rtx_time;
   }
-
-  config->rtp.transport_cc =
-      send_codec_ ? HasTransportCc(send_codec_->codec) : false;
-
   sp.GetFidSsrc(ssrc, &config->rtp.rtx_ssrc);
 
   config->rtp.extensions = recv_rtp_extensions_;
@@ -1530,9 +1525,6 @@ void WebRtcVideoChannel::ConfigureReceiverRtp(
     flexfec_config->protected_media_ssrcs = {ssrc};
     flexfec_config->rtp.local_ssrc = config->rtp.local_ssrc;
     flexfec_config->rtcp_mode = config->rtp.rtcp_mode;
-    // TODO(brandtr): We should be spec-compliant and set `transport_cc` here
-    // based on the rtcp-fb for the FlexFEC codec, not the media codec.
-    flexfec_config->rtp.transport_cc = config->rtp.transport_cc;
     flexfec_config->rtp.extensions = config->rtp.extensions;
   }
 }
@@ -2986,7 +2978,6 @@ bool WebRtcVideoChannel::WebRtcVideoReceiveStream::ReconfigureCodecs(
 void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetFeedbackParameters(
     bool lntf_enabled,
     bool nack_enabled,
-    bool transport_cc_enabled,
     webrtc::RtcpMode rtcp_mode,
     int rtx_time) {
   RTC_DCHECK(stream_);
@@ -3001,17 +2992,6 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetFeedbackParameters(
     }
   }
 
-  if (config_.rtp.transport_cc != transport_cc_enabled) {
-    config_.rtp.transport_cc = transport_cc_enabled;
-    stream_->SetTransportCc(transport_cc_enabled);
-    // TODO(brandtr): We should be spec-compliant and set `transport_cc` here
-    // based on the rtcp-fb for the FlexFEC codec, not the media codec.
-    flexfec_config_.rtp.transport_cc = transport_cc_enabled;
-    if (flexfec_stream_) {
-      flexfec_stream_->SetTransportCc(transport_cc_enabled);
-    }
-  }
-
   config_.rtp.lntf.enabled = lntf_enabled;
   stream_->SetLossNotificationEnabled(lntf_enabled);
 

media/engine/webrtc_video_engine.h

@@ -487,7 +487,6 @@ class WebRtcVideoChannel : public VideoMediaChannel,
     // TODO(deadbeef): Move these feedback parameters into the recv parameters.
     void SetFeedbackParameters(bool lntf_enabled,
                                bool nack_enabled,
-                               bool transport_cc_enabled,
                                webrtc::RtcpMode rtcp_mode,
                                int rtx_time);
     void SetRecvParameters(const ChangedRecvParameters& recv_params);

media/engine/webrtc_video_engine_unittest.cc

@@ -3107,32 +3107,6 @@ TEST_F(WebRtcVideoChannelTest, RtcpIsCompoundByDefault) {
   EXPECT_EQ(webrtc::RtcpMode::kCompound, stream->GetConfig().rtp.rtcp_mode);
 }
 
-TEST_F(WebRtcVideoChannelTest, TransportCcIsEnabledByDefault) {
-  FakeVideoReceiveStream* stream = AddRecvStream();
-  EXPECT_TRUE(stream->transport_cc());
-}
-
-TEST_F(WebRtcVideoChannelTest, TransportCcCanBeEnabledAndDisabled) {
-  FakeVideoReceiveStream* stream = AddRecvStream();
-  EXPECT_TRUE(stream->transport_cc());
-
-  // Verify that transport cc feedback is turned off when send(!) codecs without
-  // transport cc feedback are set.
-  cricket::VideoSendParameters parameters;
-  parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8")));
-  EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
-  EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  stream = fake_call_->GetVideoReceiveStreams()[0];
-  EXPECT_FALSE(stream->transport_cc());
-
-  // Verify that transport cc feedback is turned on when setting default codecs
-  // since the default codecs have transport cc feedback enabled.
-  parameters.codecs = engine_.send_codecs();
-  EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  stream = fake_call_->GetVideoReceiveStreams()[0];
-  EXPECT_TRUE(stream->transport_cc());
-}
-
 TEST_F(WebRtcVideoChannelTest, LossNotificationIsDisabledByDefault) {
   TestLossNotificationState(false);
 }
@@ -4414,10 +4388,6 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvCodecsWithFec) {
   EXPECT_EQ(video_stream_config.rtp.rtcp_mode, flexfec_stream_config.rtcp_mode);
   EXPECT_EQ(video_stream_config.rtcp_send_transport,
             flexfec_stream_config.rtcp_send_transport);
-  // TODO(brandtr): Update this EXPECT when we set `transport_cc` in a
-  // spec-compliant way.
-  EXPECT_EQ(video_stream_config.rtp.transport_cc,
-            flexfec_stream_config.rtp.transport_cc);
   EXPECT_EQ(video_stream_config.rtp.rtcp_mode, flexfec_stream_config.rtcp_mode);
   EXPECT_EQ(video_stream_config.rtp.extensions,
             flexfec_stream_config.rtp.extensions);

media/engine/webrtc_voice_engine.cc

@@ -247,7 +247,6 @@ struct AdaptivePtimeConfig {
 webrtc::AudioReceiveStreamInterface::Config BuildReceiveStreamConfig(
     uint32_t remote_ssrc,
     uint32_t local_ssrc,
-    bool use_transport_cc,
     bool use_nack,
     bool enable_non_sender_rtt,
     const std::vector<std::string>& stream_ids,
@@ -265,7 +264,6 @@ webrtc::AudioReceiveStreamInterface::Config BuildReceiveStreamConfig(
   webrtc::AudioReceiveStreamInterface::Config config;
   config.rtp.remote_ssrc = remote_ssrc;
   config.rtp.local_ssrc = local_ssrc;
-  config.rtp.transport_cc = use_transport_cc;
   config.rtp.nack.rtp_history_ms = use_nack ? kNackRtpHistoryMs : 0;
   if (!stream_ids.empty()) {
     config.sync_group = stream_ids[0];
@@ -1163,9 +1161,8 @@ class WebRtcVoiceMediaChannel::WebRtcAudioReceiveStream {
     stream_->SetFrameDecryptor(std::move(frame_decryptor));
   }
 
-  void SetUseTransportCc(bool use_transport_cc, bool use_nack) {
+  void SetUseNack(bool use_nack) {
     RTC_DCHECK_RUN_ON(&worker_thread_checker_);
-    stream_->SetTransportCc(use_transport_cc);
     stream_->SetNackHistory(use_nack ? kNackRtpHistoryMs : 0);
   }
 
@@ -1740,17 +1737,13 @@ bool WebRtcVoiceMediaChannel::SetSendCodecs(
   }
   call_->GetTransportControllerSend()->SetSdpBitrateParameters(bitrate_config);
 
-  // Check if the transport cc feedback or NACK status has changed on the
+  // Check if the NACK status has changed on the
   // preferred send codec, and in that case reconfigure all receive streams.
-  if (recv_transport_cc_enabled_ != send_codec_spec_->transport_cc_enabled ||
+  if (recv_nack_enabled_ != send_codec_spec_->nack_enabled) {
-      recv_nack_enabled_ != send_codec_spec_->nack_enabled) {
+    RTC_LOG(LS_INFO) << "Changing NACK status on receive streams.";
-    RTC_LOG(LS_INFO) << "Changing transport cc and NACK status on receive "
-                        "streams.";
-    recv_transport_cc_enabled_ = send_codec_spec_->transport_cc_enabled;
     recv_nack_enabled_ = send_codec_spec_->nack_enabled;
     for (auto& kv : recv_streams_) {
-      kv.second->SetUseTransportCc(recv_transport_cc_enabled_,
+      kv.second->SetUseNack(recv_nack_enabled_);
-                                   recv_nack_enabled_);
     }
   }
 
@@ -1928,10 +1921,9 @@ bool WebRtcVoiceMediaChannel::AddRecvStream(const StreamParams& sp) {
 
   // Create a new channel for receiving audio data.
   auto config = BuildReceiveStreamConfig(
-      ssrc, receiver_reports_ssrc_, recv_transport_cc_enabled_,
+      ssrc, receiver_reports_ssrc_, recv_nack_enabled_, enable_non_sender_rtt_,
-      recv_nack_enabled_, enable_non_sender_rtt_, sp.stream_ids(),
+      sp.stream_ids(), recv_rtp_extensions_, this, engine()->decoder_factory_,
-      recv_rtp_extensions_, this, engine()->decoder_factory_, decoder_map_,
+      decoder_map_, codec_pair_id_, engine()->audio_jitter_buffer_max_packets_,
-      codec_pair_id_, engine()->audio_jitter_buffer_max_packets_,
       engine()->audio_jitter_buffer_fast_accelerate_,
       engine()->audio_jitter_buffer_min_delay_ms_, unsignaled_frame_decryptor_,
       crypto_options_, unsignaled_frame_transformer_);

media/engine/webrtc_voice_engine.h

@@ -270,7 +270,6 @@ class WebRtcVoiceMediaChannel final : public VoiceMediaChannel,
   AudioOptions options_;
   absl::optional<int> dtmf_payload_type_;
   int dtmf_payload_freq_ = -1;
-  bool recv_transport_cc_enabled_ = false;
   bool recv_nack_enabled_ = false;
   bool enable_non_sender_rtt_ = false;
   bool playout_ = false;

media/engine/webrtc_voice_engine_unittest.cc

@@ -842,7 +842,6 @@ TEST_P(WebRtcVoiceEngineTestFake, CreateRecvStream) {
       GetRecvStreamConfig(kSsrcX);
   EXPECT_EQ(kSsrcX, config.rtp.remote_ssrc);
   EXPECT_EQ(0xFA17FA17, config.rtp.local_ssrc);
-  EXPECT_FALSE(config.rtp.transport_cc);
   EXPECT_EQ(0u, config.rtp.extensions.size());
   EXPECT_EQ(static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_),
             config.rtcp_send_transport);
@@ -1866,26 +1865,6 @@ TEST_P(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) {
   EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcZ).rtp.nack.rtp_history_ms);
 }
 
-TEST_P(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) {
-  EXPECT_TRUE(SetupChannel());
-  cricket::AudioSendParameters send_parameters;
-  send_parameters.codecs.push_back(kOpusCodec);
-  EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty());
-  SetSendParameters(send_parameters);
-
-  cricket::AudioRecvParameters recv_parameters;
-  recv_parameters.codecs.push_back(kOpusCodec);
-  EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters));
-  EXPECT_TRUE(AddRecvStream(kSsrcX));
-  ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr);
-  EXPECT_FALSE(call_.GetAudioReceiveStream(kSsrcX)->transport_cc());
-
-  send_parameters.codecs = engine_->send_codecs();
-  SetSendParameters(send_parameters);
-  ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr);
-  EXPECT_TRUE(call_.GetAudioReceiveStream(kSsrcX)->transport_cc());
-}
-
 // Test that we can switch back and forth between Opus and PCMU with CN.
 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsOpusPcmuSwitching) {
   EXPECT_TRUE(SetupSendStream());

test/call_config_utils.cc

@@ -43,7 +43,6 @@ VideoReceiveStreamInterface::Config ParseVideoReceiveStreamJsonConfig(
       json["rtp"]["rtcp_mode"].asString() == "RtcpMode::kCompound"
           ? RtcpMode::kCompound
           : RtcpMode::kReducedSize;
-  receive_config.rtp.transport_cc = json["rtp"]["transport_cc"].asBool();
   receive_config.rtp.lntf.enabled = json["rtp"]["lntf"]["enabled"].asInt64();
   receive_config.rtp.nack.rtp_history_ms =
       json["rtp"]["nack"]["rtp_history_ms"].asInt64();
@@ -92,7 +91,6 @@ Json::Value GenerateVideoReceiveStreamJsonConfig(
   rtp_json["rtcp_mode"] = config.rtp.rtcp_mode == RtcpMode::kCompound
                               ? "RtcpMode::kCompound"
                               : "RtcpMode::kReducedSize";
-  rtp_json["transport_cc"] = config.rtp.transport_cc;
   rtp_json["lntf"]["enabled"] = config.rtp.lntf.enabled;
   rtp_json["nack"]["rtp_history_ms"] = config.rtp.nack.rtp_history_ms;
   rtp_json["ulpfec_payload_type"] = config.rtp.ulpfec_payload_type;

test/call_config_utils_unittest.cc

@@ -28,7 +28,6 @@ TEST(CallConfigUtils, MarshalUnmarshalProcessSameObject) {
   recv_config.rtp.remote_ssrc = 100;
   recv_config.rtp.local_ssrc = 101;
   recv_config.rtp.rtcp_mode = RtcpMode::kCompound;
-  recv_config.rtp.transport_cc = false;
   recv_config.rtp.lntf.enabled = false;
   recv_config.rtp.nack.rtp_history_ms = 150;
   recv_config.rtp.red_payload_type = 50;
@@ -50,7 +49,6 @@ TEST(CallConfigUtils, MarshalUnmarshalProcessSameObject) {
   EXPECT_EQ(recv_config.rtp.remote_ssrc, unmarshaled_config.rtp.remote_ssrc);
   EXPECT_EQ(recv_config.rtp.local_ssrc, unmarshaled_config.rtp.local_ssrc);
   EXPECT_EQ(recv_config.rtp.rtcp_mode, unmarshaled_config.rtp.rtcp_mode);
-  EXPECT_EQ(recv_config.rtp.transport_cc, unmarshaled_config.rtp.transport_cc);
   EXPECT_EQ(recv_config.rtp.lntf.enabled, unmarshaled_config.rtp.lntf.enabled);
   EXPECT_EQ(recv_config.rtp.nack.rtp_history_ms,
             unmarshaled_config.rtp.nack.rtp_history_ms);

test/call_test.cc

@@ -334,36 +334,33 @@ void CallTest::CreateMatchingVideoReceiveConfigs(
     const VideoSendStream::Config& video_send_config,
     Transport* rtcp_send_transport) {
   CreateMatchingVideoReceiveConfigs(video_send_config, rtcp_send_transport,
-                                    true, &fake_decoder_factory_, absl::nullopt,
+                                    &fake_decoder_factory_, absl::nullopt,
                                     false, 0);
 }
 
 void CallTest::CreateMatchingVideoReceiveConfigs(
     const VideoSendStream::Config& video_send_config,
     Transport* rtcp_send_transport,
-    bool send_side_bwe,
     VideoDecoderFactory* decoder_factory,
     absl::optional<size_t> decode_sub_stream,
     bool receiver_reference_time_report,
     int rtp_history_ms) {
   AddMatchingVideoReceiveConfigs(
       &video_receive_configs_, video_send_config, rtcp_send_transport,
-      send_side_bwe, decoder_factory, decode_sub_stream,
+      decoder_factory, decode_sub_stream, receiver_reference_time_report,
-      receiver_reference_time_report, rtp_history_ms);
+      rtp_history_ms);
 }
 
 void CallTest::AddMatchingVideoReceiveConfigs(
     std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
     const VideoSendStream::Config& video_send_config,
     Transport* rtcp_send_transport,
-    bool send_side_bwe,
     VideoDecoderFactory* decoder_factory,
     absl::optional<size_t> decode_sub_stream,
     bool receiver_reference_time_report,
     int rtp_history_ms) {
   RTC_DCHECK(!video_send_config.rtp.ssrcs.empty());
   VideoReceiveStreamInterface::Config default_config(rtcp_send_transport);
-  default_config.rtp.transport_cc = send_side_bwe;
   default_config.rtp.local_ssrc = kReceiverLocalVideoSsrc;
   for (const RtpExtension& extension : video_send_config.rtp.extensions)
     default_config.rtp.extensions.push_back(extension);
@@ -429,10 +426,6 @@ AudioReceiveStreamInterface::Config CallTest::CreateMatchingAudioConfig(
   audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc;
   audio_config.rtcp_send_transport = transport;
   audio_config.rtp.remote_ssrc = send_config.rtp.ssrc;
-  audio_config.rtp.transport_cc =
-      send_config.send_codec_spec
-          ? send_config.send_codec_spec->transport_cc_enabled
-          : false;
   audio_config.rtp.extensions = send_config.rtp.extensions;
   audio_config.decoder_factory = audio_decoder_factory;
   audio_config.decoder_map = {{kAudioSendPayloadType, {"opus", 48000, 2}}};

test/call_test.h

@@ -113,7 +113,6 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
   void CreateMatchingVideoReceiveConfigs(
       const VideoSendStream::Config& video_send_config,
       Transport* rtcp_send_transport,
-      bool send_side_bwe,
       VideoDecoderFactory* decoder_factory,
       absl::optional<size_t> decode_sub_stream,
       bool receiver_reference_time_report,
@@ -122,7 +121,6 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
       std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
       const VideoSendStream::Config& video_send_config,
       Transport* rtcp_send_transport,
-      bool send_side_bwe,
       VideoDecoderFactory* decoder_factory,
       absl::optional<size_t> decode_sub_stream,
       bool receiver_reference_time_report,

test/fuzzers/vp8_replay_fuzzer.cc

@@ -29,7 +29,6 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
   vp8_config.rtp.local_ssrc = 7731;
   vp8_config.rtp.remote_ssrc = 1337;
   vp8_config.rtp.rtx_ssrc = 100;
-  vp8_config.rtp.transport_cc = true;
   vp8_config.rtp.nack.rtp_history_ms = 1000;
   vp8_config.rtp.lntf.enabled = true;
 

test/fuzzers/vp9_replay_fuzzer.cc

@@ -29,7 +29,6 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
   vp9_config.rtp.local_ssrc = 7731;
   vp9_config.rtp.remote_ssrc = 1337;
   vp9_config.rtp.rtx_ssrc = 100;
-  vp9_config.rtp.transport_cc = true;
   vp9_config.rtp.nack.rtp_history_ms = 1000;
 
   std::vector<VideoReceiveStreamInterface::Config> replay_configs;

test/scenario/audio_stream.cc

@@ -180,7 +180,6 @@ ReceiveAudioStream::ReceiveAudioStream(
   recv_config.rtp.remote_ssrc = send_stream->ssrc_;
   receiver->ssrc_media_types_[recv_config.rtp.remote_ssrc] = MediaType::AUDIO;
   if (config.stream.in_bandwidth_estimation) {
-    recv_config.rtp.transport_cc = true;
     recv_config.rtp.extensions = {{RtpExtension::kTransportSequenceNumberUri,
                                    kTransportSequenceNumberExtensionId}};
   }

test/scenario/video_stream.cc

@@ -329,7 +329,6 @@ VideoReceiveStreamInterface::Config CreateVideoReceiveStreamConfig(
     uint32_t ssrc,
     uint32_t rtx_ssrc) {
   VideoReceiveStreamInterface::Config recv(feedback_transport);
-  recv.rtp.transport_cc = config.stream.packet_feedback;
   recv.rtp.local_ssrc = local_ssrc;
   recv.rtp.extensions = GetVideoRtpExtensions(config);
 

video/end_to_end_tests/bandwidth_tests.cc

@@ -55,7 +55,6 @@ TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
       send_config->rtp.extensions.clear();
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
-      (*receive_configs)[0].rtp.transport_cc = false;
     }
 
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
@@ -106,12 +105,10 @@ class BandwidthStatsTest : public test::EndToEndTest {
     if (!send_side_bwe_) {
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
-      (*receive_configs)[0].rtp.transport_cc = false;
     } else {
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kTransportSequenceNumberUri,
                        kTransportSequenceNumberId));
-      (*receive_configs)[0].rtp.transport_cc = true;
     }
 
     // Force a too high encoder bitrate to make sure we get pacer delay.

video/end_to_end_tests/rtp_rtcp_tests.cc

@@ -540,7 +540,6 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
     flexfec_receive_config.protected_media_ssrcs =
         GetVideoSendConfig()->rtp.flexfec.protected_media_ssrcs;
     flexfec_receive_config.rtp.local_ssrc = kReceiverLocalVideoSsrc;
-    flexfec_receive_config.rtp.transport_cc = true;
     flexfec_receive_config.rtp.extensions.emplace_back(
         RtpExtension::kTransportSequenceNumberUri,
         kTransportSequenceNumberExtensionId);

video/end_to_end_tests/transport_feedback_tests.cc

@@ -244,11 +244,8 @@ class TransportFeedbackEndToEndTest : public test::CallTest {
 
 class TransportFeedbackTester : public test::EndToEndTest {
  public:
-  TransportFeedbackTester(bool feedback_enabled,
+  TransportFeedbackTester(size_t num_video_streams, size_t num_audio_streams)
-                          size_t num_video_streams,
-                          size_t num_audio_streams)
       : EndToEndTest(::webrtc::TransportFeedbackEndToEndTest::kDefaultTimeout),
-        feedback_enabled_(feedback_enabled),
         num_video_streams_(num_video_streams),
         num_audio_streams_(num_audio_streams),
         receiver_call_(nullptr) {
@@ -276,11 +273,7 @@ class TransportFeedbackTester : public test::EndToEndTest {
   }
 
   void PerformTest() override {
-    constexpr TimeDelta kDisabledFeedbackTimeout = TimeDelta::Seconds(5);
+    EXPECT_TRUE(observation_complete_.Wait(test::CallTest::kDefaultTimeout));
-    EXPECT_EQ(feedback_enabled_,
-              observation_complete_.Wait(feedback_enabled_
-                                             ? test::CallTest::kDefaultTimeout
-                                             : kDisabledFeedbackTimeout));
   }
 
   void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
@@ -290,13 +283,6 @@ class TransportFeedbackTester : public test::EndToEndTest {
   size_t GetNumVideoStreams() const override { return num_video_streams_; }
   size_t GetNumAudioStreams() const override { return num_audio_streams_; }
 
-  void ModifyVideoConfigs(
-      VideoSendStream::Config* send_config,
-      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
-      VideoEncoderConfig* encoder_config) override {
-    (*receive_configs)[0].rtp.transport_cc = feedback_enabled_;
-  }
-
   void ModifyAudioConfigs(AudioSendStream::Config* send_config,
                           std::vector<AudioReceiveStreamInterface::Config>*
                               receive_configs) override {
@@ -306,38 +292,25 @@ class TransportFeedbackTester : public test::EndToEndTest {
                      kTransportSequenceNumberExtensionId));
     (*receive_configs)[0].rtp.extensions.clear();
     (*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
-    (*receive_configs)[0].rtp.transport_cc = feedback_enabled_;
   }
 
  private:
-  const bool feedback_enabled_;
   const size_t num_video_streams_;
   const size_t num_audio_streams_;
   Call* receiver_call_;
 };
 
 TEST_F(TransportFeedbackEndToEndTest, VideoReceivesTransportFeedback) {
-  TransportFeedbackTester test(true, 1, 0);
+  TransportFeedbackTester test(1, 0);
   RunBaseTest(&test);
 }
-
-TEST_F(TransportFeedbackEndToEndTest, VideoTransportFeedbackNotConfigured) {
-  TransportFeedbackTester test(false, 1, 0);
-  RunBaseTest(&test);
-}
-
 TEST_F(TransportFeedbackEndToEndTest, AudioReceivesTransportFeedback) {
-  TransportFeedbackTester test(true, 0, 1);
+  TransportFeedbackTester test(0, 1);
-  RunBaseTest(&test);
-}
-
-TEST_F(TransportFeedbackEndToEndTest, AudioTransportFeedbackNotConfigured) {
-  TransportFeedbackTester test(false, 0, 1);
   RunBaseTest(&test);
 }
 
 TEST_F(TransportFeedbackEndToEndTest, AudioVideoReceivesTransportFeedback) {
-  TransportFeedbackTester test(true, 1, 1);
+  TransportFeedbackTester test(1, 1);
   RunBaseTest(&test);
 }
 

video/video_quality_test.cc

@@ -827,9 +827,8 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
     if (!decode_all_receive_streams)
       decode_sub_stream = params_.ss[video_idx].selected_stream;
     CreateMatchingVideoReceiveConfigs(
-        video_send_configs_[video_idx], recv_transport,
+        video_send_configs_[video_idx], recv_transport, &video_decoder_factory_,
-        params_.call.send_side_bwe, &video_decoder_factory_, decode_sub_stream,
+        decode_sub_stream, true, kNackRtpHistoryMs);
-        true, kNackRtpHistoryMs);
 
     if (params_.screenshare[video_idx].enabled) {
       // Fill out codec settings.
@@ -934,7 +933,6 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
     }
 
     CreateMatchingFecConfig(recv_transport, *GetVideoSendConfig());
-    GetFlexFecConfig()->rtp.transport_cc = params_.call.send_side_bwe;
     if (params_.call.send_side_bwe) {
       GetFlexFecConfig()->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kTransportSequenceNumberUri,
@@ -1002,8 +1000,7 @@ void VideoQualityTest::SetupThumbnails(Transport* send_transport,
 
     AddMatchingVideoReceiveConfigs(
         &thumbnail_receive_configs_, thumbnail_send_config, send_transport,
-        params_.call.send_side_bwe, &video_decoder_factory_, absl::nullopt,
+        &video_decoder_factory_, absl::nullopt, false, kNackRtpHistoryMs);
-        false, kNackRtpHistoryMs);
   }
   for (size_t i = 0; i < thumbnail_send_configs_.size(); ++i) {
     thumbnail_send_streams_.push_back(receiver_call_->CreateVideoSendStream(

video/video_receive_stream2.cc

@@ -463,17 +463,6 @@ RtpHeaderExtensionMap VideoReceiveStream2::GetRtpExtensionMap() const {
   return rtp_video_stream_receiver_.GetRtpExtensions();
 }
 
-bool VideoReceiveStream2::transport_cc() const {
-  RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
-  return config_.rtp.transport_cc;
-}
-
-void VideoReceiveStream2::SetTransportCc(bool transport_cc) {
-  RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
-  // TODO(tommi): Stop using the config struct for the internal state.
-  const_cast<bool&>(config_.rtp.transport_cc) = transport_cc;
-}
-
 void VideoReceiveStream2::SetRtcpMode(RtcpMode mode) {
   RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
   // TODO(tommi): Stop using the config struct for the internal state.

video/video_receive_stream2.h

@@ -144,8 +144,6 @@ class VideoReceiveStream2
 
   void SetRtpExtensions(std::vector<RtpExtension> extensions) override;
   RtpHeaderExtensionMap GetRtpExtensionMap() const override;
-  bool transport_cc() const override;
-  void SetTransportCc(bool transport_cc) override;
   void SetRtcpMode(RtcpMode mode) override;
   void SetFlexFecProtection(RtpPacketSinkInterface* flexfec_sink) override;
   void SetLossNotificationEnabled(bool enabled) override;

video/video_send_stream_tests.cc

@@ -1615,7 +1615,6 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
       send_config->rtp.extensions.push_back(RtpExtension(
           RtpExtension::kTransportSequenceNumberUri, kExtensionId));
       (*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
-      (*receive_configs)[0].rtp.transport_cc = true;
     }
 
     void ModifyAudioConfigs(AudioSendStream::Config* send_config,
@@ -1627,7 +1626,6 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
           RtpExtension::kTransportSequenceNumberUri, kExtensionId));
       (*receive_configs)[0].rtp.extensions.clear();
       (*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
-      (*receive_configs)[0].rtp.transport_cc = true;
     }
 
     Action OnSendRtp(const uint8_t* packet, size_t length) override {