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

Remove usage of InjectPacket and transport_ in rtp_sender_unittest

Browse Source 
Thus removing dependency on RtpSenderEgress, allowing simplification of
the test fixture in a follow-up.

Bug: webrtc:11340
Change-Id: I9772bab18d1f4a04e0deccc9125d4b1c16c30d7a
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/219627
Commit-Queue: Erik Språng <sprang@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34132}
This commit is contained in:
Erik Språng
2021-05-26 12:29:22 +02:00
committed by WebRTC LUCI CQ
parent b412efdb78
commit 8f8bf252e6
1 changed files with 50 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -393,7 +393,7 @@ class RtpSenderTest : public ::testing::TestWithParam<TestConfig> {
for (auto& packet :
rtp_sender()->GeneratePadding(target_size_bytes, true)) {
generated_bytes += packet->payload_size() + packet->padding_size();
rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo());
rtp_sender()->SendToNetwork(std::move(packet));
}
return generated_bytes;
}
@ -498,14 +498,23 @@ TEST_P(RtpSenderTest, PaddingAlwaysAllowedOnAudio) {
rtp_sender()->AssignSequenceNumber(audio_packet.get());
const size_t kPaddingSize = 59;
EXPECT_CALL(transport, SendRtp(_, kPaddingSize + kRtpHeaderSize, _))
.WillOnce(Return(true));
EXPECT_CALL(
mock_paced_sender_,
EnqueuePackets(ElementsAre(AllOf(
Pointee(Property(&RtpPacketToSend::packet_type,
RtpPacketMediaType::kPadding)),
Pointee(Property(&RtpPacketToSend::padding_size, kPaddingSize))))));
EXPECT_EQ(kPaddingSize, GenerateAndSendPadding(kPaddingSize));
// Requested padding size is too small, will send a larger one.
const size_t kMinPaddingSize = 50;
EXPECT_CALL(transport, SendRtp(_, kMinPaddingSize + kRtpHeaderSize, _))
.WillOnce(Return(true));
EXPECT_CALL(mock_paced_sender_,
EnqueuePackets(ElementsAre(
AllOf(Pointee(Property(&RtpPacketToSend::packet_type,
RtpPacketMediaType::kPadding)),
Pointee(Property(&RtpPacketToSend::padding_size,
kMinPaddingSize))))));
EXPECT_EQ(kMinPaddingSize, GenerateAndSendPadding(kMinPaddingSize - 5));
}
@ -515,7 +524,7 @@ TEST_P(RtpSenderTest, SendToNetworkForwardsPacketsToPacer) {
EXPECT_CALL(
mock_paced_sender_,
EnqueuePackets(Contains(AllOf(
EnqueuePackets(ElementsAre(AllOf(
Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)),
Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)),
Pointee(Property(&RtpPacketToSend::capture_time_ms, now_ms))))));
@ -533,7 +542,7 @@ TEST_P(RtpSenderTest, ReSendPacketForwardsPacketsToPacer) {
rtp_sender_context_->packet_history_.PutRtpPacket(std::move(packet), now_ms);
EXPECT_CALL(mock_paced_sender_,
EnqueuePackets(Contains(AllOf(
EnqueuePackets(ElementsAre(AllOf(
Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)),
Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)),
Pointee(Property(&RtpPacketToSend::capture_time_ms, now_ms)),
@ -560,7 +569,7 @@ TEST_P(RtpSenderTest, SendPadding) {
// number range. Size will be forced to full pack size and the timestamp
// shall be that of the last media packet.
EXPECT_CALL(mock_paced_sender_,
EnqueuePackets(Contains(AllOf(
EnqueuePackets(ElementsAre(AllOf(
Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)),
Pointee(Property(&RtpPacketToSend::SequenceNumber,
media_packet->SequenceNumber() + i + 1)),
@ -577,7 +586,7 @@ TEST_P(RtpSenderTest, SendPadding) {
// Send a regular video packet again.
EXPECT_CALL(mock_paced_sender_,
EnqueuePackets(Contains(AllOf(
EnqueuePackets(ElementsAre(AllOf(
Pointee(Property(
&RtpPacketToSend::SequenceNumber,
media_packet->SequenceNumber() + kNumPaddingPackets + 1)),
@ -644,7 +653,7 @@ TEST_P(RtpSenderTest, UpdatesTimestampsOnPlainRtxPadding) {
// Start by sending one media packet.
EXPECT_CALL(
mock_paced_sender_,
EnqueuePackets(Contains(AllOf(
EnqueuePackets(ElementsAre(AllOf(
Pointee(Property(&RtpPacketToSend::padding_size, 0u)),
Pointee(Property(&RtpPacketToSend::Timestamp, start_timestamp)),
Pointee(Property(&RtpPacketToSend::capture_time_ms, start_time))))));
@ -681,7 +690,7 @@ TEST_P(RtpSenderTest, KeepsTimestampsOnPayloadPadding) {
// Start by sending one media packet and putting in the packet history.
EXPECT_CALL(
mock_paced_sender_,
EnqueuePackets(Contains(AllOf(
EnqueuePackets(ElementsAre(AllOf(
Pointee(Property(&RtpPacketToSend::padding_size, 0u)),
Pointee(Property(&RtpPacketToSend::Timestamp, start_timestamp)),
Pointee(Property(&RtpPacketToSend::capture_time_ms, start_time))))));
@ -981,7 +990,7 @@ TEST_P(RtpSenderTest, MidAndRridNotIncludedOnRtxPacketsAfterRtpStateRestored) {
ASSERT_LT(0, rtp_sender()->ReSendPacket(built_packet->SequenceNumber()));
}
TEST_P(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) {
TEST_P(RtpSenderTest, RespectsNackBitrateLimit) {
const int32_t kPacketSize = 1400;
const int32_t kNumPackets = 30;
@ -994,24 +1003,38 @@ TEST_P(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) {
for (int32_t i = 0; i < kNumPackets; ++i) {
sequence_numbers.push_back(kStartSequenceNumber + i);
time_controller_.AdvanceTime(TimeDelta::Millis(1));
EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1)))
.WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
rtp_sender_context_->packet_history_.PutRtpPacket(
std::move(packets[0]), clock_->TimeInMilliseconds());
});
SendPacket(clock_->TimeInMilliseconds(), kPacketSize);
}
EXPECT_EQ(kNumPackets, transport_.packets_sent());
time_controller_.AdvanceTime(TimeDelta::Millis(1000 - kNumPackets));
// Resending should work - brings the bandwidth up to the limit.
// NACK bitrate is capped to the same bitrate as the encoder, since the max
// protection overhead is 50% (see MediaOptimization::SetTargetRates).
EXPECT_CALL(mock_paced_sender_, EnqueuePackets(ElementsAre(Pointee(Property(
&RtpPacketToSend::packet_type,
RtpPacketMediaType::kRetransmission)))))
.Times(kNumPackets)
.WillRepeatedly(
[&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
for (const auto& packet : packets) {
rtp_sender_context_->packet_history_.MarkPacketAsSent(
*packet->retransmitted_sequence_number());
}
});
rtp_sender()->OnReceivedNack(sequence_numbers, 0);
EXPECT_EQ(kNumPackets * 2, transport_.packets_sent());
// Must be at least 5ms in between retransmission attempts.
time_controller_.AdvanceTime(TimeDelta::Millis(5));
// Resending should not work, bandwidth exceeded.
EXPECT_CALL(mock_paced_sender_, EnqueuePackets).Times(0);
rtp_sender()->OnReceivedNack(sequence_numbers, 0);
EXPECT_EQ(kNumPackets * 2, transport_.packets_sent());
}
TEST_P(RtpSenderTest, UpdatingCsrcsUpdatedOverhead) {
@ -1163,11 +1186,7 @@ TEST_P(RtpSenderTest, MarksRetransmittedPackets) {
TEST_P(RtpSenderTest, GeneratedPaddingHasBweExtensions) {
// Min requested size in order to use RTX payload.
const size_t kMinPaddingSize = 50;
rtp_sender()->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
rtp_sender()->SetRtxPayloadType(kRtxPayload, kPayload);
rtp_sender_context_->packet_history_.SetStorePacketsStatus(
RtpPacketHistory::StorageMode::kStoreAndCull, 1);
EnableRtx();
ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
TransmissionOffset::kUri, kTransmissionTimeOffsetExtensionId));
@ -1176,15 +1195,14 @@ TEST_P(RtpSenderTest, GeneratedPaddingHasBweExtensions) {
ASSERT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
// Send a payload packet first, to enable padding and populate the packet
// history.
// Put a packet in the history, in order to facilitate payload padding.
std::unique_ptr<RtpPacketToSend> packet =
BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
packet->set_allow_retransmission(true);
packet->SetPayloadSize(kMinPaddingSize);
packet->set_packet_type(RtpPacketMediaType::kVideo);
EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1);
rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo());
rtp_sender_context_->packet_history_.PutRtpPacket(
std::move(packet), clock_->TimeInMilliseconds());
// Generate a plain padding packet, check that extensions are registered.
std::vector<std::unique_ptr<RtpPacketToSend>> generated_packets =
@ -1195,19 +1213,7 @@ TEST_P(RtpSenderTest, GeneratedPaddingHasBweExtensions) {
EXPECT_TRUE(plain_padding->HasExtension<TransportSequenceNumber>());
EXPECT_TRUE(plain_padding->HasExtension<AbsoluteSendTime>());
EXPECT_TRUE(plain_padding->HasExtension<TransmissionOffset>());
// Verify all header extensions have been written.
rtp_sender_context_->InjectPacket(std::move(plain_padding),
PacedPacketInfo());
const auto& sent_plain_padding = transport_.last_sent_packet();
EXPECT_TRUE(sent_plain_padding.HasExtension<TransportSequenceNumber>());
EXPECT_TRUE(sent_plain_padding.HasExtension<AbsoluteSendTime>());
EXPECT_TRUE(sent_plain_padding.HasExtension<TransmissionOffset>());
webrtc::RTPHeader rtp_header;
sent_plain_padding.GetHeader(&rtp_header);
EXPECT_TRUE(rtp_header.extension.hasAbsoluteSendTime);
EXPECT_TRUE(rtp_header.extension.hasTransmissionTimeOffset);
EXPECT_TRUE(rtp_header.extension.hasTransportSequenceNumber);
EXPECT_GT(plain_padding->padding_size(), 0u);
// Generate a payload padding packets, check that extensions are registered.
generated_packets = rtp_sender()->GeneratePadding(kMinPaddingSize, true);
@ -1217,18 +1223,7 @@ TEST_P(RtpSenderTest, GeneratedPaddingHasBweExtensions) {
EXPECT_TRUE(payload_padding->HasExtension<TransportSequenceNumber>());
EXPECT_TRUE(payload_padding->HasExtension<AbsoluteSendTime>());
EXPECT_TRUE(payload_padding->HasExtension<TransmissionOffset>());
// Verify all header extensions have been written.
rtp_sender_context_->InjectPacket(std::move(payload_padding),
PacedPacketInfo());
const auto& sent_payload_padding = transport_.last_sent_packet();
EXPECT_TRUE(sent_payload_padding.HasExtension<TransportSequenceNumber>());
EXPECT_TRUE(sent_payload_padding.HasExtension<AbsoluteSendTime>());
EXPECT_TRUE(sent_payload_padding.HasExtension<TransmissionOffset>());
sent_payload_padding.GetHeader(&rtp_header);
EXPECT_TRUE(rtp_header.extension.hasAbsoluteSendTime);
EXPECT_TRUE(rtp_header.extension.hasTransmissionTimeOffset);
EXPECT_TRUE(rtp_header.extension.hasTransportSequenceNumber);
EXPECT_GT(payload_padding->payload_size(), 0u);
}
TEST_P(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) {
@ -1249,10 +1244,8 @@ TEST_P(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) {
packet->set_allow_retransmission(true);
packet->SetPayloadSize(kPayloadPacketSize);
packet->set_packet_type(RtpPacketMediaType::kVideo);
// Send a dummy video packet so it ends up in the packet history.
EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1);
rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo());
rtp_sender_context_->packet_history_.PutRtpPacket(
std::move(packet), clock_->TimeInMilliseconds());
// Generated padding has large enough budget that the video packet should be
// retransmitted as padding.
@ -1303,8 +1296,8 @@ TEST_P(RtpSenderTest, LimitsPayloadPaddingSize) {
packet->set_allow_retransmission(true);
packet->SetPayloadSize(kPayloadPacketSize);
packet->set_packet_type(RtpPacketMediaType::kVideo);
EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1);
rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo());
rtp_sender_context_->packet_history_.PutRtpPacket(
std::move(packet), clock_->TimeInMilliseconds());
// Smallest target size that will result in the sent packet being returned as
// padding.
@ -1344,8 +1337,8 @@ TEST_P(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) {
packet->set_allow_retransmission(true);
packet->SetPayloadSize(kPayloadPacketSize);
packet->set_packet_type(RtpPacketMediaType::kVideo);
EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1);
rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo());
rtp_sender_context_->packet_history_.PutRtpPacket(
std::move(packet), clock_->TimeInMilliseconds());
// Payload padding not available without RTX, only generate plain padding on
// the media SSRC.
@ -1368,14 +1361,6 @@ TEST_P(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) {
EXPECT_TRUE(packet->HasExtension<TransportSequenceNumber>());
EXPECT_TRUE(packet->HasExtension<AbsoluteSendTime>());
EXPECT_TRUE(packet->HasExtension<TransmissionOffset>());
// Verify all header extensions are received.
rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo());
webrtc::RTPHeader rtp_header;
transport_.last_sent_packet().GetHeader(&rtp_header);
EXPECT_TRUE(rtp_header.extension.hasAbsoluteSendTime);
EXPECT_TRUE(rtp_header.extension.hasTransmissionTimeOffset);
EXPECT_TRUE(rtp_header.extension.hasTransportSequenceNumber);
}
EXPECT_EQ(padding_bytes_generated,