diff --git a/modules/rtp_rtcp/BUILD.gn b/modules/rtp_rtcp/BUILD.gn index 704344d1c6..173e3522cc 100644 --- a/modules/rtp_rtcp/BUILD.gn +++ b/modules/rtp_rtcp/BUILD.gn @@ -553,6 +553,7 @@ if (rtc_include_tests) { "../../rtc_base:rtc_base_tests_utils", "../../rtc_base:rtc_numerics", "../../rtc_base:task_queue_for_test", + "../../rtc_base/task_utils:to_queued_task", "../../system_wrappers", "../../test:field_trial", "../../test:mock_frame_transformer", diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc index 9e1aefa6f9..9146eb8fd8 100644 --- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc @@ -36,12 +36,13 @@ #include "rtc_base/arraysize.h" #include "rtc_base/rate_limiter.h" #include "rtc_base/strings/string_builder.h" +#include "rtc_base/task_utils/to_queued_task.h" #include "test/field_trial.h" #include "test/gmock.h" #include "test/gtest.h" #include "test/mock_transport.h" #include "test/rtp_header_parser.h" -#include "test/run_loop.h" +#include "test/time_controller/simulated_time_controller.h" namespace webrtc { @@ -212,24 +213,69 @@ class StreamDataTestCallback : public StreamDataCountersCallback { } }; +class TaskQueuePacketSender : public RtpPacketSender { + public: + TaskQueuePacketSender(TimeController* time_controller, + std::unique_ptr packet_sender) + : time_controller_(time_controller), + packet_sender_(std::move(packet_sender)), + queue_(time_controller_->CreateTaskQueueFactory()->CreateTaskQueue( + "PacerQueue", + TaskQueueFactory::Priority::NORMAL)) {} + + void EnqueuePackets( + std::vector> packets) override { + queue_->PostTask(ToQueuedTask([sender = packet_sender_.get(), + packets_ = std::move(packets)]() mutable { + sender->EnqueuePackets(std::move(packets_)); + })); + // Trigger task we just enqueued to be executed by updating the simulated + // time controller. + time_controller_->AdvanceTime(TimeDelta::Zero()); + } + + TaskQueueBase* task_queue() const { return queue_.get(); } + + TimeController* const time_controller_; + std::unique_ptr packet_sender_; + std::unique_ptr queue_; +}; + // Mimics ModuleRtpRtcp::RtpSenderContext. // TODO(sprang): Split up unit tests and test these components individually // wherever possible. struct RtpSenderContext : public SequenceNumberAssigner { - explicit RtpSenderContext(const RtpRtcpInterface::Configuration& config) - : packet_history_(config.clock, config.enable_rtx_padding_prioritization), + RtpSenderContext(const RtpRtcpInterface::Configuration& config, + TimeController* time_controller) + : time_controller_(time_controller), + packet_history_(config.clock, config.enable_rtx_padding_prioritization), packet_sender_(config, &packet_history_), - non_paced_sender_(&packet_sender_, this), - packet_generator_( - config, - &packet_history_, - config.paced_sender ? config.paced_sender : &non_paced_sender_) {} + pacer_(time_controller, + std::make_unique( + &packet_sender_, + this)), + packet_generator_(config, + &packet_history_, + config.paced_sender ? config.paced_sender : &pacer_) { + } void AssignSequenceNumber(RtpPacketToSend* packet) override { packet_generator_.AssignSequenceNumber(packet); } + // Inject packet straight into RtpSenderEgress without passing through the + // pacer, but while still running on the pacer task queue. + void InjectPacket(std::unique_ptr packet, + const PacedPacketInfo& packet_info) { + pacer_.task_queue()->PostTask( + ToQueuedTask([sender_ = &packet_sender_, packet_ = std::move(packet), + packet_info]() mutable { + sender_->SendPacket(packet_.get(), packet_info); + })); + time_controller_->AdvanceTime(TimeDelta::Zero()); + } + TimeController* time_controller_; RtpPacketHistory packet_history_; RtpSenderEgress packet_sender_; - RtpSenderEgress::NonPacedPacketSender non_paced_sender_; + TaskQueuePacketSender pacer_; RTPSender packet_generator_; }; @@ -270,8 +316,9 @@ class FieldTrialConfig : public WebRtcKeyValueConfig { class RtpSenderTest : public ::testing::TestWithParam { protected: RtpSenderTest() - : fake_clock_(kStartTime), - retransmission_rate_limiter_(&fake_clock_, 1000), + : time_controller_(Timestamp::Millis(kStartTime)), + clock_(time_controller_.GetClock()), + retransmission_rate_limiter_(clock_, 1000), flexfec_sender_(0, kFlexFecSsrc, kSsrc, @@ -279,7 +326,7 @@ class RtpSenderTest : public ::testing::TestWithParam { std::vector(), std::vector(), nullptr, - &fake_clock_), + clock_), kMarkerBit(true) { field_trials_.SetOverHeadEnabled(GetParam().with_overhead); field_trials_.UseDeferredFec(GetParam().deferred_fec); @@ -309,7 +356,7 @@ class RtpSenderTest : public ::testing::TestWithParam { bool always_send_mid_and_rid, VideoFecGenerator* fec_generator) { RtpRtcpInterface::Configuration config; - config.clock = &fake_clock_; + config.clock = clock_; config.outgoing_transport = &transport_; config.local_media_ssrc = kSsrc; config.rtx_send_ssrc = kRtxSsrc; @@ -323,13 +370,14 @@ class RtpSenderTest : public ::testing::TestWithParam { config.always_send_mid_and_rid = always_send_mid_and_rid; config.field_trials = &field_trials_; - rtp_sender_context_ = std::make_unique(config); + rtp_sender_context_ = + std::make_unique(config, &time_controller_); rtp_sender()->SetSequenceNumber(kSeqNum); rtp_sender()->SetTimestampOffset(0); } - test::RunLoop loop_; - SimulatedClock fake_clock_; + GlobalSimulatedTimeController time_controller_; + Clock* const clock_; NiceMock mock_rtc_event_log_; MockRtpPacketPacer mock_paced_sender_; StrictMock send_packet_observer_; @@ -373,7 +421,7 @@ class RtpSenderTest : public ::testing::TestWithParam { } std::unique_ptr SendGenericPacket() { - const int64_t kCaptureTimeMs = fake_clock_.TimeInMilliseconds(); + const int64_t kCaptureTimeMs = clock_->TimeInMilliseconds(); return SendPacket(kCaptureTimeMs, sizeof(kPayloadData)); } @@ -382,7 +430,7 @@ class RtpSenderTest : public ::testing::TestWithParam { for (auto& packet : rtp_sender()->GeneratePadding(target_size_bytes, true)) { generated_bytes += packet->payload_size() + packet->padding_size(); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); } return generated_bytes; } @@ -507,13 +555,14 @@ TEST_P(RtpSenderTest, AssignSequenceNumberAllowsPaddingOnAudio) { MockTransport transport; RtpRtcpInterface::Configuration config; config.audio = true; - config.clock = &fake_clock_; + config.clock = clock_; config.outgoing_transport = &transport; config.paced_sender = &mock_paced_sender_; config.local_media_ssrc = kSsrc; config.event_log = &mock_rtc_event_log_; config.retransmission_rate_limiter = &retransmission_rate_limiter_; - rtp_sender_context_ = std::make_unique(config); + rtp_sender_context_ = + std::make_unique(config, &time_controller_); rtp_sender()->SetTimestampOffset(0); @@ -556,14 +605,15 @@ TEST_P(RtpSenderTestWithoutPacer, constexpr size_t kRtpOverheadBytesPerPacket = 12 + 8; RtpRtcpInterface::Configuration config; - config.clock = &fake_clock_; + config.clock = clock_; config.outgoing_transport = &transport_; config.local_media_ssrc = kSsrc; config.transport_feedback_callback = &feedback_observer_; config.event_log = &mock_rtc_event_log_; config.retransmission_rate_limiter = &retransmission_rate_limiter_; config.field_trials = &field_trials_; - rtp_sender_context_ = std::make_unique(config); + rtp_sender_context_ = + std::make_unique(config, &time_controller_); EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( kRtpExtensionTransportSequenceNumber, @@ -591,14 +641,15 @@ TEST_P(RtpSenderTestWithoutPacer, TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) { RtpRtcpInterface::Configuration config; - config.clock = &fake_clock_; + config.clock = clock_; config.outgoing_transport = &transport_; config.local_media_ssrc = kSsrc; config.transport_feedback_callback = &feedback_observer_; config.event_log = &mock_rtc_event_log_; config.send_packet_observer = &send_packet_observer_; config.retransmission_rate_limiter = &retransmission_rate_limiter_; - rtp_sender_context_ = std::make_unique(config); + rtp_sender_context_ = + std::make_unique(config, &time_controller_); EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( kRtpExtensionTransportSequenceNumber, @@ -630,14 +681,15 @@ TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) { TEST_P(RtpSenderTestWithoutPacer, PacketOptionsNoRetransmission) { RtpRtcpInterface::Configuration config; - config.clock = &fake_clock_; + config.clock = clock_; config.outgoing_transport = &transport_; config.local_media_ssrc = kSsrc; config.transport_feedback_callback = &feedback_observer_; config.event_log = &mock_rtc_event_log_; config.send_packet_observer = &send_packet_observer_; config.retransmission_rate_limiter = &retransmission_rate_limiter_; - rtp_sender_context_ = std::make_unique(config); + rtp_sender_context_ = + std::make_unique(config, &time_controller_); SendGenericPacket(); @@ -685,16 +737,17 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) { StrictMock send_side_delay_observer_; RtpRtcpInterface::Configuration config; - config.clock = &fake_clock_; + config.clock = clock_; config.outgoing_transport = &transport_; config.local_media_ssrc = kSsrc; config.send_side_delay_observer = &send_side_delay_observer_; config.event_log = &mock_rtc_event_log_; - rtp_sender_context_ = std::make_unique(config); + rtp_sender_context_ = + std::make_unique(config, &time_controller_); FieldTrialBasedConfig field_trials; RTPSenderVideo::Config video_config; - video_config.clock = &fake_clock_; + video_config.clock = clock_; video_config.rtp_sender = rtp_sender(); video_config.field_trials = &field_trials; RTPSenderVideo rtp_sender_video(video_config); @@ -711,8 +764,8 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) { EXPECT_CALL(send_side_delay_observer_, SendSideDelayUpdated(10, 10, 10, kSsrc)) .Times(1); - int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); - fake_clock_.AdvanceTimeMilliseconds(10); + int64_t capture_time_ms = clock_->TimeInMilliseconds(); + time_controller_.AdvanceTime(TimeDelta::Millis(10)); video_header.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video.SendVideo( kPayloadType, kCodecType, capture_time_ms * kCaptureTimeMsToRtpTimestamp, @@ -724,7 +777,7 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) { EXPECT_CALL(send_side_delay_observer_, SendSideDelayUpdated(15, 20, 30, kSsrc)) .Times(1); - fake_clock_.AdvanceTimeMilliseconds(10); + time_controller_.AdvanceTime(TimeDelta::Millis(10)); video_header.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video.SendVideo( kPayloadType, kCodecType, capture_time_ms * kCaptureTimeMsToRtpTimestamp, @@ -737,7 +790,7 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) { // TODO(terelius): Is is not clear that this is the right behavior. EXPECT_CALL(send_side_delay_observer_, SendSideDelayUpdated(5, 10, 30, kSsrc)) .Times(1); - capture_time_ms = fake_clock_.TimeInMilliseconds(); + capture_time_ms = clock_->TimeInMilliseconds(); video_header.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video.SendVideo( kPayloadType, kCodecType, capture_time_ms * kCaptureTimeMsToRtpTimestamp, @@ -747,9 +800,9 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) { // Send a packet 1 second later. The earlier packets should have timed // out, so both max and average should be the delay of this packet. The total // keeps increasing. - fake_clock_.AdvanceTimeMilliseconds(1000); - capture_time_ms = fake_clock_.TimeInMilliseconds(); - fake_clock_.AdvanceTimeMilliseconds(1); + time_controller_.AdvanceTime(TimeDelta::Millis(1000)); + capture_time_ms = clock_->TimeInMilliseconds(); + time_controller_.AdvanceTime(TimeDelta::Millis(1)); EXPECT_CALL(send_side_delay_observer_, SendSideDelayUpdated(1, 1, 31, kSsrc)) .Times(1); video_header.frame_type = VideoFrameType::kVideoFrameKey; @@ -772,7 +825,7 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendPacketUpdated) { TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) { RtpRtcpInterface::Configuration config; - config.clock = &fake_clock_; + config.clock = clock_; config.outgoing_transport = &transport_; config.paced_sender = &mock_paced_sender_; config.local_media_ssrc = kSsrc; @@ -780,7 +833,8 @@ TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) { config.event_log = &mock_rtc_event_log_; config.send_packet_observer = &send_packet_observer_; config.retransmission_rate_limiter = &retransmission_rate_limiter_; - rtp_sender_context_ = std::make_unique(config); + rtp_sender_context_ = + std::make_unique(config, &time_controller_); rtp_sender()->SetSequenceNumber(kSeqNum); rtp_sender_context_->packet_history_.SetStorePacketsStatus( @@ -811,7 +865,7 @@ TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) { packet->set_packet_type(RtpPacketMediaType::kVideo); // Transport sequence number is set by PacketRouter, before SendPacket(). packet->SetExtension(kTransportSequenceNumber); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); uint16_t transport_seq_no; EXPECT_TRUE( @@ -826,7 +880,7 @@ TEST_P(RtpSenderTest, WritesPacerExitToTimingExtension) { RtpPacketHistory::StorageMode::kStoreAndCull, 10); EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( kRtpExtensionVideoTiming, kVideoTimingExtensionId)); - int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); + int64_t capture_time_ms = clock_->TimeInMilliseconds(); auto packet = rtp_sender()->AllocatePacket(); packet->SetPayloadType(kPayload); packet->SetMarker(true); @@ -844,8 +898,8 @@ TEST_P(RtpSenderTest, WritesPacerExitToTimingExtension) { &RtpPacketToSend::Ssrc, kSsrc))))); EXPECT_TRUE( rtp_sender()->SendToNetwork(std::make_unique(*packet))); - fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + time_controller_.AdvanceTime(TimeDelta::Millis(kStoredTimeInMs)); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); EXPECT_EQ(1, transport_.packets_sent()); EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); @@ -861,7 +915,7 @@ TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithPacer) { RtpPacketHistory::StorageMode::kStoreAndCull, 10); EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( kRtpExtensionVideoTiming, kVideoTimingExtensionId)); - int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); + int64_t capture_time_ms = clock_->TimeInMilliseconds(); auto packet = rtp_sender()->AllocatePacket(); packet->SetPayloadType(kPayload); packet->SetMarker(true); @@ -881,8 +935,8 @@ TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithPacer) { &RtpPacketToSend::Ssrc, kSsrc))))); EXPECT_TRUE( rtp_sender()->SendToNetwork(std::make_unique(*packet))); - fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + time_controller_.AdvanceTime(TimeDelta::Millis(kStoredTimeInMs)); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); EXPECT_EQ(1, transport_.packets_sent()); EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); @@ -900,7 +954,7 @@ TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithoutPacer) { kRtpExtensionVideoTiming, kVideoTimingExtensionId)); auto packet = rtp_sender()->AllocatePacket(); packet->SetMarker(true); - packet->set_capture_time_ms(fake_clock_.TimeInMilliseconds()); + packet->set_capture_time_ms(clock_->TimeInMilliseconds()); const VideoSendTiming kVideoTiming = {0u, 0u, 0u, 0u, 0u, 0u, true}; packet->SetExtension(kVideoTiming); packet->set_allow_retransmission(true); @@ -908,7 +962,7 @@ TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithoutPacer) { packet->set_packet_type(RtpPacketMediaType::kVideo); const int kPropagateTimeMs = 10; - fake_clock_.AdvanceTimeMilliseconds(kPropagateTimeMs); + time_controller_.AdvanceTime(TimeDelta::Millis(kPropagateTimeMs)); EXPECT_TRUE(rtp_sender()->SendToNetwork(std::move(packet))); @@ -931,7 +985,7 @@ TEST_P(RtpSenderTest, TrafficSmoothingWithExtensions) { EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); - int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); + int64_t capture_time_ms = clock_->TimeInMilliseconds(); auto packet = BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms); size_t packet_size = packet->size(); @@ -947,8 +1001,8 @@ TEST_P(RtpSenderTest, TrafficSmoothingWithExtensions) { EXPECT_TRUE( rtp_sender()->SendToNetwork(std::make_unique(*packet))); EXPECT_EQ(0, transport_.packets_sent()); - fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + time_controller_.AdvanceTime(TimeDelta::Millis(kStoredTimeInMs)); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); // Process send bucket. Packet should now be sent. EXPECT_EQ(1, transport_.packets_sent()); @@ -960,7 +1014,7 @@ TEST_P(RtpSenderTest, TrafficSmoothingWithExtensions) { // Verify transmission time offset. EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset); uint64_t expected_send_time = - ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); + ConvertMsToAbsSendTime(clock_->TimeInMilliseconds()); EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); } @@ -976,7 +1030,7 @@ TEST_P(RtpSenderTest, TrafficSmoothingRetransmits) { EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); - int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); + int64_t capture_time_ms = clock_->TimeInMilliseconds(); auto packet = BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms); size_t packet_size = packet->size(); @@ -992,13 +1046,14 @@ TEST_P(RtpSenderTest, TrafficSmoothingRetransmits) { EXPECT_TRUE( rtp_sender()->SendToNetwork(std::make_unique(*packet))); // Immediately process send bucket and send packet. - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::make_unique(*packet), + PacedPacketInfo()); EXPECT_EQ(1, transport_.packets_sent()); // Retransmit packet. const int kStoredTimeInMs = 100; - fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); + time_controller_.AdvanceTime(TimeDelta::Millis(kStoredTimeInMs)); EXPECT_CALL(mock_rtc_event_log_, LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing))); @@ -1011,7 +1066,7 @@ TEST_P(RtpSenderTest, TrafficSmoothingRetransmits) { Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)))))); EXPECT_EQ(static_cast(packet_size), rtp_sender()->ReSendPacket(kSeqNum)); EXPECT_EQ(1, transport_.packets_sent()); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); // Process send bucket. Packet should now be sent. EXPECT_EQ(2, transport_.packets_sent()); @@ -1023,7 +1078,7 @@ TEST_P(RtpSenderTest, TrafficSmoothingRetransmits) { // Verify transmission time offset. EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset); uint64_t expected_send_time = - ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); + ConvertMsToAbsSendTime(clock_->TimeInMilliseconds()); EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); } @@ -1052,7 +1107,7 @@ TEST_P(RtpSenderTest, SendPadding) { webrtc::RTPHeader rtp_header; - int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); + int64_t capture_time_ms = clock_->TimeInMilliseconds(); auto packet = BuildRtpPacket(kPayload, kMarkerBit, timestamp, capture_time_ms); const uint32_t media_packet_timestamp = timestamp; @@ -1071,8 +1126,8 @@ TEST_P(RtpSenderTest, SendPadding) { EXPECT_TRUE( rtp_sender()->SendToNetwork(std::make_unique(*packet))); EXPECT_EQ(total_packets_sent, transport_.packets_sent()); - fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + time_controller_.AdvanceTime(TimeDelta::Millis(kStoredTimeInMs)); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); ++seq_num; // Packet should now be sent. This test doesn't verify the regular video @@ -1104,14 +1159,14 @@ TEST_P(RtpSenderTest, SendPadding) { int offset = timestamp - media_packet_timestamp; EXPECT_EQ(offset, rtp_header.extension.transmissionTimeOffset); uint64_t expected_send_time = - ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); + ConvertMsToAbsSendTime(clock_->TimeInMilliseconds()); EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); - fake_clock_.AdvanceTimeMilliseconds(kPaddingPeriodMs); + time_controller_.AdvanceTime(TimeDelta::Millis(kPaddingPeriodMs)); timestamp += 90 * kPaddingPeriodMs; } // Send a regular video packet again. - capture_time_ms = fake_clock_.TimeInMilliseconds(); + capture_time_ms = clock_->TimeInMilliseconds(); packet = BuildRtpPacket(kPayload, kMarkerBit, timestamp, capture_time_ms); packet_size = packet->size(); @@ -1124,7 +1179,7 @@ TEST_P(RtpSenderTest, SendPadding) { Pointee(Property(&RtpPacketToSend::SequenceNumber, seq_num)))))); EXPECT_TRUE( rtp_sender()->SendToNetwork(std::make_unique(*packet))); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); // Process send bucket. EXPECT_EQ(++total_packets_sent, transport_.packets_sent()); @@ -1137,7 +1192,7 @@ TEST_P(RtpSenderTest, SendPadding) { // Verify transmission time offset. This packet is sent without delay. EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset); uint64_t expected_send_time = - ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); + ConvertMsToAbsSendTime(clock_->TimeInMilliseconds()); EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); } @@ -1160,7 +1215,7 @@ TEST_P(RtpSenderTest, OnSendPacketUpdated) { auto packet = SendGenericPacket(); packet->set_packet_type(RtpPacketMediaType::kVideo); packet->SetExtension(kTransportSequenceNumber); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); EXPECT_EQ(1, transport_.packets_sent()); } @@ -1182,7 +1237,7 @@ TEST_P(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) { auto packet = SendGenericPacket(); packet->set_packet_type(RtpPacketMediaType::kRetransmission); packet->SetExtension(kTransportSequenceNumber); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); EXPECT_EQ(1, transport_.packets_sent()); EXPECT_TRUE(transport_.last_options_.is_retransmit); @@ -1193,7 +1248,7 @@ TEST_P(RtpSenderTestWithoutPacer, SendGenericVideo) { const VideoCodecType kCodecType = VideoCodecType::kVideoCodecGeneric; FieldTrialBasedConfig field_trials; RTPSenderVideo::Config video_config; - video_config.clock = &fake_clock_; + video_config.clock = clock_; video_config.rtp_sender = rtp_sender(); video_config.field_trials = &field_trials; RTPSenderVideo rtp_sender_video(video_config); @@ -1235,7 +1290,7 @@ TEST_P(RtpSenderTestWithoutPacer, SendRawVideo) { FieldTrialBasedConfig field_trials; RTPSenderVideo::Config video_config; - video_config.clock = &fake_clock_; + video_config.clock = clock_; video_config.rtp_sender = rtp_sender(); video_config.field_trials = &field_trials; RTPSenderVideo rtp_sender_video(video_config); @@ -1260,11 +1315,11 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) { const std::vector kNoRtpExtensionSizes; FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexFecSsrc, kSsrc, kNoMid, kNoRtpExtensions, kNoRtpExtensionSizes, - nullptr /* rtp_state */, &fake_clock_); + nullptr /* rtp_state */, clock_); // Reset |rtp_sender_| to use FlexFEC. RtpRtcpInterface::Configuration config; - config.clock = &fake_clock_; + config.clock = clock_; config.outgoing_transport = &transport_; config.paced_sender = &mock_paced_sender_; config.local_media_ssrc = kSsrc; @@ -1273,7 +1328,8 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) { config.send_packet_observer = &send_packet_observer_; config.retransmission_rate_limiter = &retransmission_rate_limiter_; config.field_trials = &field_trials_; - rtp_sender_context_ = std::make_unique(config); + rtp_sender_context_ = + std::make_unique(config, &time_controller_); rtp_sender()->SetSequenceNumber(kSeqNum); rtp_sender_context_->packet_history_.SetStorePacketsStatus( @@ -1281,7 +1337,7 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) { FieldTrialBasedConfig field_trials; RTPSenderVideo::Config video_config; - video_config.clock = &fake_clock_; + video_config.clock = clock_; video_config.rtp_sender = rtp_sender(); if (!GetParam().deferred_fec) { video_config.fec_generator = &flexfec_sender; @@ -1334,15 +1390,15 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) { video_header.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video.SendVideo( - kMediaPayloadType, kCodecType, kTimestamp, - fake_clock_.TimeInMilliseconds(), kPayloadData, nullptr, video_header, + kMediaPayloadType, kCodecType, kTimestamp, clock_->TimeInMilliseconds(), + kPayloadData, nullptr, video_header, kDefaultExpectedRetransmissionTimeMs)); ASSERT_TRUE(media_packet != nullptr); ASSERT_TRUE(fec_packet != nullptr); flexfec_seq_num = fec_packet->SequenceNumber(); - rtp_egress()->SendPacket(media_packet.get(), PacedPacketInfo()); - rtp_egress()->SendPacket(fec_packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(media_packet), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(fec_packet), PacedPacketInfo()); ASSERT_EQ(2, transport_.packets_sent()); const RtpPacketReceived& sent_media_packet = transport_.sent_packets_[0]; @@ -1364,11 +1420,11 @@ TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) { const std::vector kNoRtpExtensionSizes; FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexFecSsrc, kSsrc, kNoMid, kNoRtpExtensions, kNoRtpExtensionSizes, - nullptr /* rtp_state */, &fake_clock_); + nullptr /* rtp_state */, clock_); // Reset |rtp_sender_| to use FlexFEC. RtpRtcpInterface::Configuration config; - config.clock = &fake_clock_; + config.clock = clock_; config.outgoing_transport = &transport_; config.local_media_ssrc = kSsrc; config.fec_generator = &flexfec_sender; @@ -1376,13 +1432,14 @@ TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) { config.send_packet_observer = &send_packet_observer_; config.retransmission_rate_limiter = &retransmission_rate_limiter_; config.field_trials = &field_trials_; - rtp_sender_context_ = std::make_unique(config); + rtp_sender_context_ = + std::make_unique(config, &time_controller_); rtp_sender()->SetSequenceNumber(kSeqNum); FieldTrialBasedConfig field_trials; RTPSenderVideo::Config video_config; - video_config.clock = &fake_clock_; + video_config.clock = clock_; video_config.rtp_sender = rtp_sender(); if (!GetParam().deferred_fec) { video_config.fec_generator = &flexfec_sender; @@ -1409,8 +1466,8 @@ TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) { RTPVideoHeader video_header; video_header.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video.SendVideo( - kMediaPayloadType, kCodecType, kTimestamp, - fake_clock_.TimeInMilliseconds(), kPayloadData, nullptr, video_header, + kMediaPayloadType, kCodecType, kTimestamp, clock_->TimeInMilliseconds(), + kPayloadData, nullptr, video_header, kDefaultExpectedRetransmissionTimeMs)); ASSERT_EQ(2, transport_.packets_sent()); @@ -1704,14 +1761,14 @@ TEST_P(RtpSenderTest, FecOverheadRate) { const std::vector kNoRtpExtensionSizes; FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexFecSsrc, kSsrc, kNoMid, kNoRtpExtensions, kNoRtpExtensionSizes, - nullptr /* rtp_state */, &fake_clock_); + nullptr /* rtp_state */, clock_); // Reset |rtp_sender_| to use this FlexFEC instance. SetUpRtpSender(false, false, false, &flexfec_sender); FieldTrialBasedConfig field_trials; RTPSenderVideo::Config video_config; - video_config.clock = &fake_clock_; + video_config.clock = clock_; video_config.rtp_sender = rtp_sender(); if (!GetParam().deferred_fec) { video_config.fec_generator = &flexfec_sender; @@ -1739,11 +1796,11 @@ TEST_P(RtpSenderTest, FecOverheadRate) { video_header.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video.SendVideo( - kMediaPayloadType, kCodecType, kTimestamp, - fake_clock_.TimeInMilliseconds(), kPayloadData, nullptr, video_header, + kMediaPayloadType, kCodecType, kTimestamp, clock_->TimeInMilliseconds(), + kPayloadData, nullptr, video_header, kDefaultExpectedRetransmissionTimeMs)); - fake_clock_.AdvanceTimeMilliseconds(kTimeBetweenPacketsMs); + time_controller_.AdvanceTime(TimeDelta::Millis(kTimeBetweenPacketsMs)); } constexpr size_t kRtpHeaderLength = 12; constexpr size_t kFlexfecHeaderLength = 20; @@ -1752,7 +1809,6 @@ TEST_P(RtpSenderTest, FecOverheadRate) { constexpr size_t kPacketLength = kRtpHeaderLength + kFlexfecHeaderLength + kGenericCodecHeaderLength + kPayloadLength; - loop_.Flush(); if (GetParam().deferred_fec) { EXPECT_NEAR( kNumFecPackets * kPacketLength * 8 / @@ -1795,16 +1851,17 @@ TEST_P(RtpSenderTest, BitrateCallbacks) { } callback; RtpRtcpInterface::Configuration config; - config.clock = &fake_clock_; + config.clock = clock_; config.outgoing_transport = &transport_; config.local_media_ssrc = kSsrc; config.send_bitrate_observer = &callback; config.retransmission_rate_limiter = &retransmission_rate_limiter_; - rtp_sender_context_ = std::make_unique(config); + rtp_sender_context_ = + std::make_unique(config, &time_controller_); FieldTrialBasedConfig field_trials; RTPSenderVideo::Config video_config; - video_config.clock = &fake_clock_; + video_config.clock = clock_; video_config.rtp_sender = rtp_sender(); video_config.field_trials = &field_trials; RTPSenderVideo rtp_sender_video(video_config); @@ -1833,8 +1890,7 @@ TEST_P(RtpSenderTest, BitrateCallbacks) { ASSERT_TRUE(rtp_sender_video.SendVideo( kPayloadType, kCodecType, 1234, 4321, payload, nullptr, video_header, kDefaultExpectedRetransmissionTimeMs)); - fake_clock_.AdvanceTimeMilliseconds(kPacketInterval); - loop_.Flush(); + time_controller_.AdvanceTime(TimeDelta::Millis(kPacketInterval)); } // We get one call for every stats updated, thus two calls since both the @@ -1856,7 +1912,7 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) { const VideoCodecType kCodecType = VideoCodecType::kVideoCodecGeneric; FieldTrialBasedConfig field_trials; RTPSenderVideo::Config video_config; - video_config.clock = &fake_clock_; + video_config.clock = clock_; video_config.rtp_sender = rtp_sender(); video_config.field_trials = &field_trials; RTPSenderVideo rtp_sender_video(video_config); @@ -1871,7 +1927,6 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) { ASSERT_TRUE(rtp_sender_video.SendVideo(kPayloadType, kCodecType, 1234, 4321, payload, nullptr, video_header, kDefaultExpectedRetransmissionTimeMs)); - loop_.Flush(); StreamDataCounters expected; expected.transmitted.payload_bytes = 6; expected.transmitted.header_bytes = 12; @@ -1887,7 +1942,6 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) { // Retransmit a frame. uint16_t seqno = rtp_sender()->SequenceNumber() - 1; rtp_sender()->ReSendPacket(seqno); - loop_.Flush(); expected.transmitted.payload_bytes = 12; expected.transmitted.header_bytes = 24; expected.transmitted.packets = 2; @@ -1899,7 +1953,6 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) { // Send padding. GenerateAndSendPadding(kMaxPaddingSize); - loop_.Flush(); expected.transmitted.payload_bytes = 12; expected.transmitted.header_bytes = 36; expected.transmitted.padding_bytes = kMaxPaddingSize; @@ -1913,11 +1966,10 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacksUlpfec) { const uint8_t kPayloadType = 127; const VideoCodecType kCodecType = VideoCodecType::kVideoCodecGeneric; - UlpfecGenerator ulpfec_generator(kRedPayloadType, kUlpfecPayloadType, - &fake_clock_); + UlpfecGenerator ulpfec_generator(kRedPayloadType, kUlpfecPayloadType, clock_); SetUpRtpSender(false, false, false, &ulpfec_generator); RTPSenderVideo::Config video_config; - video_config.clock = &fake_clock_; + video_config.clock = clock_; video_config.rtp_sender = rtp_sender(); video_config.field_trials = &field_trials_; video_config.red_payload_type = kRedPayloadType; @@ -1949,7 +2001,6 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacksUlpfec) { ASSERT_TRUE(rtp_sender_video.SendVideo(kPayloadType, kCodecType, 1234, 4321, payload, nullptr, video_header, kDefaultExpectedRetransmissionTimeMs)); - loop_.Flush(); expected.transmitted.payload_bytes = 28; expected.transmitted.header_bytes = 24; expected.transmitted.packets = 2; @@ -1968,8 +2019,6 @@ TEST_P(RtpSenderTestWithoutPacer, BytesReportedCorrectly) { GenerateAndSendPadding(1); GenerateAndSendPadding(1); - loop_.Flush(); - StreamDataCounters rtp_stats; StreamDataCounters rtx_stats; rtp_egress()->GetDataCounters(&rtp_stats, &rtx_stats); @@ -2009,12 +2058,12 @@ TEST_P(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) { std::vector sequence_numbers; for (int32_t i = 0; i < kNumPackets; ++i) { sequence_numbers.push_back(kStartSequenceNumber + i); - fake_clock_.AdvanceTimeMilliseconds(1); - SendPacket(fake_clock_.TimeInMilliseconds(), kPacketSize); + time_controller_.AdvanceTime(TimeDelta::Millis(1)); + SendPacket(clock_->TimeInMilliseconds(), kPacketSize); } EXPECT_EQ(kNumPackets, transport_.packets_sent()); - fake_clock_.AdvanceTimeMilliseconds(1000 - kNumPackets); + 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 @@ -2023,7 +2072,7 @@ TEST_P(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) { EXPECT_EQ(kNumPackets * 2, transport_.packets_sent()); // Must be at least 5ms in between retransmission attempts. - fake_clock_.AdvanceTimeMilliseconds(5); + time_controller_.AdvanceTime(TimeDelta::Millis(5)); // Resending should not work, bandwidth exceeded. rtp_sender()->OnReceivedNack(sequence_numbers, 0); @@ -2032,11 +2081,12 @@ TEST_P(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) { TEST_P(RtpSenderTest, UpdatingCsrcsUpdatedOverhead) { RtpRtcpInterface::Configuration config; - config.clock = &fake_clock_; + config.clock = clock_; config.outgoing_transport = &transport_; config.local_media_ssrc = kSsrc; config.retransmission_rate_limiter = &retransmission_rate_limiter_; - rtp_sender_context_ = std::make_unique(config); + rtp_sender_context_ = + std::make_unique(config, &time_controller_); // Base RTP overhead is 12B. EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u); @@ -2048,11 +2098,12 @@ TEST_P(RtpSenderTest, UpdatingCsrcsUpdatedOverhead) { TEST_P(RtpSenderTest, OnOverheadChanged) { RtpRtcpInterface::Configuration config; - config.clock = &fake_clock_; + config.clock = clock_; config.outgoing_transport = &transport_; config.local_media_ssrc = kSsrc; config.retransmission_rate_limiter = &retransmission_rate_limiter_; - rtp_sender_context_ = std::make_unique(config); + rtp_sender_context_ = + std::make_unique(config, &time_controller_); // Base RTP overhead is 12B. EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u); @@ -2067,11 +2118,12 @@ TEST_P(RtpSenderTest, OnOverheadChanged) { TEST_P(RtpSenderTest, CountMidOnlyUntilAcked) { RtpRtcpInterface::Configuration config; - config.clock = &fake_clock_; + config.clock = clock_; config.outgoing_transport = &transport_; config.local_media_ssrc = kSsrc; config.retransmission_rate_limiter = &retransmission_rate_limiter_; - rtp_sender_context_ = std::make_unique(config); + rtp_sender_context_ = + std::make_unique(config, &time_controller_); // Base RTP overhead is 12B. EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u); @@ -2094,11 +2146,12 @@ TEST_P(RtpSenderTest, CountMidOnlyUntilAcked) { TEST_P(RtpSenderTest, DontCountVolatileExtensionsIntoOverhead) { RtpRtcpInterface::Configuration config; - config.clock = &fake_clock_; + config.clock = clock_; config.outgoing_transport = &transport_; config.local_media_ssrc = kSsrc; config.retransmission_rate_limiter = &retransmission_rate_limiter_; - rtp_sender_context_ = std::make_unique(config); + rtp_sender_context_ = + std::make_unique(config, &time_controller_); // Base RTP overhead is 12B. EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u); @@ -2118,93 +2171,93 @@ TEST_P(RtpSenderTest, DontCountVolatileExtensionsIntoOverhead) { TEST_P(RtpSenderTest, SendPacketMatchesVideo) { std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->set_packet_type(RtpPacketMediaType::kVideo); // Verify sent with correct SSRC. - packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + packet = BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->SetSsrc(kSsrc); packet->set_packet_type(RtpPacketMediaType::kVideo); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 1); } TEST_P(RtpSenderTest, SendPacketMatchesAudio) { std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->set_packet_type(RtpPacketMediaType::kAudio); // Verify sent with correct SSRC. - packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + packet = BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->SetSsrc(kSsrc); packet->set_packet_type(RtpPacketMediaType::kAudio); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 1); } TEST_P(RtpSenderTest, SendPacketMatchesRetransmissions) { std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->set_packet_type(RtpPacketMediaType::kRetransmission); // Verify sent with correct SSRC (non-RTX). - packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + packet = BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->SetSsrc(kSsrc); packet->set_packet_type(RtpPacketMediaType::kRetransmission); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 1); // RTX retransmission. - packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + packet = BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->SetSsrc(kRtxSsrc); packet->set_packet_type(RtpPacketMediaType::kRetransmission); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 2); } TEST_P(RtpSenderTest, SendPacketMatchesPadding) { std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->set_packet_type(RtpPacketMediaType::kPadding); // Verify sent with correct SSRC (non-RTX). - packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + packet = BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->SetSsrc(kSsrc); packet->set_packet_type(RtpPacketMediaType::kPadding); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 1); // RTX padding. - packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + packet = BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->SetSsrc(kRtxSsrc); packet->set_packet_type(RtpPacketMediaType::kPadding); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 2); } TEST_P(RtpSenderTest, SendPacketMatchesFlexfec) { std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); // Verify sent with correct SSRC. - packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + packet = BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->SetSsrc(kFlexFecSsrc); packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 1); } TEST_P(RtpSenderTest, SendPacketMatchesUlpfec) { std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); // Verify sent with correct SSRC. - packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + packet = BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->SetSsrc(kSsrc); packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); EXPECT_EQ(transport_.packets_sent(), 1); } @@ -2217,35 +2270,36 @@ TEST_P(RtpSenderTest, SendPacketHandlesRetransmissionHistory) { // Build a media packet and send it. std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); const uint16_t media_sequence_number = packet->SequenceNumber(); packet->set_packet_type(RtpPacketMediaType::kVideo); packet->set_allow_retransmission(true); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); // Simulate retransmission request. - fake_clock_.AdvanceTimeMilliseconds(30); + time_controller_.AdvanceTime(TimeDelta::Millis(30)); EXPECT_GT(rtp_sender()->ReSendPacket(media_sequence_number), 0); // Packet already pending, retransmission not allowed. - fake_clock_.AdvanceTimeMilliseconds(30); + time_controller_.AdvanceTime(TimeDelta::Millis(30)); EXPECT_EQ(rtp_sender()->ReSendPacket(media_sequence_number), 0); // Packet exiting pacer, mark as not longer pending. - packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + packet = BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); EXPECT_NE(packet->SequenceNumber(), media_sequence_number); packet->set_packet_type(RtpPacketMediaType::kRetransmission); packet->SetSsrc(kRtxSsrc); packet->set_retransmitted_sequence_number(media_sequence_number); packet->set_allow_retransmission(false); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + uint16_t seq_no = packet->SequenceNumber(); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); // Retransmissions allowed again. - fake_clock_.AdvanceTimeMilliseconds(30); + time_controller_.AdvanceTime(TimeDelta::Millis(30)); EXPECT_GT(rtp_sender()->ReSendPacket(media_sequence_number), 0); // Retransmission of RTX packet should not be allowed. - EXPECT_EQ(rtp_sender()->ReSendPacket(packet->SequenceNumber()), 0); + EXPECT_EQ(rtp_sender()->ReSendPacket(seq_no), 0); } TEST_P(RtpSenderTest, SendPacketUpdatesExtensions) { @@ -2261,21 +2315,21 @@ TEST_P(RtpSenderTest, SendPacketUpdatesExtensions) { 0); std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); - packet->set_packetization_finish_time_ms(fake_clock_.TimeInMilliseconds()); + BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); + packet->set_packetization_finish_time_ms(clock_->TimeInMilliseconds()); const int32_t kDiffMs = 10; - fake_clock_.AdvanceTimeMilliseconds(kDiffMs); + time_controller_.AdvanceTime(TimeDelta::Millis(kDiffMs)); packet->set_packet_type(RtpPacketMediaType::kVideo); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); const RtpPacketReceived& received_packet = transport_.last_sent_packet(); EXPECT_EQ(received_packet.GetExtension(), kDiffMs * 90); EXPECT_EQ(received_packet.GetExtension(), - AbsoluteSendTime::MsTo24Bits(fake_clock_.TimeInMilliseconds())); + AbsoluteSendTime::MsTo24Bits(clock_->TimeInMilliseconds())); VideoSendTiming timing; EXPECT_TRUE(received_packet.GetExtension(&timing)); @@ -2289,12 +2343,12 @@ TEST_P(RtpSenderTest, SendPacketSetsPacketOptions) { kTransportSequenceNumberExtensionId), 0); std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->SetExtension(kPacketId); packet->set_packet_type(RtpPacketMediaType::kVideo); EXPECT_CALL(send_packet_observer_, OnSendPacket); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); EXPECT_EQ(transport_.last_options_.packet_id, kPacketId); EXPECT_TRUE(transport_.last_options_.included_in_allocation); @@ -2302,10 +2356,10 @@ TEST_P(RtpSenderTest, SendPacketSetsPacketOptions) { EXPECT_FALSE(transport_.last_options_.is_retransmit); // Send another packet as retransmission, verify options are populated. - packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + packet = BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->SetExtension(kPacketId + 1); packet->set_packet_type(RtpPacketMediaType::kRetransmission); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); EXPECT_TRUE(transport_.last_options_.is_retransmit); } @@ -2315,7 +2369,7 @@ TEST_P(RtpSenderTest, SendPacketUpdatesStats) { StrictMock send_side_delay_observer; RtpRtcpInterface::Configuration config; - config.clock = &fake_clock_; + config.clock = clock_; config.outgoing_transport = &transport_; config.local_media_ssrc = kSsrc; config.rtx_send_ssrc = kRtxSsrc; @@ -2323,35 +2377,36 @@ TEST_P(RtpSenderTest, SendPacketUpdatesStats) { config.send_side_delay_observer = &send_side_delay_observer; config.event_log = &mock_rtc_event_log_; config.send_packet_observer = &send_packet_observer_; - rtp_sender_context_ = std::make_unique(config); + rtp_sender_context_ = + std::make_unique(config, &time_controller_); ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension( kRtpExtensionTransportSequenceNumber, kTransportSequenceNumberExtensionId)); - const int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); + const int64_t capture_time_ms = clock_->TimeInMilliseconds(); std::unique_ptr video_packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); video_packet->set_packet_type(RtpPacketMediaType::kVideo); video_packet->SetPayloadSize(kPayloadSize); video_packet->SetExtension(1); std::unique_ptr rtx_packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); rtx_packet->SetSsrc(kRtxSsrc); rtx_packet->set_packet_type(RtpPacketMediaType::kRetransmission); rtx_packet->SetPayloadSize(kPayloadSize); rtx_packet->SetExtension(2); std::unique_ptr fec_packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); fec_packet->SetSsrc(kFlexFecSsrc); fec_packet->set_packet_type(RtpPacketMediaType::kForwardErrorCorrection); fec_packet->SetPayloadSize(kPayloadSize); fec_packet->SetExtension(3); const int64_t kDiffMs = 25; - fake_clock_.AdvanceTimeMilliseconds(kDiffMs); + time_controller_.AdvanceTime(TimeDelta::Millis(kDiffMs)); EXPECT_CALL(send_side_delay_observer, SendSideDelayUpdated(kDiffMs, kDiffMs, kDiffMs, kSsrc)); @@ -2361,17 +2416,15 @@ TEST_P(RtpSenderTest, SendPacketUpdatesStats) { EXPECT_CALL(send_packet_observer_, OnSendPacket(1, capture_time_ms, kSsrc)); - rtp_egress()->SendPacket(video_packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(video_packet), PacedPacketInfo()); // Send packet observer not called for padding/retransmissions. EXPECT_CALL(send_packet_observer_, OnSendPacket(2, _, _)).Times(0); - rtp_egress()->SendPacket(rtx_packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(rtx_packet), PacedPacketInfo()); EXPECT_CALL(send_packet_observer_, OnSendPacket(3, capture_time_ms, kFlexFecSsrc)); - rtp_egress()->SendPacket(fec_packet.get(), PacedPacketInfo()); - - loop_.Flush(); + rtp_sender_context_->InjectPacket(std::move(fec_packet), PacedPacketInfo()); StreamDataCounters rtp_stats; StreamDataCounters rtx_stats; @@ -2403,12 +2456,12 @@ TEST_P(RtpSenderTest, GeneratedPaddingHasBweExtensions) { // Send a payload packet first, to enable padding and populate the packet // history. std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + 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_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); // Generate a plain padding packet, check that extensions are registered. std::vector> generated_packets = @@ -2421,7 +2474,8 @@ TEST_P(RtpSenderTest, GeneratedPaddingHasBweExtensions) { EXPECT_TRUE(plain_padding->HasExtension()); // Verify all header extensions have been written. - rtp_egress()->SendPacket(plain_padding.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(plain_padding), + PacedPacketInfo()); const auto& sent_plain_padding = transport_.last_sent_packet(); EXPECT_TRUE(sent_plain_padding.HasExtension()); EXPECT_TRUE(sent_plain_padding.HasExtension()); @@ -2442,7 +2496,8 @@ TEST_P(RtpSenderTest, GeneratedPaddingHasBweExtensions) { EXPECT_TRUE(payload_padding->HasExtension()); // Verify all header extensions have been written. - rtp_egress()->SendPacket(payload_padding.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(payload_padding), + PacedPacketInfo()); const auto& sent_payload_padding = transport_.last_sent_packet(); EXPECT_TRUE(sent_payload_padding.HasExtension()); EXPECT_TRUE(sent_payload_padding.HasExtension()); @@ -2468,14 +2523,14 @@ TEST_P(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) { const size_t kPayloadPacketSize = kMinPaddingSize; std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); 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_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); // Generated padding has large enough budget that the video packet should be // retransmitted as padding. @@ -2523,12 +2578,12 @@ TEST_P(RtpSenderTest, LimitsPayloadPaddingSize) { // Send a dummy video packet so it ends up in the packet history. const size_t kPayloadPacketSize = 1234u; std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->set_allow_retransmission(true); packet->SetPayloadSize(kPayloadPacketSize); packet->set_packet_type(RtpPacketMediaType::kVideo); EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); // Smallest target size that will result in the sent packet being returned as // padding. @@ -2567,12 +2622,12 @@ TEST_P(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) { // Send a dummy video packet so it ends up in the packet history. Since we // are not using RTX, it should never be used as padding. std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds()); + BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds()); packet->set_allow_retransmission(true); packet->SetPayloadSize(kPayloadPacketSize); packet->set_packet_type(RtpPacketMediaType::kVideo); EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1); - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet), PacedPacketInfo()); // Payload padding not available without RTX, only generate plain padding on // the media SSRC. @@ -2597,7 +2652,7 @@ TEST_P(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) { EXPECT_TRUE(packet->HasExtension()); // Verify all header extensions are received. - rtp_egress()->SendPacket(packet.get(), PacedPacketInfo()); + 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); @@ -2661,54 +2716,55 @@ TEST_P(RtpSenderTest, SetsCaptureTimeAndPopulatesTransmissionOffset) { const uint32_t kTimestampTicksPerMs = 90; const int64_t kOffsetMs = 10; - auto packet = - BuildRtpPacket(kPayload, kMarkerBit, fake_clock_.TimeInMilliseconds(), - kMissingCaptureTimeMs); - packet->set_packet_type(RtpPacketMediaType::kVideo); - packet->ReserveExtension(); - packet->AllocatePayload(sizeof(kPayloadData)); + auto packet = + BuildRtpPacket(kPayload, kMarkerBit, clock_->TimeInMilliseconds(), + kMissingCaptureTimeMs); + packet->set_packet_type(RtpPacketMediaType::kVideo); + packet->ReserveExtension(); + packet->AllocatePayload(sizeof(kPayloadData)); - std::unique_ptr packet_to_pace; - EXPECT_CALL(mock_paced_sender_, EnqueuePackets) - .WillOnce([&](std::vector> packets) { - EXPECT_EQ(packets.size(), 1u); - EXPECT_GT(packets[0]->capture_time_ms(), 0); - packet_to_pace = std::move(packets[0]); - }); + std::unique_ptr packet_to_pace; + EXPECT_CALL(mock_paced_sender_, EnqueuePackets) + .WillOnce([&](std::vector> packets) { + EXPECT_EQ(packets.size(), 1u); + EXPECT_GT(packets[0]->capture_time_ms(), 0); + packet_to_pace = std::move(packets[0]); + }); - packet->set_allow_retransmission(true); - EXPECT_TRUE(rtp_sender()->SendToNetwork(std::move(packet))); + packet->set_allow_retransmission(true); + EXPECT_TRUE(rtp_sender()->SendToNetwork(std::move(packet))); - fake_clock_.AdvanceTimeMilliseconds(kOffsetMs); + time_controller_.AdvanceTime(TimeDelta::Millis(kOffsetMs)); - rtp_egress()->SendPacket(packet_to_pace.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet_to_pace), + PacedPacketInfo()); - EXPECT_EQ(1, transport_.packets_sent()); - absl::optional transmission_time_extension = - transport_.sent_packets_.back().GetExtension(); - ASSERT_TRUE(transmission_time_extension.has_value()); - EXPECT_EQ(*transmission_time_extension, kOffsetMs * kTimestampTicksPerMs); + EXPECT_EQ(1, transport_.packets_sent()); + absl::optional transmission_time_extension = + transport_.sent_packets_.back().GetExtension(); + ASSERT_TRUE(transmission_time_extension.has_value()); + EXPECT_EQ(*transmission_time_extension, kOffsetMs * kTimestampTicksPerMs); - // Retransmit packet. The RTX packet should get the same capture time as the - // original packet, so offset is delta from original packet to now. - fake_clock_.AdvanceTimeMilliseconds(kOffsetMs); + // Retransmit packet. The RTX packet should get the same capture time as the + // original packet, so offset is delta from original packet to now. + time_controller_.AdvanceTime(TimeDelta::Millis(kOffsetMs)); - std::unique_ptr rtx_packet_to_pace; - EXPECT_CALL(mock_paced_sender_, EnqueuePackets) - .WillOnce([&](std::vector> packets) { - EXPECT_GT(packets[0]->capture_time_ms(), 0); - rtx_packet_to_pace = std::move(packets[0]); - }); + std::unique_ptr rtx_packet_to_pace; + EXPECT_CALL(mock_paced_sender_, EnqueuePackets) + .WillOnce([&](std::vector> packets) { + EXPECT_GT(packets[0]->capture_time_ms(), 0); + rtx_packet_to_pace = std::move(packets[0]); + }); - EXPECT_GT(rtp_sender()->ReSendPacket(kSeqNum), 0); - rtp_egress()->SendPacket(rtx_packet_to_pace.get(), PacedPacketInfo()); + EXPECT_GT(rtp_sender()->ReSendPacket(kSeqNum), 0); + rtp_sender_context_->InjectPacket(std::move(rtx_packet_to_pace), + PacedPacketInfo()); - EXPECT_EQ(2, transport_.packets_sent()); - transmission_time_extension = - transport_.sent_packets_.back().GetExtension(); - ASSERT_TRUE(transmission_time_extension.has_value()); - EXPECT_EQ(*transmission_time_extension, - 2 * kOffsetMs * kTimestampTicksPerMs); + EXPECT_EQ(2, transport_.packets_sent()); + transmission_time_extension = + transport_.sent_packets_.back().GetExtension(); + ASSERT_TRUE(transmission_time_extension.has_value()); + EXPECT_EQ(*transmission_time_extension, 2 * kOffsetMs * kTimestampTicksPerMs); } TEST_P(RtpSenderTestWithoutPacer, ClearHistoryOnSequenceNumberCange) { @@ -2730,13 +2786,13 @@ TEST_P(RtpSenderTestWithoutPacer, ClearHistoryOnSequenceNumberCange) { // Advance time and make sure it can be retransmitted, even if we try to set // the ssrc the what it already is. rtp_sender()->SetSequenceNumber(rtp_sender()->SequenceNumber()); - fake_clock_.AdvanceTimeMilliseconds(kRtt); + time_controller_.AdvanceTime(TimeDelta::Millis(kRtt)); EXPECT_GT(rtp_sender()->ReSendPacket(packet_seqence_number), 0); // Change the sequence number, then move the time and try to retransmit again. // The old packet should now be gone. rtp_sender()->SetSequenceNumber(rtp_sender()->SequenceNumber() - 1); - fake_clock_.AdvanceTimeMilliseconds(kRtt); + time_controller_.AdvanceTime(TimeDelta::Millis(kRtt)); EXPECT_EQ(rtp_sender()->ReSendPacket(packet_seqence_number), 0); } @@ -2758,13 +2814,14 @@ TEST_P(RtpSenderTest, IgnoresNackAfterDisablingMedia) { }); SendGenericPacket(); - rtp_egress()->SendPacket(packet_to_pace.get(), PacedPacketInfo()); + rtp_sender_context_->InjectPacket(std::move(packet_to_pace), + PacedPacketInfo()); ASSERT_EQ(1u, transport_.sent_packets_.size()); // Disable media sending and try to retransmit the packet, it should fail. rtp_sender()->SetSendingMediaStatus(false); - fake_clock_.AdvanceTimeMilliseconds(kRtt); + time_controller_.AdvanceTime(TimeDelta::Millis(kRtt)); EXPECT_LT(rtp_sender()->ReSendPacket(kSeqNum), 0); }