Remove rtp header extension from config of Call audio and video receivers

These configurations are no longer used by call. Header extensions are identified once when demuxing packets in WebrtcVideoEngine::OnPacketReceived and WebrtcVoiceEngine::OnPacketReceived.

Change-Id: I49de9005f0aa9ab32f2c5d3abcdd8bd12343022d
Bug: webrtc:7135
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/291480
Owners-Override: Per Kjellander <perkj@webrtc.org>
Commit-Queue: Per Kjellander <perkj@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Henrik Boström <hbos@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#39236}

audio/audio_receive_stream.cc

@@ -39,14 +39,6 @@ std::string AudioReceiveStreamInterface::Config::Rtp::ToString() const {
   ss << "{remote_ssrc: " << remote_ssrc;
   ss << ", local_ssrc: " << local_ssrc;
   ss << ", nack: " << nack.ToString();
-  ss << ", extensions: [";
-  for (size_t i = 0; i < extensions.size(); ++i) {
-    ss << extensions[i].ToString();
-    if (i != extensions.size() - 1) {
-      ss << ", ";
-    }
-  }
-  ss << ']';
   ss << '}';
   return ss.str();
 }
@@ -254,18 +246,6 @@ void AudioReceiveStreamImpl::SetFrameDecryptor(
   channel_receive_->SetFrameDecryptor(std::move(frame_decryptor));
 }
 
-void AudioReceiveStreamImpl::SetRtpExtensions(
-    std::vector<RtpExtension> extensions) {
-  // TODO(bugs.webrtc.org/11993): This is called via WebRtcAudioReceiveStream,
-  // expect to be called on the network thread.
-  RTC_DCHECK_RUN_ON(&worker_thread_checker_);
-  config_.rtp.extensions = std::move(extensions);
-}
-
-RtpHeaderExtensionMap AudioReceiveStreamImpl::GetRtpExtensionMap() const {
-  return RtpHeaderExtensionMap(config_.rtp.extensions);
-}
-
 webrtc::AudioReceiveStreamInterface::Stats AudioReceiveStreamImpl::GetStats(
     bool get_and_clear_legacy_stats) const {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);

audio/audio_receive_stream.h

@@ -94,8 +94,6 @@ class AudioReceiveStreamImpl final : public webrtc::AudioReceiveStreamInterface,
   void SetNonSenderRttMeasurement(bool enabled) override;
   void SetFrameDecryptor(rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
                              frame_decryptor) override;
-  void SetRtpExtensions(std::vector<RtpExtension> extensions) override;
-  RtpHeaderExtensionMap GetRtpExtensionMap() const override;
 
   webrtc::AudioReceiveStreamInterface::Stats GetStats(
       bool get_and_clear_legacy_stats) const override;

audio/audio_receive_stream_unittest.cc

@@ -54,8 +54,6 @@ AudioDecodingCallStats MakeAudioDecodeStatsForTest() {
 
 const uint32_t kRemoteSsrc = 1234;
 const uint32_t kLocalSsrc = 5678;
-const int kAudioLevelId = 3;
-const int kTransportSequenceNumberId = 4;
 const int kJitterBufferDelay = -7;
 const int kPlayoutBufferDelay = 302;
 const unsigned int kSpeechOutputLevel = 99;
@@ -138,10 +136,6 @@ struct ConfigHelper {
     stream_config_.rtp.local_ssrc = kLocalSsrc;
     stream_config_.rtp.remote_ssrc = kRemoteSsrc;
     stream_config_.rtp.nack.rtp_history_ms = 300;
-    stream_config_.rtp.extensions.push_back(
-        RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId));
-    stream_config_.rtp.extensions.push_back(RtpExtension(
-        RtpExtension::kTransportSequenceNumberUri, kTransportSequenceNumberId));
     stream_config_.rtcp_send_transport = &rtcp_send_transport_;
     stream_config_.decoder_factory =
         rtc::make_ref_counted<MockAudioDecoderFactory>();
@@ -213,12 +207,9 @@ TEST(AudioReceiveStreamTest, ConfigToString) {
   AudioReceiveStreamInterface::Config config;
   config.rtp.remote_ssrc = kRemoteSsrc;
   config.rtp.local_ssrc = kLocalSsrc;
-  config.rtp.extensions.push_back(
-      RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId));
   EXPECT_EQ(
       "{rtp: {remote_ssrc: 1234, local_ssrc: 5678, nack: "
-      "{rtp_history_ms: 0}, extensions: [{uri: "
+      "{rtp_history_ms: 0}}, "
-      "urn:ietf:params:rtp-hdrext:ssrc-audio-level, id: 3}]}, "
       "rtcp_send_transport: null}",
       config.ToString());
 }
@@ -381,13 +372,6 @@ TEST(AudioReceiveStreamTest, ReconfigureWithUpdatedConfig) {
 
     auto new_config = helper.config();
 
-    new_config.rtp.extensions.clear();
-    new_config.rtp.extensions.push_back(
-        RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId + 1));
-    new_config.rtp.extensions.push_back(
-        RtpExtension(RtpExtension::kTransportSequenceNumberUri,
-                     kTransportSequenceNumberId + 1));
-
     MockChannelReceive& channel_receive = *helper.channel_receive();
 
     // TODO(tommi, nisse): This applies new extensions to the internal config,

call/bitrate_estimator_tests.cc

@@ -139,10 +139,6 @@ class BitrateEstimatorTest : public test::CallTest {
       // receive_config_.decoders will be set by every stream separately.
       receive_config_.rtp.remote_ssrc = GetVideoSendConfig()->rtp.ssrcs[0];
       receive_config_.rtp.local_ssrc = kReceiverLocalVideoSsrc;
-      receive_config_.rtp.extensions.push_back(
-          RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId));
-      receive_config_.rtp.extensions.push_back(
-          RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId));
     });
   }
 

call/call.cc

@@ -91,7 +91,6 @@ std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig(
   rtclog_config->local_ssrc = config.rtp.local_ssrc;
   rtclog_config->rtx_ssrc = config.rtp.rtx_ssrc;
   rtclog_config->rtcp_mode = config.rtp.rtcp_mode;
-  rtclog_config->rtp_extensions = config.rtp.extensions;
 
   for (const auto& d : config.decoders) {
     const int* search =
@@ -124,7 +123,6 @@ std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig(
   auto rtclog_config = std::make_unique<rtclog::StreamConfig>();
   rtclog_config->remote_ssrc = config.rtp.remote_ssrc;
   rtclog_config->local_ssrc = config.rtp.local_ssrc;
-  rtclog_config->rtp_extensions = config.rtp.extensions;
   return rtclog_config;
 }
 

call/flexfec_receive_stream_impl.cc

@@ -42,13 +42,7 @@ std::string FlexfecReceiveStream::Config::ToString() const {
     ss << protected_media_ssrcs[i] << ", ";
   if (!protected_media_ssrcs.empty())
     ss << protected_media_ssrcs[i];
-  ss << ", rtp.extensions: [";
+  ss << "}";
-  i = 0;
-  for (; i + 1 < rtp.extensions.size(); ++i)
-    ss << rtp.extensions[i].ToString() << ", ";
-  if (!rtp.extensions.empty())
-    ss << rtp.extensions[i].ToString();
-  ss << "]}";
   return ss.str();
 }
 
@@ -130,8 +124,7 @@ FlexfecReceiveStreamImpl::FlexfecReceiveStreamImpl(
     Config config,
     RecoveredPacketReceiver* recovered_packet_receiver,
     RtcpRttStats* rtt_stats)
-    : extension_map_(std::move(config.rtp.extensions)),
+    : remote_ssrc_(config.rtp.remote_ssrc),
-      remote_ssrc_(config.rtp.remote_ssrc),
       payload_type_(config.payload_type),
       receiver_(
           MaybeCreateFlexfecReceiver(clock, config, recovered_packet_receiver)),
@@ -198,17 +191,6 @@ int FlexfecReceiveStreamImpl::payload_type() const {
   return payload_type_;
 }
 
-void FlexfecReceiveStreamImpl::SetRtpExtensions(
-    std::vector<RtpExtension> extensions) {
-  RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
-  extension_map_.Reset(extensions);
-}
-
-RtpHeaderExtensionMap FlexfecReceiveStreamImpl::GetRtpExtensionMap() const {
-  RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
-  return extension_map_;
-}
-
 void FlexfecReceiveStreamImpl::SetLocalSsrc(uint32_t local_ssrc) {
   RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
   if (local_ssrc == rtp_rtcp_->local_media_ssrc())

call/flexfec_receive_stream_impl.h

@@ -59,10 +59,6 @@ class FlexfecReceiveStreamImpl : public FlexfecReceiveStream {
   void SetPayloadType(int payload_type) override;
   int payload_type() const override;
 
-  // ReceiveStreamInterface impl.
-  void SetRtpExtensions(std::vector<RtpExtension> extensions) override;
-  RtpHeaderExtensionMap GetRtpExtensionMap() const override;
-
   // Updates the `rtp_video_stream_receiver_`'s `local_ssrc` when the default
   // sender has been created, changed or removed.
   void SetLocalSsrc(uint32_t local_ssrc);
@@ -77,8 +73,6 @@ class FlexfecReceiveStreamImpl : public FlexfecReceiveStream {
  private:
   RTC_NO_UNIQUE_ADDRESS SequenceChecker packet_sequence_checker_;
 
-  RtpHeaderExtensionMap extension_map_;
-
   const uint32_t remote_ssrc_;
 
   // `payload_type_` is initially set to -1, indicating that FlexFec is

call/flexfec_receive_stream_unittest.cc

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

call/receive_stream.h

@@ -18,7 +18,6 @@
 #include "api/media_types.h"
 #include "api/scoped_refptr.h"
 #include "api/transport/rtp/rtp_source.h"
-#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
 
 namespace webrtc {
 
@@ -39,18 +38,8 @@ class ReceiveStreamInterface {
     // This value may change mid-stream and must be done on the same thread
     // that the value is read on (i.e. packet delivery).
     uint32_t local_ssrc = 0;
-
-    // RTP header extensions used for the received stream.
-    // This value may change mid-stream and must be done on the same thread
-    // that the value is read on (i.e. packet delivery).
-    std::vector<RtpExtension> extensions;
   };
 
-  // Set/change the rtp header extensions. Must be called on the packet
-  // delivery thread.
-  virtual void SetRtpExtensions(std::vector<RtpExtension> extensions) = 0;
-  virtual RtpHeaderExtensionMap GetRtpExtensionMap() const = 0;
-
  protected:
   virtual ~ReceiveStreamInterface() {}
 };

call/video_receive_stream.cc

@@ -146,13 +146,6 @@ std::string VideoReceiveStreamInterface::Config::Rtp::ToString() const {
     ss << pt << ", ";
   }
   ss << '}';
-  ss << ", extensions: [";
-  for (size_t i = 0; i < extensions.size(); ++i) {
-    ss << extensions[i].ToString();
-    if (i != extensions.size() - 1)
-      ss << ", ";
-  }
-  ss << ']';
   ss << '}';
   return ss.str();
 }

media/engine/fake_webrtc_call.cc

@@ -130,16 +130,6 @@ void FakeAudioReceiveStream::SetFrameDecryptor(
   config_.frame_decryptor = std::move(frame_decryptor);
 }
 
-void FakeAudioReceiveStream::SetRtpExtensions(
-    std::vector<webrtc::RtpExtension> extensions) {
-  config_.rtp.extensions = std::move(extensions);
-}
-
-webrtc::RtpHeaderExtensionMap FakeAudioReceiveStream::GetRtpExtensionMap()
-    const {
-  return webrtc::RtpHeaderExtensionMap(config_.rtp.extensions);
-}
-
 webrtc::AudioReceiveStreamInterface::Stats FakeAudioReceiveStream::GetStats(
     bool get_and_clear_legacy_stats) const {
   return stats_;
@@ -421,16 +411,6 @@ webrtc::VideoReceiveStreamInterface::Stats FakeVideoReceiveStream::GetStats()
   return stats_;
 }
 
-void FakeVideoReceiveStream::SetRtpExtensions(
-    std::vector<webrtc::RtpExtension> extensions) {
-  config_.rtp.extensions = std::move(extensions);
-}
-
-webrtc::RtpHeaderExtensionMap FakeVideoReceiveStream::GetRtpExtensionMap()
-    const {
-  return webrtc::RtpHeaderExtensionMap(config_.rtp.extensions);
-}
-
 void FakeVideoReceiveStream::Start() {
   receiving_ = true;
 }
@@ -448,16 +428,6 @@ FakeFlexfecReceiveStream::FakeFlexfecReceiveStream(
     const webrtc::FlexfecReceiveStream::Config config)
     : config_(std::move(config)) {}
 
-void FakeFlexfecReceiveStream::SetRtpExtensions(
-    std::vector<webrtc::RtpExtension> extensions) {
-  config_.rtp.extensions = std::move(extensions);
-}
-
-webrtc::RtpHeaderExtensionMap FakeFlexfecReceiveStream::GetRtpExtensionMap()
-    const {
-  return webrtc::RtpHeaderExtensionMap(config_.rtp.extensions);
-}
-
 const webrtc::FlexfecReceiveStream::Config&
 FakeFlexfecReceiveStream::GetConfig() const {
   return config_;

media/engine/fake_webrtc_call.h

@@ -126,8 +126,6 @@ class FakeAudioReceiveStream final
   void SetNonSenderRttMeasurement(bool enabled) override;
   void SetFrameDecryptor(rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
                              frame_decryptor) override;
-  void SetRtpExtensions(std::vector<webrtc::RtpExtension> extensions) override;
-  webrtc::RtpHeaderExtensionMap GetRtpExtensionMap() const override;
 
   webrtc::AudioReceiveStreamInterface::Stats GetStats(
       bool get_and_clear_legacy_stats) const override;
@@ -274,9 +272,6 @@ class FakeVideoReceiveStream final
   }
   void GenerateKeyFrame() override {}
 
-  // webrtc::VideoReceiveStreamInterface implementation.
-  void SetRtpExtensions(std::vector<webrtc::RtpExtension> extensions) override;
-  webrtc::RtpHeaderExtensionMap GetRtpExtensionMap() const override;
   void SetRtcpMode(webrtc::RtcpMode mode) override {
     config_.rtp.rtcp_mode = mode;
   }
@@ -340,8 +335,6 @@ class FakeFlexfecReceiveStream final : public webrtc::FlexfecReceiveStream {
     config_.rtp.local_ssrc = local_ssrc;
   }
 
-  void SetRtpExtensions(std::vector<webrtc::RtpExtension> extensions) override;
-  webrtc::RtpHeaderExtensionMap GetRtpExtensionMap() const override;
   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

@@ -1088,6 +1088,7 @@ webrtc::RtpParameters WebRtcVideoChannel::GetRtpReceiveParameters(
     return webrtc::RtpParameters();
   }
   rtp_params = it->second->GetRtpParameters();
+  rtp_params.header_extensions = recv_rtp_extensions_;
 
   // Add codecs, which any stream is prepared to receive.
   for (const VideoCodec& codec : recv_params_.codecs) {
@@ -1507,8 +1508,6 @@ void WebRtcVideoChannel::ConfigureReceiverRtp(
   }
   sp.GetFidSsrc(ssrc, &config->rtp.rtx_ssrc);
 
-  config->rtp.extensions = recv_rtp_extensions_;
-
   // TODO(brandtr): Generalize when we add support for multistream protection.
   flexfec_config->payload_type = recv_flexfec_payload_type_;
   if (!IsDisabled(call_->trials(), "WebRTC-FlexFEC-03-Advertised") &&
@@ -1516,7 +1515,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;
-    flexfec_config->rtp.extensions = config->rtp.extensions;
   }
 }
 
@@ -2961,7 +2959,6 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::GetRtpParameters() const {
     rtp_parameters.encodings.back().ssrc = ssrc;
   }
 
-  rtp_parameters.header_extensions = config_.rtp.extensions;
   rtp_parameters.rtcp.reduced_size =
       config_.rtp.rtcp_mode == webrtc::RtcpMode::kReducedSize;
 
@@ -3110,20 +3107,6 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetRecvParameters(
     video_needs_recreation = ReconfigureCodecs(*params.codec_settings);
   }
 
-  if (params.rtp_header_extensions) {
-    if (config_.rtp.extensions != *params.rtp_header_extensions) {
-      config_.rtp.extensions = *params.rtp_header_extensions;
-      stream_->SetRtpExtensions(config_.rtp.extensions);
-    }
-
-    if (flexfec_config_.rtp.extensions != *params.rtp_header_extensions) {
-      flexfec_config_.rtp.extensions = *params.rtp_header_extensions;
-      if (flexfec_stream_) {
-        flexfec_stream_->SetRtpExtensions(flexfec_config_.rtp.extensions);
-      }
-    }
-  }
-
   if (params.flexfec_payload_type)
     SetFlexFecPayload(*params.flexfec_payload_type);
 

media/engine/webrtc_video_engine.h

@@ -458,7 +458,8 @@ class WebRtcVideoChannel : public VideoMediaChannel,
 
     std::vector<webrtc::RtpSource> GetSources();
 
-    // Does not return codecs, they are filled by the owning WebRtcVideoChannel.
+    // Does not return codecs, nor header extensions,  they are filled by the
+    // owning WebRtcVideoChannel.
     webrtc::RtpParameters GetRtpParameters() const;
 
     // TODO(deadbeef): Move these feedback parameters into the recv parameters.

media/engine/webrtc_video_engine_unittest.cc

@@ -2684,11 +2684,6 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
     EXPECT_EQ(ext_uri, send_stream->GetConfig().rtp.extensions[0].uri);
     // Verify call with same set of extensions returns true.
     EXPECT_TRUE(channel_->SetSendParameters(parameters));
-    // Verify that SetSendRtpHeaderExtensions doesn't implicitly add them for
-    // receivers.
-    EXPECT_TRUE(AddRecvStream(cricket::StreamParams::CreateLegacy(123))
-                    ->GetConfig()
-                    .rtp.extensions.empty());
 
     // Verify that existing RTP header extensions can be removed.
     EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
@@ -2712,13 +2707,10 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
     parameters.extensions.push_back(RtpExtension(ext_uri, id));
     EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
-    FakeVideoReceiveStream* recv_stream =
+    AddRecvStream(cricket::StreamParams::CreateLegacy(123));
-        AddRecvStream(cricket::StreamParams::CreateLegacy(123));
+    EXPECT_THAT(channel_->GetRtpReceiveParameters(123).header_extensions,
+                ElementsAre(RtpExtension(ext_uri, id)));
 
-    // Verify the recv extension id.
-    ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
-    EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
-    EXPECT_EQ(ext_uri, recv_stream->GetConfig().rtp.extensions[0].uri);
     // Verify call with same set of extensions returns true.
     EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
@@ -2730,17 +2722,14 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
 
     // Verify that existing RTP header extensions can be removed.
     EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
-    ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
+    EXPECT_THAT(channel_->GetRtpReceiveParameters(123).header_extensions,
-    recv_stream = fake_call_->GetVideoReceiveStreams()[0];
+                IsEmpty());
-    EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
 
     // Verify that adding receive RTP header extensions adds them for existing
     // streams.
     EXPECT_TRUE(channel_->SetRecvParameters(parameters));
-    recv_stream = fake_call_->GetVideoReceiveStreams()[0];
+    EXPECT_EQ(channel_->GetRtpReceiveParameters(123).header_extensions,
-    ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
+              parameters.extensions);
-    EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
-    EXPECT_EQ(ext_uri, recv_stream->GetConfig().rtp.extensions[0].uri);
   }
 
   void TestLossNotificationState(bool expect_lntf_enabled) {
@@ -2968,9 +2957,9 @@ TEST_F(WebRtcVideoChannelTest, NoHeaderExtesionsByDefault) {
       AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
   ASSERT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
 
-  FakeVideoReceiveStream* recv_stream =
+  AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
-      AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
+  ASSERT_TRUE(receive_channel_->GetRtpReceiveParameters(kSsrcs1[0])
-  ASSERT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
+                  .header_extensions.empty());
 }
 
 // Test support for RTP timestamp offset header extension.
@@ -3055,38 +3044,6 @@ TEST_F(WebRtcVideoChannelTest, IdenticalSendExtensionsDoesntRecreateStream) {
   EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams());
 }
 
-TEST_F(WebRtcVideoChannelTest, IdenticalRecvExtensionsDoesntRecreateStream) {
-  const int kTOffsetId = 1;
-  const int kAbsSendTimeId = 2;
-  const int kVideoRotationId = 3;
-  recv_parameters_.extensions.push_back(
-      RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeId));
-  recv_parameters_.extensions.push_back(
-      RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId));
-  recv_parameters_.extensions.push_back(
-      RtpExtension(RtpExtension::kVideoRotationUri, kVideoRotationId));
-
-  EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
-  FakeVideoReceiveStream* recv_stream =
-      AddRecvStream(cricket::StreamParams::CreateLegacy(123));
-
-  EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
-  ASSERT_EQ(3u, recv_stream->GetConfig().rtp.extensions.size());
-
-  // Setting the same extensions (even if in different order) shouldn't
-  // reallocate the stream.
-  absl::c_reverse(recv_parameters_.extensions);
-  EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
-
-  EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
-
-  // Setting different extensions should not require the stream to be recreated.
-  recv_parameters_.extensions.resize(1);
-  EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
-
-  EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
-}
-
 TEST_F(WebRtcVideoChannelTest,
        SetSendRtpHeaderExtensionsExcludeUnsupportedExtensions) {
   const int kUnsupportedId = 1;
@@ -3117,14 +3074,16 @@ TEST_F(WebRtcVideoChannelTest,
   recv_parameters_.extensions.push_back(
       RtpExtension(RtpExtension::kTimestampOffsetUri, kTOffsetId));
   EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
-  FakeVideoReceiveStream* recv_stream =
+  AddRecvStream(cricket::StreamParams::CreateLegacy(123));
-      AddRecvStream(cricket::StreamParams::CreateLegacy(123));
 
   // Only timestamp offset extension is set to receive stream,
   // unsupported rtp extension is ignored.
-  ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
+  ASSERT_THAT(receive_channel_->GetRtpReceiveParameters(123).header_extensions,
-  EXPECT_STREQ(RtpExtension::kTimestampOffsetUri,
+              SizeIs(1));
-               recv_stream->GetConfig().rtp.extensions[0].uri.c_str());
+  EXPECT_STREQ(receive_channel_->GetRtpReceiveParameters(123)
+                   .header_extensions[0]
+                   .uri.c_str(),
+               RtpExtension::kTimestampOffsetUri);
 }
 
 TEST_F(WebRtcVideoChannelTest, SetSendRtpHeaderExtensionsRejectsIncorrectIds) {
@@ -4505,8 +4464,6 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvCodecsWithFec) {
   EXPECT_EQ(video_stream_config.rtcp_send_transport,
             flexfec_stream_config.rtcp_send_transport);
   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);
 }
 
 // We should not send FlexFEC, even if we advertise it, unless the right

media/engine/webrtc_voice_engine.cc

@@ -271,7 +271,6 @@ webrtc::AudioReceiveStreamInterface::Config BuildReceiveStreamConfig(
   if (!stream_ids.empty()) {
     config.sync_group = stream_ids[0];
   }
-  config.rtp.extensions = extensions;
   config.rtcp_send_transport = rtcp_send_transport;
   config.enable_non_sender_rtt = enable_non_sender_rtt;
   config.decoder_factory = decoder_factory;
@@ -1179,11 +1178,6 @@ class WebRtcVoiceMediaChannel::WebRtcAudioReceiveStream {
     stream_->SetNonSenderRttMeasurement(enabled);
   }
 
-  void SetRtpExtensions(const std::vector<webrtc::RtpExtension>& extensions) {
-    RTC_DCHECK_RUN_ON(&worker_thread_checker_);
-    stream_->SetRtpExtensions(extensions);
-  }
-
   // Set a new payload type -> decoder map.
   void SetDecoderMap(const std::map<int, webrtc::SdpAudioFormat>& decoder_map) {
     RTC_DCHECK_RUN_ON(&worker_thread_checker_);
@@ -1355,9 +1349,6 @@ bool WebRtcVoiceMediaChannel::SetRecvParameters(
     recv_rtp_extensions_.swap(filtered_extensions);
     recv_rtp_extension_map_ =
         webrtc::RtpHeaderExtensionMap(recv_rtp_extensions_);
-    for (auto& it : recv_streams_) {
-      it.second->SetRtpExtensions(recv_rtp_extensions_);
-    }
   }
   return true;
 }

media/engine/webrtc_voice_engine_unittest.cc

@@ -45,10 +45,12 @@ using ::testing::_;
 using ::testing::ContainerEq;
 using ::testing::Contains;
 using ::testing::Field;
+using ::testing::IsEmpty;
 using ::testing::Return;
 using ::testing::ReturnPointee;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
+using ::testing::UnorderedElementsAreArray;
 
 namespace {
 using webrtc::BitrateConstraints;
@@ -558,40 +560,41 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam<bool> {
     EXPECT_TRUE(SetupRecvStream());
 
     // Ensure extensions are off by default.
-    EXPECT_EQ(0u, GetRecvStreamConfig(kSsrcX).rtp.extensions.size());
+    EXPECT_THAT(channel_->GetRtpReceiveParameters(kSsrcX).header_extensions,
+                IsEmpty());
 
     // Ensure unknown extensions won't cause an error.
     recv_parameters_.extensions.push_back(
         webrtc::RtpExtension("urn:ietf:params:unknownextention", 1));
     EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
-    EXPECT_EQ(0u, GetRecvStreamConfig(kSsrcX).rtp.extensions.size());
+    EXPECT_THAT(channel_->GetRtpReceiveParameters(kSsrcX).header_extensions,
+                IsEmpty());
 
     // Ensure extensions stay off with an empty list of headers.
     recv_parameters_.extensions.clear();
     EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
-    EXPECT_EQ(0u, GetRecvStreamConfig(kSsrcX).rtp.extensions.size());
+    EXPECT_THAT(channel_->GetRtpReceiveParameters(kSsrcX).header_extensions,
+                IsEmpty());
 
     // Ensure extension is set properly.
     const int id = 2;
     recv_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id));
     EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
-    EXPECT_EQ(1u, GetRecvStreamConfig(kSsrcX).rtp.extensions.size());
+    EXPECT_EQ(channel_->GetRtpReceiveParameters(kSsrcX).header_extensions,
-    EXPECT_EQ(ext, GetRecvStreamConfig(kSsrcX).rtp.extensions[0].uri);
+              recv_parameters_.extensions);
-    EXPECT_EQ(id, GetRecvStreamConfig(kSsrcX).rtp.extensions[0].id);
 
     // Ensure extension is set properly on new stream.
     EXPECT_TRUE(AddRecvStream(kSsrcY));
-    EXPECT_NE(call_.GetAudioReceiveStream(kSsrcX),
+    EXPECT_EQ(channel_->GetRtpReceiveParameters(kSsrcY).header_extensions,
-              call_.GetAudioReceiveStream(kSsrcY));
+              recv_parameters_.extensions);
-    EXPECT_EQ(1u, GetRecvStreamConfig(kSsrcY).rtp.extensions.size());
-    EXPECT_EQ(ext, GetRecvStreamConfig(kSsrcY).rtp.extensions[0].uri);
-    EXPECT_EQ(id, GetRecvStreamConfig(kSsrcY).rtp.extensions[0].id);
 
     // Ensure all extensions go back off with an empty list.
     recv_parameters_.extensions.clear();
     EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
-    EXPECT_EQ(0u, GetRecvStreamConfig(kSsrcX).rtp.extensions.size());
+    EXPECT_THAT(channel_->GetRtpReceiveParameters(kSsrcX).header_extensions,
-    EXPECT_EQ(0u, GetRecvStreamConfig(kSsrcY).rtp.extensions.size());
+                IsEmpty());
+    EXPECT_THAT(channel_->GetRtpReceiveParameters(kSsrcY).header_extensions,
+                IsEmpty());
   }
 
   webrtc::AudioSendStream::Stats GetAudioSendStreamStats() const {
@@ -847,7 +850,6 @@ TEST_P(WebRtcVoiceEngineTestFake, CreateRecvStream) {
       GetRecvStreamConfig(kSsrcX);
   EXPECT_EQ(kSsrcX, config.rtp.remote_ssrc);
   EXPECT_EQ(0xFA17FA17, config.rtp.local_ssrc);
-  EXPECT_EQ(0u, config.rtp.extensions.size());
   EXPECT_EQ(static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_),
             config.rtcp_send_transport);
   EXPECT_EQ("", config.sync_group);
@@ -3392,9 +3394,9 @@ TEST_P(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) {
 
   EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size());
   for (uint32_t ssrc : ssrcs) {
-    const auto* s = call_.GetAudioReceiveStream(ssrc);
+    EXPECT_THAT(
-    EXPECT_NE(nullptr, s);
+        receive_channel_->GetRtpReceiveParameters(ssrc).header_extensions,
-    EXPECT_EQ(0u, s->GetConfig().rtp.extensions.size());
+        IsEmpty());
   }
 
   // Set up receive extensions.
@@ -3405,25 +3407,17 @@ TEST_P(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) {
   channel_->SetRecvParameters(recv_parameters);
   EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size());
   for (uint32_t ssrc : ssrcs) {
-    const auto* s = call_.GetAudioReceiveStream(ssrc);
+    EXPECT_THAT(
-    EXPECT_NE(nullptr, s);
+        receive_channel_->GetRtpReceiveParameters(ssrc).header_extensions,
-    const auto& s_exts = s->GetConfig().rtp.extensions;
+        testing::UnorderedElementsAreArray(header_extensions));
-    EXPECT_EQ(header_extensions.size(), s_exts.size());
-    for (const auto& e_ext : header_extensions) {
-      for (const auto& s_ext : s_exts) {
-        if (e_ext.id == s_ext.id) {
-          EXPECT_EQ(e_ext.uri, s_ext.uri);
-        }
-      }
-    }
   }
 
   // Disable receive extensions.
   channel_->SetRecvParameters(cricket::AudioRecvParameters());
   for (uint32_t ssrc : ssrcs) {
-    const auto* s = call_.GetAudioReceiveStream(ssrc);
+    EXPECT_THAT(
-    EXPECT_NE(nullptr, s);
+        receive_channel_->GetRtpReceiveParameters(ssrc).header_extensions,
-    EXPECT_EQ(0u, s->GetConfig().rtp.extensions.size());
+        IsEmpty());
   }
 }
 

modules/rtp_rtcp/source/ulpfec_receiver.h

@@ -54,8 +54,6 @@ class UlpfecReceiver {
 
   FecPacketCounter GetPacketCounter() const;
 
-  void SetRtpExtensions(rtc::ArrayView<const RtpExtension> extensions);
-
  private:
   const uint32_t ssrc_;
   const int ulpfec_payload_type_;

test/call_config_utils.cc

@@ -59,11 +59,6 @@ VideoReceiveStreamInterface::Config ParseVideoReceiveStreamJsonConfig(
     receive_config.rtp.rtx_associated_payload_types[std::stoi(members[0])] =
         rtx_payload_type.asInt64();
   }
-  for (const auto& ext_json : json["rtp"]["extensions"]) {
-    receive_config.rtp.extensions.emplace_back(ext_json["uri"].asString(),
-                                               ext_json["id"].asInt64(),
-                                               ext_json["encrypt"].asBool());
-  }
   return receive_config;
 }
 
@@ -104,14 +99,6 @@ Json::Value GenerateVideoReceiveStreamJsonConfig(
     rtp_json["rtx_payload_types"].append(val);
   }
 
-  rtp_json["extensions"] = Json::Value(Json::arrayValue);
-  for (auto& ext : config.rtp.extensions) {
-    Json::Value ext_json;
-    ext_json["uri"] = ext.uri;
-    ext_json["id"] = ext.id;
-    ext_json["encrypt"] = ext.encrypt;
-    rtp_json["extensions"].append(ext_json);
-  }
   root_json["rtp"] = rtp_json;
 
   root_json["render_delay_ms"] = config.render_delay_ms;

test/call_config_utils_unittest.cc

@@ -33,7 +33,6 @@ TEST(CallConfigUtils, MarshalUnmarshalProcessSameObject) {
   recv_config.rtp.red_payload_type = 50;
   recv_config.rtp.rtx_ssrc = 1000;
   recv_config.rtp.rtx_associated_payload_types[10] = 10;
-  recv_config.rtp.extensions.emplace_back("uri", 128, true);
 
   VideoReceiveStreamInterface::Config unmarshaled_config =
       ParseVideoReceiveStreamJsonConfig(
@@ -57,7 +56,6 @@ TEST(CallConfigUtils, MarshalUnmarshalProcessSameObject) {
   EXPECT_EQ(recv_config.rtp.rtx_ssrc, unmarshaled_config.rtp.rtx_ssrc);
   EXPECT_EQ(recv_config.rtp.rtx_associated_payload_types,
             unmarshaled_config.rtp.rtx_associated_payload_types);
-  EXPECT_EQ(recv_config.rtp.extensions, recv_config.rtp.extensions);
 }
 
 }  // namespace test

test/call_test.cc

@@ -374,8 +374,6 @@ void CallTest::AddMatchingVideoReceiveConfigs(
   RTC_DCHECK(!video_send_config.rtp.ssrcs.empty());
   VideoReceiveStreamInterface::Config default_config(rtcp_send_transport);
   default_config.rtp.local_ssrc = kReceiverLocalVideoSsrc;
-  for (const RtpExtension& extension : video_send_config.rtp.extensions)
-    default_config.rtp.extensions.push_back(extension);
   default_config.rtp.nack.rtp_history_ms = rtp_history_ms;
   // Enable RTT calculation so NTP time estimator will work.
   default_config.rtp.rtcp_xr.receiver_reference_time_report =
@@ -418,8 +416,6 @@ void CallTest::CreateMatchingAudioAndFecConfigs(
   RTC_DCHECK(num_flexfec_streams_ <= 1);
   if (num_flexfec_streams_ == 1) {
     CreateMatchingFecConfig(rtcp_send_transport, *GetVideoSendConfig());
-    for (const RtpExtension& extension : GetVideoSendConfig()->rtp.extensions)
-      GetFlexFecConfig()->rtp.extensions.push_back(extension);
   }
 }
 
@@ -438,7 +434,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.extensions = send_config.rtp.extensions;
   audio_config.decoder_factory = audio_decoder_factory;
   audio_config.decoder_map = {{kAudioSendPayloadType, {"opus", 48000, 2}}};
   audio_config.sync_group = sync_group;

test/scenario/audio_stream.cc

@@ -188,7 +188,6 @@ ReceiveAudioStream::ReceiveAudioStream(
   recv_config.rtcp_send_transport = feedback_transport;
   recv_config.rtp.remote_ssrc = send_stream->ssrc_;
   receiver->ssrc_media_types_[recv_config.rtp.remote_ssrc] = MediaType::AUDIO;
-  recv_config.rtp.extensions = GetAudioRtpExtensions(config);
   recv_config.decoder_factory = decoder_factory;
   recv_config.decoder_map = {
       {CallTest::kAudioSendPayloadType, {"opus", 48000, 2}}};

test/scenario/video_stream.cc

@@ -312,7 +312,6 @@ VideoReceiveStreamInterface::Config CreateVideoReceiveStreamConfig(
     uint32_t rtx_ssrc) {
   VideoReceiveStreamInterface::Config recv(feedback_transport);
   recv.rtp.local_ssrc = local_ssrc;
-  recv.rtp.extensions = GetVideoRtpExtensions(config);
 
   RTC_DCHECK(!config.stream.use_rtx ||
              config.stream.nack_history_time > TimeDelta::Zero());

video/end_to_end_tests/config_tests.cc

@@ -85,8 +85,6 @@ TEST_F(ConfigEndToEndTest, VerifyDefaultVideoReceiveConfigParameters) {
       << "Enabling RTX requires ssrc-group: FID negotiation";
   EXPECT_TRUE(default_receive_config.rtp.rtx_associated_payload_types.empty())
       << "Enabling RTX requires rtpmap: rtx negotiation.";
-  EXPECT_TRUE(default_receive_config.rtp.extensions.empty())
-      << "Enabling RTP extensions require negotiation.";
   VerifyEmptyNackConfig(default_receive_config.rtp.nack);
   EXPECT_EQ(-1, default_receive_config.rtp.ulpfec_payload_type)
       << "Enabling ULPFEC requires rtpmap: ulpfec negotiation.";

video/end_to_end_tests/rtp_rtcp_tests.cc

@@ -501,9 +501,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.extensions.emplace_back(
-        RtpExtension::kTransportSequenceNumberUri,
-        kTransportSequenceNumberExtensionId);
     flexfec_receive_configs_.push_back(flexfec_receive_config);
 
     CreateFlexfecStreams();

video/end_to_end_tests/stats_tests.cc

@@ -357,11 +357,6 @@ TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
       send_config->rtp.extensions.clear();
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kVideoTimingUri, kExtensionId));
-      for (auto& receive_config : *receive_configs) {
-        receive_config.rtp.extensions.clear();
-        receive_config.rtp.extensions.push_back(
-            RtpExtension(RtpExtension::kVideoTimingUri, kExtensionId));
-      }
     }
 
     void OnVideoStreamsCreated(VideoSendStream* send_stream,

video/end_to_end_tests/transport_feedback_tests.cc

@@ -210,10 +210,6 @@ TEST(TransportFeedbackMultiStreamTest, AssignsTransportSequenceNumbers) {
         size_t stream_index,
         VideoReceiveStreamInterface::Config* receive_config) override {
       receive_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
-      receive_config->rtp.extensions.clear();
-      receive_config->rtp.extensions.push_back(
-          RtpExtension(RtpExtension::kTransportSequenceNumberUri,
-                       kTransportSequenceNumberExtensionId));
       receive_config->renderer = &fake_renderer_;
     }
 
@@ -300,8 +296,6 @@ class TransportFeedbackTester : public test::EndToEndTest {
     send_config->rtp.extensions.push_back(
         RtpExtension(RtpExtension::kTransportSequenceNumberUri,
                      kTransportSequenceNumberExtensionId));
-    (*receive_configs)[0].rtp.extensions.clear();
-    (*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
   }
 
  private:
@@ -438,8 +432,6 @@ TEST_F(TransportFeedbackEndToEndTest, TransportSeqNumOnAudioAndVideo) {
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kTransportSequenceNumberUri,
                        kTransportSequenceNumberExtensionId));
-      (*receive_configs)[0].rtp.extensions.clear();
-      (*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
     }
 
     Action OnSendRtp(const uint8_t* packet, size_t length) override {

video/rtp_video_stream_receiver2.cc

@@ -253,7 +253,6 @@ RtpVideoStreamReceiver2::RtpVideoStreamReceiver2(
       config_(*config),
       packet_router_(packet_router),
       ntp_estimator_(clock),
-      rtp_header_extensions_(config_.rtp.extensions),
       forced_playout_delay_max_ms_("max_ms", absl::nullopt),
       forced_playout_delay_min_ms_("min_ms", absl::nullopt),
       rtp_receive_statistics_(rtp_receive_statistics),
@@ -955,17 +954,6 @@ void RtpVideoStreamReceiver2::SetDepacketizerToDecoderFrameTransformer(
   frame_transformer_delegate_->Init();
 }
 
-void RtpVideoStreamReceiver2::SetRtpExtensions(
-    const std::vector<RtpExtension>& extensions) {
-  RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
-  rtp_header_extensions_.Reset(extensions);
-}
-
-const RtpHeaderExtensionMap& RtpVideoStreamReceiver2::GetRtpExtensions() const {
-  RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
-  return rtp_header_extensions_;
-}
-
 void RtpVideoStreamReceiver2::UpdateRtt(int64_t max_rtt_ms) {
   RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
   if (nack_module_)

video/rtp_video_stream_receiver2.h

@@ -175,11 +175,6 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
   void SetDepacketizerToDecoderFrameTransformer(
       rtc::scoped_refptr<FrameTransformerInterface> frame_transformer);
 
-  // Updates the rtp header extensions at runtime. Must be called on the
-  // `packet_sequence_checker_` thread.
-  void SetRtpExtensions(const std::vector<RtpExtension>& extensions);
-  const RtpHeaderExtensionMap& GetRtpExtensions() const;
-
   // Called by VideoReceiveStreamInterface when stats are updated.
   void UpdateRtt(int64_t max_rtt_ms);
 
@@ -323,8 +318,6 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
 
   RemoteNtpTimeEstimator ntp_estimator_;
 
-  RtpHeaderExtensionMap rtp_header_extensions_
-      RTC_GUARDED_BY(packet_sequence_checker_);
   // Set by the field trial WebRTC-ForcePlayoutDelay to override any playout
   // delay that is specified in the received packets.
   FieldTrialOptional<int> forced_playout_delay_max_ms_;

video/video_quality_test.cc

@@ -934,14 +934,6 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
     }
 
     CreateMatchingFecConfig(recv_transport, *GetVideoSendConfig());
-    if (params_.call.send_side_bwe) {
-      GetFlexFecConfig()->rtp.extensions.push_back(
-          RtpExtension(RtpExtension::kTransportSequenceNumberUri,
-                       kTransportSequenceNumberExtensionId));
-    } else {
-      GetFlexFecConfig()->rtp.extensions.push_back(
-          RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
-    }
   }
 
   if (params_.video[0].ulpfec) {

video/video_receive_stream2.cc

@@ -440,29 +440,6 @@ void VideoReceiveStream2::Stop() {
   transport_adapter_.Disable();
 }
 
-void VideoReceiveStream2::SetRtpExtensions(
-    std::vector<RtpExtension> extensions) {
-  RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
-  rtp_video_stream_receiver_.SetRtpExtensions(extensions);
-  // TODO(tommi): We don't use the `c.rtp.extensions` member in the
-  // VideoReceiveStream2 class, so this const_cast<> is a temporary hack to keep
-  // things consistent between VideoReceiveStream2 and RtpVideoStreamReceiver2
-  // for debugging purposes. The `packet_sequence_checker_` gives us assurances
-  // that from a threading perspective, this is still safe. The accessors that
-  // give read access to this state, run behind the same check.
-  // The alternative to the const_cast<> would be to make `config_` non-const
-  // and guarded by `packet_sequence_checker_`. However the scope of that state
-  // is huge (the whole Config struct), and would require all methods that touch
-  // the struct to abide the needs of the `extensions` member.
-  const_cast<std::vector<RtpExtension>&>(config_.rtp.extensions) =
-      std::move(extensions);
-}
-
-RtpHeaderExtensionMap VideoReceiveStream2::GetRtpExtensionMap() const {
-  RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
-  return rtp_video_stream_receiver_.GetRtpExtensions();
-}
-
 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

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

video/video_send_stream_tests.cc

@@ -633,7 +633,6 @@ class UlpfecObserver : public test::EndToEndTest {
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
     }
-    (*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
     encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
     (*receive_configs)[0].rtp.red_payload_type =
         send_config->rtp.ulpfec.red_payload_type;
@@ -832,7 +831,6 @@ class FlexfecObserver : public test::EndToEndTest {
     } else {
       send_config->rtp.extensions.clear();
     }
-    (*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
     encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
   }
 
@@ -1590,7 +1588,6 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
       send_config->rtp.extensions.clear();
       send_config->rtp.extensions.push_back(RtpExtension(
           RtpExtension::kTransportSequenceNumberUri, kExtensionId));
-      (*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
     }
 
     void ModifyAudioConfigs(AudioSendStream::Config* send_config,
@@ -1600,8 +1597,6 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
       send_config->rtp.extensions.clear();
       send_config->rtp.extensions.push_back(RtpExtension(
           RtpExtension::kTransportSequenceNumberUri, kExtensionId));
-      (*receive_configs)[0].rtp.extensions.clear();
-      (*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
     }
 
     Action OnSendRtp(const uint8_t* packet, size_t length) override {