zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Delete unused functions in RtpSender, RtcpSender and RtcpReceiver

Browse Source 
These functions are not longer used by the RtpRtcp implementations.

Bug: None
Change-Id: Ibc36433b253b264de4cdcdf380f5ec1df201b17a
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/207862
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#33282}
This commit is contained in:
Danil Chapovalov
2021-02-16 11:59:29 +01:00
committed by Commit Bot
parent f4e3e2b83f
commit 3562318bde
9 changed files with 91 additions and 261 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
modules/rtp_rtcp/source/rtcp_receiver.cc
View File

@ -714,7 +714,6 @@ void RTCPReceiver::HandleSdes(const CommonHeader& rtcp_block,
} }
for (const rtcp::Sdes::Chunk& chunk : sdes.chunks()) { for (const rtcp::Sdes::Chunk& chunk : sdes.chunks()) {
received_cnames_[chunk.ssrc] = chunk.cname;
if (cname_callback_) if (cname_callback_)
cname_callback_->OnCname(chunk.ssrc, chunk.cname); cname_callback_->OnCname(chunk.ssrc, chunk.cname);
} }
@ -778,7 +777,6 @@ void RTCPReceiver::HandleBye(const CommonHeader& rtcp_block) {
tmmbr_info->ready_for_delete = true; tmmbr_info->ready_for_delete = true;
last_fir_.erase(bye.sender_ssrc()); last_fir_.erase(bye.sender_ssrc());
received_cnames_.erase(bye.sender_ssrc());
auto it = received_rrtrs_ssrc_it_.find(bye.sender_ssrc()); auto it = received_rrtrs_ssrc_it_.find(bye.sender_ssrc());
if (it != received_rrtrs_ssrc_it_.end()) { if (it != received_rrtrs_ssrc_it_.end()) {
received_rrtrs_.erase(it->second); received_rrtrs_.erase(it->second);
@ -1169,20 +1167,6 @@ void RTCPReceiver::TriggerCallbacksFromRtcpPacket(
} }
} }
int32_t RTCPReceiver::CNAME(uint32_t remoteSSRC,
char cName[RTCP_CNAME_SIZE]) const {
RTC_DCHECK(cName);
MutexLock lock(&rtcp_receiver_lock_);
auto received_cname_it = received_cnames_.find(remoteSSRC);
if (received_cname_it == received_cnames_.end())
return -1;
size_t length = received_cname_it->second.copy(cName, RTCP_CNAME_SIZE - 1);
cName[length] = 0;
return 0;
}
std::vector<rtcp::TmmbItem> RTCPReceiver::TmmbrReceived() { std::vector<rtcp::TmmbItem> RTCPReceiver::TmmbrReceived() {
MutexLock lock(&rtcp_receiver_lock_); MutexLock lock(&rtcp_receiver_lock_);
std::vector<rtcp::TmmbItem> candidates; std::vector<rtcp::TmmbItem> candidates;

5
modules/rtp_rtcp/source/rtcp_receiver.h
View File

@ -67,9 +67,6 @@ class RTCPReceiver final {
void SetRemoteSSRC(uint32_t ssrc); void SetRemoteSSRC(uint32_t ssrc);
uint32_t RemoteSSRC() const; uint32_t RemoteSSRC() const;
// Get received cname.
int32_t CNAME(uint32_t remote_ssrc, char cname[RTCP_CNAME_SIZE]) const;
// Get received NTP. // Get received NTP.
bool NTP(uint32_t* received_ntp_secs, bool NTP(uint32_t* received_ntp_secs,
uint32_t* received_ntp_frac, uint32_t* received_ntp_frac,
@ -262,8 +259,6 @@ class RTCPReceiver final {
ReportBlockMap received_report_blocks_ RTC_GUARDED_BY(rtcp_receiver_lock_); ReportBlockMap received_report_blocks_ RTC_GUARDED_BY(rtcp_receiver_lock_);
std::map<uint32_t, LastFirStatus> last_fir_ std::map<uint32_t, LastFirStatus> last_fir_
RTC_GUARDED_BY(rtcp_receiver_lock_); RTC_GUARDED_BY(rtcp_receiver_lock_);
std::map<uint32_t, std::string> received_cnames_
RTC_GUARDED_BY(rtcp_receiver_lock_);
// The last time we received an RTCP Report block for this module. // The last time we received an RTCP Report block for this module.
Timestamp last_received_rb_ RTC_GUARDED_BY(rtcp_receiver_lock_) = Timestamp last_received_rb_ RTC_GUARDED_BY(rtcp_receiver_lock_) =

27
modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
View File

@ -648,33 +648,6 @@ TEST(RtcpReceiverTest, InjectSdesWithOneChunk) {
EXPECT_CALL(callback, OnCname(kSenderSsrc, StrEq(kCname))); EXPECT_CALL(callback, OnCname(kSenderSsrc, StrEq(kCname)));
receiver.IncomingPacket(sdes.Build()); receiver.IncomingPacket(sdes.Build());
char cName[RTCP_CNAME_SIZE];
EXPECT_EQ(0, receiver.CNAME(kSenderSsrc, cName));
EXPECT_EQ(0, strncmp(cName, kCname, RTCP_CNAME_SIZE));
}
TEST(RtcpReceiverTest, InjectByePacket_RemovesCname) {
ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc);
const char kCname[] = "alice@host";
rtcp::Sdes sdes;
sdes.AddCName(kSenderSsrc, kCname);
receiver.IncomingPacket(sdes.Build());
char cName[RTCP_CNAME_SIZE];
EXPECT_EQ(0, receiver.CNAME(kSenderSsrc, cName));
// Verify that BYE removes the CNAME.
rtcp::Bye bye;
bye.SetSenderSsrc(kSenderSsrc);
receiver.IncomingPacket(bye.Build());
EXPECT_EQ(-1, receiver.CNAME(kSenderSsrc, cName));
} }
TEST(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) { TEST(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) {

38
modules/rtp_rtcp/source/rtcp_sender.cc
View File

@ -273,15 +273,6 @@ bool RTCPSender::TMMBR() const {
return IsFlagPresent(RTCPPacketType::kRtcpTmmbr); return IsFlagPresent(RTCPPacketType::kRtcpTmmbr);
} }
void RTCPSender::SetTMMBRStatus(bool enable) {
MutexLock lock(&mutex_rtcp_sender_);
if (enable) {
SetFlag(RTCPPacketType::kRtcpTmmbr, false);
} else {
ConsumeFlag(RTCPPacketType::kRtcpTmmbr, true);
}
}
void RTCPSender::SetMaxRtpPacketSize(size_t max_packet_size) { void RTCPSender::SetMaxRtpPacketSize(size_t max_packet_size) {
MutexLock lock(&mutex_rtcp_sender_); MutexLock lock(&mutex_rtcp_sender_);
max_packet_size_ = max_packet_size; max_packet_size_ = max_packet_size;
@ -330,31 +321,6 @@ int32_t RTCPSender::SetCNAME(const char* c_name) {
return 0; return 0;
} }
int32_t RTCPSender::AddMixedCNAME(uint32_t SSRC, const char* c_name) {
RTC_DCHECK(c_name);
RTC_DCHECK_LT(strlen(c_name), RTCP_CNAME_SIZE);
MutexLock lock(&mutex_rtcp_sender_);
// One spot is reserved for ssrc_/cname_.
// TODO(danilchap): Add support for more than 30 contributes by sending
// several sdes packets.
if (csrc_cnames_.size() >= rtcp::Sdes::kMaxNumberOfChunks - 1)
return -1;
csrc_cnames_[SSRC] = c_name;
return 0;
}
int32_t RTCPSender::RemoveMixedCNAME(uint32_t SSRC) {
MutexLock lock(&mutex_rtcp_sender_);
auto it = csrc_cnames_.find(SSRC);
if (it == csrc_cnames_.end())
return -1;
csrc_cnames_.erase(it);
return 0;
}
bool RTCPSender::TimeToSendRTCPReport(bool sendKeyframeBeforeRTP) const { bool RTCPSender::TimeToSendRTCPReport(bool sendKeyframeBeforeRTP) const {
/* /*
For audio we use a configurable interval (default: 5 seconds) For audio we use a configurable interval (default: 5 seconds)
@ -465,10 +431,6 @@ void RTCPSender::BuildSDES(const RtcpContext& ctx, PacketSender& sender) {
rtcp::Sdes sdes; rtcp::Sdes sdes;
sdes.AddCName(ssrc_, cname_); sdes.AddCName(ssrc_, cname_);
for (const auto& it : csrc_cnames_)
RTC_CHECK(sdes.AddCName(it.first, it.second));
sender.AppendPacket(sdes); sender.AppendPacket(sdes);
} }

10
modules/rtp_rtcp/source/rtcp_sender.h
View File

@ -100,12 +100,6 @@ class RTCPSender final {
int32_t SetCNAME(const char* cName) RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_); int32_t SetCNAME(const char* cName) RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
int32_t AddMixedCNAME(uint32_t SSRC, const char* c_name)
RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
int32_t RemoveMixedCNAME(uint32_t SSRC)
RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
bool TimeToSendRTCPReport(bool sendKeyframeBeforeRTP = false) const bool TimeToSendRTCPReport(bool sendKeyframeBeforeRTP = false) const
RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_); RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
@ -129,8 +123,6 @@ class RTCPSender final {
bool TMMBR() const RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_); bool TMMBR() const RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
void SetTMMBRStatus(bool enable) RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
void SetMaxRtpPacketSize(size_t max_packet_size) void SetMaxRtpPacketSize(size_t max_packet_size)
RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_); RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
@ -219,8 +211,6 @@ class RTCPSender final {
ReceiveStatisticsProvider* receive_statistics_ ReceiveStatisticsProvider* receive_statistics_
RTC_GUARDED_BY(mutex_rtcp_sender_); RTC_GUARDED_BY(mutex_rtcp_sender_);
std::map<uint32_t, std::string> csrc_cnames_
RTC_GUARDED_BY(mutex_rtcp_sender_);
// send CSRCs // send CSRCs
std::vector<uint32_t> csrcs_ RTC_GUARDED_BY(mutex_rtcp_sender_); std::vector<uint32_t> csrcs_ RTC_GUARDED_BY(mutex_rtcp_sender_);

33
modules/rtp_rtcp/source/rtcp_sender_unittest.cc
View File

@ -294,20 +294,6 @@ TEST_F(RtcpSenderTest, SendSdes) {
EXPECT_EQ("alice@host", parser()->sdes()->chunks()[0].cname); EXPECT_EQ("alice@host", parser()->sdes()->chunks()[0].cname);
} }
TEST_F(RtcpSenderTest, SendSdesWithMaxChunks) {
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender->SetCNAME("alice@host"));
const char cname[] = "smith@host";
for (size_t i = 0; i < 30; ++i) {
const uint32_t csrc = 0x1234 + i;
EXPECT_EQ(0, rtcp_sender->AddMixedCNAME(csrc, cname));
}
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpSdes));
EXPECT_EQ(1, parser()->sdes()->num_packets());
EXPECT_EQ(31U, parser()->sdes()->chunks().size());
}
TEST_F(RtcpSenderTest, SdesIncludedInCompoundPacket) { TEST_F(RtcpSenderTest, SdesIncludedInCompoundPacket) {
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig()); auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound); rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
@ -588,25 +574,6 @@ TEST_F(RtcpSenderTest, SendTmmbr) {
// TODO(asapersson): tmmbr_item()->Overhead() looks broken, always zero. // TODO(asapersson): tmmbr_item()->Overhead() looks broken, always zero.
} }
TEST_F(RtcpSenderTest, TmmbrIncludedInCompoundPacketIfEnabled) {
const unsigned int kBitrateBps = 312000;
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_FALSE(rtcp_sender->TMMBR());
rtcp_sender->SetTMMBRStatus(true);
EXPECT_TRUE(rtcp_sender->TMMBR());
rtcp_sender->SetTargetBitrate(kBitrateBps);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(1, parser()->tmmbr()->num_packets());
EXPECT_EQ(1U, parser()->tmmbr()->requests().size());
// TMMBR should be included in each compound packet.
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(2, parser()->tmmbr()->num_packets());
rtcp_sender->SetTMMBRStatus(false);
EXPECT_FALSE(rtcp_sender->TMMBR());
}
TEST_F(RtcpSenderTest, SendTmmbn) { TEST_F(RtcpSenderTest, SendTmmbn) {
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig()); auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound); rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);

9
modules/rtp_rtcp/source/rtp_sender.cc
View File

@ -228,15 +228,6 @@ void RTPSender::SetExtmapAllowMixed(bool extmap_allow_mixed) {
rtp_header_extension_map_.SetExtmapAllowMixed(extmap_allow_mixed); rtp_header_extension_map_.SetExtmapAllowMixed(extmap_allow_mixed);
} }
int32_t RTPSender::RegisterRtpHeaderExtension(RTPExtensionType type,
uint8_t id) {
MutexLock lock(&send_mutex_);
bool registered = rtp_header_extension_map_.RegisterByType(id, type);
supports_bwe_extension_ = HasBweExtension(rtp_header_extension_map_);
UpdateHeaderSizes();
return registered ? 0 : -1;
}
bool RTPSender::RegisterRtpHeaderExtension(absl::string_view uri, int id) { bool RTPSender::RegisterRtpHeaderExtension(absl::string_view uri, int id) {
MutexLock lock(&send_mutex_); MutexLock lock(&send_mutex_);
bool registered = rtp_header_extension_map_.RegisterByUri(id, uri); bool registered = rtp_header_extension_map_.RegisterByUri(id, uri);

2
modules/rtp_rtcp/source/rtp_sender.h
View File

@ -78,8 +78,6 @@ class RTPSender {
RTC_LOCKS_EXCLUDED(send_mutex_); RTC_LOCKS_EXCLUDED(send_mutex_);
// RTP header extension // RTP header extension
int32_t RegisterRtpHeaderExtension(RTPExtensionType type, uint8_t id)
RTC_LOCKS_EXCLUDED(send_mutex_);
bool RegisterRtpHeaderExtension(absl::string_view uri, int id) bool RegisterRtpHeaderExtension(absl::string_view uri, int id)
RTC_LOCKS_EXCLUDED(send_mutex_); RTC_LOCKS_EXCLUDED(send_mutex_);
bool IsRtpHeaderExtensionRegistered(RTPExtensionType type) const bool IsRtpHeaderExtensionRegistered(RTPExtensionType type) const

212
modules/rtp_rtcp/source/rtp_sender_unittest.cc
View File

@ -451,16 +451,16 @@ class RtpSenderTest : public ::testing::TestWithParam<TestConfig> {
// Enable sending of the MID header extension for both the primary SSRC and // Enable sending of the MID header extension for both the primary SSRC and
// the RTX SSRC. // the RTX SSRC.
void EnableMidSending(const std::string& mid) { void EnableMidSending(const std::string& mid) {
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionMid, kMidExtensionId); rtp_sender()->RegisterRtpHeaderExtension(RtpMid::kUri, kMidExtensionId);
rtp_sender()->SetMid(mid); rtp_sender()->SetMid(mid);
} }
// Enable sending of the RSID header extension for the primary SSRC and the // Enable sending of the RSID header extension for the primary SSRC and the
// RRSID header extension for the RTX SSRC. // RRSID header extension for the RTX SSRC.
void EnableRidSending(const std::string& rid) { void EnableRidSending(const std::string& rid) {
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionRtpStreamId, rtp_sender()->RegisterRtpHeaderExtension(RtpStreamId::kUri,
kRidExtensionId); kRidExtensionId);
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionRepairedRtpStreamId, rtp_sender()->RegisterRtpHeaderExtension(RepairedRtpStreamId::kUri,
kRepairedRidExtensionId); kRepairedRidExtensionId);
rtp_sender()->SetRid(rid); rtp_sender()->SetRid(rid);
} }
@ -488,19 +488,16 @@ TEST_P(RtpSenderTestWithoutPacer, AllocatePacketSetCsrc) {
TEST_P(RtpSenderTestWithoutPacer, AllocatePacketReserveExtensions) { TEST_P(RtpSenderTestWithoutPacer, AllocatePacketReserveExtensions) {
// Configure rtp_sender with extensions. // Configure rtp_sender with extensions.
ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransmissionTimeOffset, TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
kTransmissionTimeOffsetExtensionId)); ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
ASSERT_EQ(0, AbsoluteSendTime::kUri, kAbsoluteSendTimeExtensionId));
rtp_sender()->RegisterRtpHeaderExtension( ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(AudioLevel::kUri,
kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); kAudioLevelExtensionId));
ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionAudioLevel, kAudioLevelExtensionId)); TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber, VideoOrientation::kUri, kVideoRotationExtensionId));
kTransportSequenceNumberExtensionId));
ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionVideoRotation, kVideoRotationExtensionId));
auto packet = rtp_sender()->AllocatePacket(); auto packet = rtp_sender()->AllocatePacket();
@ -615,9 +612,8 @@ TEST_P(RtpSenderTestWithoutPacer,
rtp_sender_context_ = rtp_sender_context_ =
std::make_unique<RtpSenderContext>(config, &time_controller_); std::make_unique<RtpSenderContext>(config, &time_controller_);
EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber, TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
kTransportSequenceNumberExtensionId));
const size_t expected_bytes = GetParam().with_overhead const size_t expected_bytes = GetParam().with_overhead
? kPayloadSize + kRtpOverheadBytesPerPacket ? kPayloadSize + kRtpOverheadBytesPerPacket
@ -650,9 +646,8 @@ TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
rtp_sender_context_ = rtp_sender_context_ =
std::make_unique<RtpSenderContext>(config, &time_controller_); std::make_unique<RtpSenderContext>(config, &time_controller_);
EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber, TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
kTransportSequenceNumberExtensionId));
EXPECT_CALL(send_packet_observer_, EXPECT_CALL(send_packet_observer_,
OnSendPacket(kTransportSequenceNumber, _, _)) OnSendPacket(kTransportSequenceNumber, _, _))
@ -698,7 +693,7 @@ TEST_P(RtpSenderTestWithoutPacer, PacketOptionsNoRetransmission) {
TEST_P(RtpSenderTestWithoutPacer, TEST_P(RtpSenderTestWithoutPacer,
SetsIncludedInFeedbackWhenTransportSequenceNumberExtensionIsRegistered) { SetsIncludedInFeedbackWhenTransportSequenceNumberExtensionIsRegistered) {
SetUpRtpSender(false, false, false); SetUpRtpSender(false, false, false);
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber, rtp_sender()->RegisterRtpHeaderExtension(TransportSequenceNumber::kUri,
kTransportSequenceNumberExtensionId); kTransportSequenceNumberExtensionId);
EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1); EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1);
SendGenericPacket(); SendGenericPacket();
@ -709,7 +704,7 @@ TEST_P(
RtpSenderTestWithoutPacer, RtpSenderTestWithoutPacer,
SetsIncludedInAllocationWhenTransportSequenceNumberExtensionIsRegistered) { SetsIncludedInAllocationWhenTransportSequenceNumberExtensionIsRegistered) {
SetUpRtpSender(false, false, false); SetUpRtpSender(false, false, false);
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber, rtp_sender()->RegisterRtpHeaderExtension(TransportSequenceNumber::kUri,
kTransportSequenceNumberExtensionId); kTransportSequenceNumberExtensionId);
EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1); EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1);
SendGenericPacket(); SendGenericPacket();
@ -812,9 +807,8 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) {
} }
TEST_P(RtpSenderTestWithoutPacer, OnSendPacketUpdated) { TEST_P(RtpSenderTestWithoutPacer, OnSendPacketUpdated) {
EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber, TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
kTransportSequenceNumberExtensionId));
EXPECT_CALL(send_packet_observer_, EXPECT_CALL(send_packet_observer_,
OnSendPacket(kTransportSequenceNumber, _, _)) OnSendPacket(kTransportSequenceNumber, _, _))
.Times(1); .Times(1);
@ -838,9 +832,8 @@ TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
rtp_sender()->SetSequenceNumber(kSeqNum); rtp_sender()->SetSequenceNumber(kSeqNum);
rtp_sender_context_->packet_history_.SetStorePacketsStatus( rtp_sender_context_->packet_history_.SetStorePacketsStatus(
RtpPacketHistory::StorageMode::kStoreAndCull, 10); RtpPacketHistory::StorageMode::kStoreAndCull, 10);
EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber, TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
kTransportSequenceNumberExtensionId));
EXPECT_CALL(send_packet_observer_, EXPECT_CALL(send_packet_observer_,
OnSendPacket(kTransportSequenceNumber, _, _)) OnSendPacket(kTransportSequenceNumber, _, _))
@ -877,8 +870,8 @@ TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
TEST_P(RtpSenderTest, WritesPacerExitToTimingExtension) { TEST_P(RtpSenderTest, WritesPacerExitToTimingExtension) {
rtp_sender_context_->packet_history_.SetStorePacketsStatus( rtp_sender_context_->packet_history_.SetStorePacketsStatus(
RtpPacketHistory::StorageMode::kStoreAndCull, 10); RtpPacketHistory::StorageMode::kStoreAndCull, 10);
EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionVideoTiming, kVideoTimingExtensionId)); VideoTimingExtension::kUri, kVideoTimingExtensionId));
int64_t capture_time_ms = clock_->TimeInMilliseconds(); int64_t capture_time_ms = clock_->TimeInMilliseconds();
auto packet = rtp_sender()->AllocatePacket(); auto packet = rtp_sender()->AllocatePacket();
packet->SetPayloadType(kPayload); packet->SetPayloadType(kPayload);
@ -912,8 +905,8 @@ TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithPacer) {
SetUpRtpSender(/*pacer=*/true, /*populate_network2=*/true, false); SetUpRtpSender(/*pacer=*/true, /*populate_network2=*/true, false);
rtp_sender_context_->packet_history_.SetStorePacketsStatus( rtp_sender_context_->packet_history_.SetStorePacketsStatus(
RtpPacketHistory::StorageMode::kStoreAndCull, 10); RtpPacketHistory::StorageMode::kStoreAndCull, 10);
EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionVideoTiming, kVideoTimingExtensionId)); VideoTimingExtension::kUri, kVideoTimingExtensionId));
int64_t capture_time_ms = clock_->TimeInMilliseconds(); int64_t capture_time_ms = clock_->TimeInMilliseconds();
auto packet = rtp_sender()->AllocatePacket(); auto packet = rtp_sender()->AllocatePacket();
packet->SetPayloadType(kPayload); packet->SetPayloadType(kPayload);
@ -949,8 +942,8 @@ TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithPacer) {
TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithoutPacer) { TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithoutPacer) {
SetUpRtpSender(/*pacer=*/false, /*populate_network2=*/true, false); SetUpRtpSender(/*pacer=*/false, /*populate_network2=*/true, false);
EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionVideoTiming, kVideoTimingExtensionId)); VideoTimingExtension::kUri, kVideoTimingExtensionId));
auto packet = rtp_sender()->AllocatePacket(); auto packet = rtp_sender()->AllocatePacket();
packet->SetMarker(true); packet->SetMarker(true);
packet->set_capture_time_ms(clock_->TimeInMilliseconds()); packet->set_capture_time_ms(clock_->TimeInMilliseconds());
@ -978,12 +971,10 @@ TEST_P(RtpSenderTest, TrafficSmoothingWithExtensions) {
rtp_sender_context_->packet_history_.SetStorePacketsStatus( rtp_sender_context_->packet_history_.SetStorePacketsStatus(
RtpPacketHistory::StorageMode::kStoreAndCull, 10); RtpPacketHistory::StorageMode::kStoreAndCull, 10);
EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransmissionTimeOffset, TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
kTransmissionTimeOffsetExtensionId)); EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
EXPECT_EQ(0, AbsoluteSendTime::kUri, kAbsoluteSendTimeExtensionId));
rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
int64_t capture_time_ms = clock_->TimeInMilliseconds(); int64_t capture_time_ms = clock_->TimeInMilliseconds();
auto packet = auto packet =
BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms); BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms);
@ -1023,12 +1014,10 @@ TEST_P(RtpSenderTest, TrafficSmoothingRetransmits) {
rtp_sender_context_->packet_history_.SetStorePacketsStatus( rtp_sender_context_->packet_history_.SetStorePacketsStatus(
RtpPacketHistory::StorageMode::kStoreAndCull, 10); RtpPacketHistory::StorageMode::kStoreAndCull, 10);
EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransmissionTimeOffset, TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
kTransmissionTimeOffsetExtensionId)); EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
EXPECT_EQ(0, AbsoluteSendTime::kUri, kAbsoluteSendTimeExtensionId));
rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
int64_t capture_time_ms = clock_->TimeInMilliseconds(); int64_t capture_time_ms = clock_->TimeInMilliseconds();
auto packet = auto packet =
BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms); BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms);
@ -1094,13 +1083,11 @@ TEST_P(RtpSenderTest, SendPadding) {
rtp_sender_context_->packet_history_.SetStorePacketsStatus( rtp_sender_context_->packet_history_.SetStorePacketsStatus(
RtpPacketHistory::StorageMode::kStoreAndCull, 10); RtpPacketHistory::StorageMode::kStoreAndCull, 10);
size_t rtp_header_len = kRtpHeaderSize; size_t rtp_header_len = kRtpHeaderSize;
EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransmissionTimeOffset, TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
kTransmissionTimeOffsetExtensionId));
rtp_header_len += 4; // 4 bytes extension. rtp_header_len += 4; // 4 bytes extension.
EXPECT_EQ(0, EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
rtp_sender()->RegisterRtpHeaderExtension( AbsoluteSendTime::kUri, kAbsoluteSendTimeExtensionId));
kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
rtp_header_len += 4; // 4 bytes extension. rtp_header_len += 4; // 4 bytes extension.
rtp_header_len += 4; // 4 extra bytes common to all extension headers. rtp_header_len += 4; // 4 extra bytes common to all extension headers.
@ -1196,9 +1183,8 @@ TEST_P(RtpSenderTest, SendPadding) {
} }
TEST_P(RtpSenderTest, OnSendPacketUpdated) { TEST_P(RtpSenderTest, OnSendPacketUpdated) {
EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber, TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
kTransportSequenceNumberExtensionId));
rtp_sender_context_->packet_history_.SetStorePacketsStatus( rtp_sender_context_->packet_history_.SetStorePacketsStatus(
RtpPacketHistory::StorageMode::kStoreAndCull, 10); RtpPacketHistory::StorageMode::kStoreAndCull, 10);
@ -1220,9 +1206,8 @@ TEST_P(RtpSenderTest, OnSendPacketUpdated) {
} }
TEST_P(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) { TEST_P(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber, TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
kTransportSequenceNumberExtensionId));
rtp_sender_context_->packet_history_.SetStorePacketsStatus( rtp_sender_context_->packet_history_.SetStorePacketsStatus(
RtpPacketHistory::StorageMode::kStoreAndCull, 10); RtpPacketHistory::StorageMode::kStoreAndCull, 10);
@ -2073,7 +2058,7 @@ TEST_P(RtpSenderTest, OnOverheadChanged) {
// Base RTP overhead is 12B. // Base RTP overhead is 12B.
EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u); EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u);
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset, rtp_sender()->RegisterRtpHeaderExtension(TransmissionOffset::kUri,
kTransmissionTimeOffsetExtensionId); kTransmissionTimeOffsetExtensionId);
// TransmissionTimeOffset extension has a size of 3B, but with the addition // TransmissionTimeOffset extension has a size of 3B, but with the addition
@ -2093,9 +2078,8 @@ TEST_P(RtpSenderTest, CountMidOnlyUntilAcked) {
// Base RTP overhead is 12B. // Base RTP overhead is 12B.
EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u); EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u);
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionMid, kMidExtensionId); rtp_sender()->RegisterRtpHeaderExtension(RtpMid::kUri, kMidExtensionId);
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionRtpStreamId, rtp_sender()->RegisterRtpHeaderExtension(RtpStreamId::kUri, kRidExtensionId);
kRidExtensionId);
// Counted only if set. // Counted only if set.
EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u); EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u);
@ -2121,14 +2105,16 @@ TEST_P(RtpSenderTest, DontCountVolatileExtensionsIntoOverhead) {
// Base RTP overhead is 12B. // Base RTP overhead is 12B.
EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u); EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u);
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionInbandComfortNoise, 1); rtp_sender()->RegisterRtpHeaderExtension(InbandComfortNoiseExtension::kUri,
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteCaptureTime, 2); 1);
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionVideoRotation, 3); rtp_sender()->RegisterRtpHeaderExtension(AbsoluteCaptureTimeExtension::kUri,
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionPlayoutDelay, 4); 2);
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionVideoContentType, 5); rtp_sender()->RegisterRtpHeaderExtension(VideoOrientation::kUri, 3);
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionVideoTiming, 6); rtp_sender()->RegisterRtpHeaderExtension(PlayoutDelayLimits::kUri, 4);
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionRepairedRtpStreamId, 7); rtp_sender()->RegisterRtpHeaderExtension(VideoContentTypeExtension::kUri, 5);
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionColorSpace, 8); rtp_sender()->RegisterRtpHeaderExtension(VideoTimingExtension::kUri, 6);
rtp_sender()->RegisterRtpHeaderExtension(RepairedRtpStreamId::kUri, 7);
rtp_sender()->RegisterRtpHeaderExtension(ColorSpaceExtension::kUri, 8);
// Still only 12B counted since can't count on above being sent. // Still only 12B counted since can't count on above being sent.
EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u); EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u);
@ -2268,16 +2254,12 @@ TEST_P(RtpSenderTest, SendPacketHandlesRetransmissionHistory) {
} }
TEST_P(RtpSenderTest, SendPacketUpdatesExtensions) { TEST_P(RtpSenderTest, SendPacketUpdatesExtensions) {
ASSERT_EQ(rtp_sender()->RegisterRtpHeaderExtension( ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransmissionTimeOffset, TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
kTransmissionTimeOffsetExtensionId), ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
0); AbsoluteSendTime::kUri, kAbsoluteSendTimeExtensionId));
ASSERT_EQ(rtp_sender()->RegisterRtpHeaderExtension( ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId), VideoTimingExtension::kUri, kVideoTimingExtensionId));
0);
ASSERT_EQ(rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionVideoTiming,
kVideoTimingExtensionId),
0);
std::unique_ptr<RtpPacketToSend> packet = std::unique_ptr<RtpPacketToSend> packet =
BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
@ -2303,10 +2285,8 @@ TEST_P(RtpSenderTest, SendPacketUpdatesExtensions) {
TEST_P(RtpSenderTest, SendPacketSetsPacketOptions) { TEST_P(RtpSenderTest, SendPacketSetsPacketOptions) {
const uint16_t kPacketId = 42; const uint16_t kPacketId = 42;
ASSERT_EQ(rtp_sender()->RegisterRtpHeaderExtension( ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber, TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
kTransportSequenceNumberExtensionId),
0);
std::unique_ptr<RtpPacketToSend> packet = std::unique_ptr<RtpPacketToSend> packet =
BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
packet->SetExtension<TransportSequenceNumber>(kPacketId); packet->SetExtension<TransportSequenceNumber>(kPacketId);
@ -2344,9 +2324,8 @@ TEST_P(RtpSenderTest, SendPacketUpdatesStats) {
config.send_packet_observer = &send_packet_observer_; config.send_packet_observer = &send_packet_observer_;
rtp_sender_context_ = rtp_sender_context_ =
std::make_unique<RtpSenderContext>(config, &time_controller_); std::make_unique<RtpSenderContext>(config, &time_controller_);
ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber, TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
kTransportSequenceNumberExtensionId));
const int64_t capture_time_ms = clock_->TimeInMilliseconds(); const int64_t capture_time_ms = clock_->TimeInMilliseconds();
@ -2408,15 +2387,12 @@ TEST_P(RtpSenderTest, GeneratedPaddingHasBweExtensions) {
rtp_sender_context_->packet_history_.SetStorePacketsStatus( rtp_sender_context_->packet_history_.SetStorePacketsStatus(
RtpPacketHistory::StorageMode::kStoreAndCull, 1); RtpPacketHistory::StorageMode::kStoreAndCull, 1);
ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransmissionTimeOffset, TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
kTransmissionTimeOffsetExtensionId)); ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
ASSERT_EQ(0, AbsoluteSendTime::kUri, kAbsoluteSendTimeExtensionId));
rtp_sender()->RegisterRtpHeaderExtension( ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber,
kTransportSequenceNumberExtensionId));
// Send a payload packet first, to enable padding and populate the packet // Send a payload packet first, to enable padding and populate the packet
// history. // history.
@ -2482,9 +2458,8 @@ TEST_P(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) {
rtp_sender_context_->packet_history_.SetStorePacketsStatus( rtp_sender_context_->packet_history_.SetStorePacketsStatus(
RtpPacketHistory::StorageMode::kStoreAndCull, 1); RtpPacketHistory::StorageMode::kStoreAndCull, 1);
ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber, TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
kTransportSequenceNumberExtensionId));
const size_t kPayloadPacketSize = kMinPaddingSize; const size_t kPayloadPacketSize = kMinPaddingSize;
std::unique_ptr<RtpPacketToSend> packet = std::unique_ptr<RtpPacketToSend> packet =
@ -2536,9 +2511,8 @@ TEST_P(RtpSenderTest, LimitsPayloadPaddingSize) {
rtp_sender_context_->packet_history_.SetStorePacketsStatus( rtp_sender_context_->packet_history_.SetStorePacketsStatus(
RtpPacketHistory::StorageMode::kStoreAndCull, 1); RtpPacketHistory::StorageMode::kStoreAndCull, 1);
ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber, TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
kTransportSequenceNumberExtensionId));
// Send a dummy video packet so it ends up in the packet history. // Send a dummy video packet so it ends up in the packet history.
const size_t kPayloadPacketSize = 1234u; const size_t kPayloadPacketSize = 1234u;
@ -2573,15 +2547,12 @@ TEST_P(RtpSenderTest, LimitsPayloadPaddingSize) {
TEST_P(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) { TEST_P(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) {
rtp_sender_context_->packet_history_.SetStorePacketsStatus( rtp_sender_context_->packet_history_.SetStorePacketsStatus(
RtpPacketHistory::StorageMode::kStoreAndCull, 1); RtpPacketHistory::StorageMode::kStoreAndCull, 1);
ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransmissionTimeOffset, TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
kTransmissionTimeOffsetExtensionId)); ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
ASSERT_EQ(0, AbsoluteSendTime::kUri, kAbsoluteSendTimeExtensionId));
rtp_sender()->RegisterRtpHeaderExtension( ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber,
kTransportSequenceNumberExtensionId));
const size_t kPayloadPacketSize = 1234; const size_t kPayloadPacketSize = 1234;
// Send a dummy video packet so it ends up in the packet history. Since we // Send a dummy video packet so it ends up in the packet history. Since we
@ -2632,10 +2603,9 @@ TEST_P(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) {
TEST_P(RtpSenderTest, SupportsPadding) { TEST_P(RtpSenderTest, SupportsPadding) {
bool kSendingMediaStats[] = {true, false}; bool kSendingMediaStats[] = {true, false};
bool kEnableRedundantPayloads[] = {true, false}; bool kEnableRedundantPayloads[] = {true, false};
RTPExtensionType kBweExtensionTypes[] = { absl::string_view kBweExtensionUris[] = {
kRtpExtensionTransportSequenceNumber, TransportSequenceNumber::kUri, TransportSequenceNumberV2::kUri,
kRtpExtensionTransportSequenceNumber02, kRtpExtensionAbsoluteSendTime, AbsoluteSendTime::kUri, TransmissionOffset::kUri};
kRtpExtensionTransmissionTimeOffset};
const int kExtensionsId = 7; const int kExtensionsId = 7;
for (bool sending_media : kSendingMediaStats) { for (bool sending_media : kSendingMediaStats) {
@ -2647,9 +2617,9 @@ TEST_P(RtpSenderTest, SupportsPadding) {
} }
rtp_sender()->SetRtxStatus(rtx_mode); rtp_sender()->SetRtxStatus(rtx_mode);
for (auto extension_type : kBweExtensionTypes) { for (auto extension_uri : kBweExtensionUris) {
EXPECT_FALSE(rtp_sender()->SupportsPadding()); EXPECT_FALSE(rtp_sender()->SupportsPadding());
rtp_sender()->RegisterRtpHeaderExtension(extension_type, kExtensionsId); rtp_sender()->RegisterRtpHeaderExtension(extension_uri, kExtensionsId);
if (!sending_media) { if (!sending_media) {
EXPECT_FALSE(rtp_sender()->SupportsPadding()); EXPECT_FALSE(rtp_sender()->SupportsPadding());
} else { } else {
@ -2660,7 +2630,7 @@ TEST_P(RtpSenderTest, SupportsPadding) {
EXPECT_FALSE(rtp_sender()->SupportsRtxPayloadPadding()); EXPECT_FALSE(rtp_sender()->SupportsRtxPayloadPadding());
} }
} }
rtp_sender()->DeregisterRtpHeaderExtension(extension_type); rtp_sender()->DeregisterRtpHeaderExtension(extension_uri);
EXPECT_FALSE(rtp_sender()->SupportsPadding()); EXPECT_FALSE(rtp_sender()->SupportsPadding());
} }
} }
@ -2668,7 +2638,7 @@ TEST_P(RtpSenderTest, SupportsPadding) {
} }
TEST_P(RtpSenderTest, SetsCaptureTimeAndPopulatesTransmissionOffset) { TEST_P(RtpSenderTest, SetsCaptureTimeAndPopulatesTransmissionOffset) {
rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset, rtp_sender()->RegisterRtpHeaderExtension(TransmissionOffset::kUri,
kTransmissionTimeOffsetExtensionId); kTransmissionTimeOffsetExtensionId);
rtp_sender()->SetSendingMediaStatus(true); rtp_sender()->SetSendingMediaStatus(true);