mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-12 21:30:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source 
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}
This commit is contained in:
Per K 2023-01-30 16:04:01 +01:00 committed by WebRTC LUCI CQ
parent 3541732527
commit 217b384c1b
33 changed files with 48 additions and 345 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
audio/audio_receive_stream.cc
View file

@ -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_);

2
audio/audio_receive_stream.h
View file

@ -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;

18
audio/audio_receive_stream_unittest.cc
View file

@ -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: "
"urn:ietf:params:rtp-hdrext:ssrc-audio-level, id: 3}]}, "
"{rtp_history_ms: 0}}, "
"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,

4
call/bitrate_estimator_tests.cc
View file

@ -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));
});
}

2
call/call.cc
View file

@ -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;
}

22
call/flexfec_receive_stream_impl.cc
View file

@ -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: [";
i = 0;
for (; i + 1 < rtp.extensions.size(); ++i)
ss << rtp.extensions[i].ToString() << ", ";
if (!rtp.extensions.empty())
ss << rtp.extensions[i].ToString();
ss << "]}";
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())

6
call/flexfec_receive_stream_impl.h
View file

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

1
call/flexfec_receive_stream_unittest.cc
View file

@ -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;

11
call/receive_stream.h
View file

@ -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() {}
};

7
call/video_receive_stream.cc
View file

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

30
media/engine/fake_webrtc_call.cc
View file

@ -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_;

7
media/engine/fake_webrtc_call.h
View file

@ -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; }

19
media/engine/webrtc_video_engine.cc
View file

@ -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);

3
media/engine/webrtc_video_engine.h
View file

@ -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.

77
media/engine/webrtc_video_engine_unittest.cc
View file

@ -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());
recv_stream = fake_call_->GetVideoReceiveStreams()[0];
EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
EXPECT_THAT(channel_->GetRtpReceiveParameters(123).header_extensions,
IsEmpty());
// Verify that adding receive RTP header extensions adds them for existing
// streams.
EXPECT_TRUE(channel_->SetRecvParameters(parameters));
recv_stream = fake_call_->GetVideoReceiveStreams()[0];
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);
EXPECT_EQ(channel_->GetRtpReceiveParameters(123).header_extensions,
parameters.extensions);
}
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]));
ASSERT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrcs1[0]));
ASSERT_TRUE(receive_channel_->GetRtpReceiveParameters(kSsrcs1[0])
.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());
EXPECT_STREQ(RtpExtension::kTimestampOffsetUri,
recv_stream->GetConfig().rtp.extensions[0].uri.c_str());
ASSERT_THAT(receive_channel_->GetRtpReceiveParameters(123).header_extensions,
SizeIs(1));
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

9
media/engine/webrtc_voice_engine.cc
View file

@ -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;
}

56
media/engine/webrtc_voice_engine_unittest.cc
View file

@ -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(ext, GetRecvStreamConfig(kSsrcX).rtp.extensions[0].uri);
EXPECT_EQ(id, GetRecvStreamConfig(kSsrcX).rtp.extensions[0].id);
EXPECT_EQ(channel_->GetRtpReceiveParameters(kSsrcX).header_extensions,
recv_parameters_.extensions);
// Ensure extension is set properly on new stream.
EXPECT_TRUE(AddRecvStream(kSsrcY));
EXPECT_NE(call_.GetAudioReceiveStream(kSsrcX),
call_.GetAudioReceiveStream(kSsrcY));
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);
EXPECT_EQ(channel_->GetRtpReceiveParameters(kSsrcY).header_extensions,
recv_parameters_.extensions);
// 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_EQ(0u, GetRecvStreamConfig(kSsrcY).rtp.extensions.size());
EXPECT_THAT(channel_->GetRtpReceiveParameters(kSsrcX).header_extensions,
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_NE(nullptr, s);
EXPECT_EQ(0u, s->GetConfig().rtp.extensions.size());
EXPECT_THAT(
receive_channel_->GetRtpReceiveParameters(ssrc).header_extensions,
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_NE(nullptr, s);
const auto& s_exts = s->GetConfig().rtp.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);
}
}
}
EXPECT_THAT(
receive_channel_->GetRtpReceiveParameters(ssrc).header_extensions,
testing::UnorderedElementsAreArray(header_extensions));
}
// Disable receive extensions.
channel_->SetRecvParameters(cricket::AudioRecvParameters());
for (uint32_t ssrc : ssrcs) {
const auto* s = call_.GetAudioReceiveStream(ssrc);
EXPECT_NE(nullptr, s);
EXPECT_EQ(0u, s->GetConfig().rtp.extensions.size());
EXPECT_THAT(
receive_channel_->GetRtpReceiveParameters(ssrc).header_extensions,
IsEmpty());
}
}

2
modules/rtp_rtcp/source/ulpfec_receiver.h
View file

@ -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_;

13
test/call_config_utils.cc
View file

@ -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;

2
test/call_config_utils_unittest.cc
View file

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

5
test/call_test.cc
View file

@ -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;

1
test/scenario/audio_stream.cc
View file

@ -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}}};

1
test/scenario/video_stream.cc
View file

@ -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());

2
video/end_to_end_tests/config_tests.cc
View file

@ -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.";

3
video/end_to_end_tests/rtp_rtcp_tests.cc
View file

@ -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();

5
video/end_to_end_tests/stats_tests.cc
View file

@ -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,

8
video/end_to_end_tests/transport_feedback_tests.cc
View file

@ -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 {

12
video/rtp_video_stream_receiver2.cc
View file

@ -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_)

7
video/rtp_video_stream_receiver2.h
View file

@ -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_;

8
video/video_quality_test.cc
View file

@ -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) {

23
video/video_receive_stream2.cc
View file

@ -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.

2
video/video_receive_stream2.h
View file

@ -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;

5
video/video_send_stream_tests.cc
View file

@ -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 {