Updates rtp_sender_unitests to use separate thread for pacer calls.
Some classes such as RtpSenderEgress makes assumptions about which
threads (e.g. paced sender vs worker thread) call specific methods.
Unit tests currently are single threaded so these checks are
essentially noops.
This change uses a separate task queue for calls epected to be called
by the pacer, so that inconsistencies in thread can be detected early.
Bug: None
Change-Id: Ic0904304a67eb034033524e62306da34b9eab8b4
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/178602
Reviewed-by: Tommi <tommi@webrtc.org>
Commit-Queue: Tommi <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31628}
diff --git a/modules/rtp_rtcp/BUILD.gn b/modules/rtp_rtcp/BUILD.gn
index 704344d..173e352 100644
--- a/modules/rtp_rtcp/BUILD.gn
+++ b/modules/rtp_rtcp/BUILD.gn
@@ -553,6 +553,7 @@
"../../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 9e1aefa..9146eb8 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 TaskQueuePacketSender : public RtpPacketSender {
+ public:
+ TaskQueuePacketSender(TimeController* time_controller,
+ std::unique_ptr<RtpPacketSender> 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<std::unique_ptr<RtpPacketToSend>> 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<RtpPacketSender> packet_sender_;
+ std::unique_ptr<TaskQueueBase, TaskQueueDeleter> 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<RtpSenderEgress::NonPacedPacketSender>(
+ &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<RtpPacketToSend> 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 RtpSenderTest : public ::testing::TestWithParam<TestConfig> {
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 @@
std::vector<RtpExtension>(),
std::vector<RtpExtensionSize>(),
nullptr,
- &fake_clock_),
+ clock_),
kMarkerBit(true) {
field_trials_.SetOverHeadEnabled(GetParam().with_overhead);
field_trials_.UseDeferredFec(GetParam().deferred_fec);
@@ -309,7 +356,7 @@
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 @@
config.always_send_mid_and_rid = always_send_mid_and_rid;
config.field_trials = &field_trials_;
- rtp_sender_context_ = std::make_unique<RtpSenderContext>(config);
+ rtp_sender_context_ =
+ std::make_unique<RtpSenderContext>(config, &time_controller_);
rtp_sender()->SetSequenceNumber(kSeqNum);
rtp_sender()->SetTimestampOffset(0);
}
- test::RunLoop loop_;
- SimulatedClock fake_clock_;
+ GlobalSimulatedTimeController time_controller_;
+ Clock* const clock_;
NiceMock<MockRtcEventLog> mock_rtc_event_log_;
MockRtpPacketPacer mock_paced_sender_;
StrictMock<MockSendPacketObserver> send_packet_observer_;
@@ -373,7 +421,7 @@
}
std::unique_ptr<RtpPacketToSend> SendGenericPacket() {
- const int64_t kCaptureTimeMs = fake_clock_.TimeInMilliseconds();
+ const int64_t kCaptureTimeMs = clock_->TimeInMilliseconds();
return SendPacket(kCaptureTimeMs, sizeof(kPayloadData));
}
@@ -382,7 +430,7 @@
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 @@
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<RtpSenderContext>(config);
+ rtp_sender_context_ =
+ std::make_unique<RtpSenderContext>(config, &time_controller_);
rtp_sender()->SetTimestampOffset(0);
@@ -556,14 +605,15 @@
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<RtpSenderContext>(config);
+ rtp_sender_context_ =
+ std::make_unique<RtpSenderContext>(config, &time_controller_);
EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber,
@@ -591,14 +641,15 @@
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<RtpSenderContext>(config);
+ rtp_sender_context_ =
+ std::make_unique<RtpSenderContext>(config, &time_controller_);
EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber,
@@ -630,14 +681,15 @@
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<RtpSenderContext>(config);
+ rtp_sender_context_ =
+ std::make_unique<RtpSenderContext>(config, &time_controller_);
SendGenericPacket();
@@ -685,16 +737,17 @@
StrictMock<MockSendSideDelayObserver> 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<RtpSenderContext>(config);
+ rtp_sender_context_ =
+ std::make_unique<RtpSenderContext>(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 @@
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 @@
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 @@
// 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 @@
// 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(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 @@
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<RtpSenderContext>(config);
+ rtp_sender_context_ =
+ std::make_unique<RtpSenderContext>(config, &time_controller_);
rtp_sender()->SetSequenceNumber(kSeqNum);
rtp_sender_context_->packet_history_.SetStorePacketsStatus(
@@ -811,7 +865,7 @@
packet->set_packet_type(RtpPacketMediaType::kVideo);
// Transport sequence number is set by PacketRouter, before SendPacket().
packet->SetExtension<TransportSequenceNumber>(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 @@
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 @@
&RtpPacketToSend::Ssrc, kSsrc)))));
EXPECT_TRUE(
rtp_sender()->SendToNetwork(std::make_unique<RtpPacketToSend>(*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 @@
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 @@
&RtpPacketToSend::Ssrc, kSsrc)))));
EXPECT_TRUE(
rtp_sender()->SendToNetwork(std::make_unique<RtpPacketToSend>(*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 @@
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<VideoTimingExtension>(kVideoTiming);
packet->set_allow_retransmission(true);
@@ -908,7 +962,7 @@
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 @@
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 @@
EXPECT_TRUE(
rtp_sender()->SendToNetwork(std::make_unique<RtpPacketToSend>(*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 @@
// 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 @@
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 @@
EXPECT_TRUE(
rtp_sender()->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
// Immediately process send bucket and send packet.
- rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+ rtp_sender_context_->InjectPacket(std::make_unique<RtpPacketToSend>(*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 @@
Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum))))));
EXPECT_EQ(static_cast<int>(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 @@
// 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 @@
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 @@
EXPECT_TRUE(
rtp_sender()->SendToNetwork(std::make_unique<RtpPacketToSend>(*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 @@
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 @@
Pointee(Property(&RtpPacketToSend::SequenceNumber, seq_num))))));
EXPECT_TRUE(
rtp_sender()->SendToNetwork(std::make_unique<RtpPacketToSend>(*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 @@
// 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 @@
auto packet = SendGenericPacket();
packet->set_packet_type(RtpPacketMediaType::kVideo);
packet->SetExtension<TransportSequenceNumber>(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 @@
auto packet = SendGenericPacket();
packet->set_packet_type(RtpPacketMediaType::kRetransmission);
packet->SetExtension<TransportSequenceNumber>(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 @@
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 @@
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 @@
const std::vector<RtpExtensionSize> 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 @@
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<RtpSenderContext>(config);
+ rtp_sender_context_ =
+ std::make_unique<RtpSenderContext>(config, &time_controller_);
rtp_sender()->SetSequenceNumber(kSeqNum);
rtp_sender_context_->packet_history_.SetStorePacketsStatus(
@@ -1281,7 +1337,7 @@
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 @@
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 @@
const std::vector<RtpExtensionSize> 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 @@
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<RtpSenderContext>(config);
+ rtp_sender_context_ =
+ std::make_unique<RtpSenderContext>(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 @@
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 @@
const std::vector<RtpExtensionSize> 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 @@
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 @@
constexpr size_t kPacketLength = kRtpHeaderLength + kFlexfecHeaderLength +
kGenericCodecHeaderLength + kPayloadLength;
- loop_.Flush();
if (GetParam().deferred_fec) {
EXPECT_NEAR(
kNumFecPackets * kPacketLength * 8 /
@@ -1795,16 +1851,17 @@
} 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<RtpSenderContext>(config);
+ rtp_sender_context_ =
+ std::make_unique<RtpSenderContext>(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 @@
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 @@
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 @@
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 @@
// 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 @@
// 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 @@
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 @@
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 @@
GenerateAndSendPadding(1);
GenerateAndSendPadding(1);
- loop_.Flush();
-
StreamDataCounters rtp_stats;
StreamDataCounters rtx_stats;
rtp_egress()->GetDataCounters(&rtp_stats, &rtx_stats);
@@ -2009,12 +2058,12 @@
std::vector<uint16_t> 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 @@
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(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<RtpSenderContext>(config);
+ rtp_sender_context_ =
+ std::make_unique<RtpSenderContext>(config, &time_controller_);
// Base RTP overhead is 12B.
EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u);
@@ -2048,11 +2098,12 @@
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<RtpSenderContext>(config);
+ rtp_sender_context_ =
+ std::make_unique<RtpSenderContext>(config, &time_controller_);
// Base RTP overhead is 12B.
EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u);
@@ -2067,11 +2118,12 @@
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<RtpSenderContext>(config);
+ rtp_sender_context_ =
+ std::make_unique<RtpSenderContext>(config, &time_controller_);
// Base RTP overhead is 12B.
EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u);
@@ -2094,11 +2146,12 @@
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<RtpSenderContext>(config);
+ rtp_sender_context_ =
+ std::make_unique<RtpSenderContext>(config, &time_controller_);
// Base RTP overhead is 12B.
EXPECT_EQ(rtp_sender()->ExpectedPerPacketOverhead(), 12u);
@@ -2118,93 +2171,93 @@
TEST_P(RtpSenderTest, SendPacketMatchesVideo) {
std::unique_ptr<RtpPacketToSend> 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<RtpPacketToSend> 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<RtpPacketToSend> 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<RtpPacketToSend> 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<RtpPacketToSend> 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<RtpPacketToSend> 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 @@
// Build a media packet and send it.
std::unique_ptr<RtpPacketToSend> 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 @@
0);
std::unique_ptr<RtpPacketToSend> 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<TransmissionOffset>(), kDiffMs * 90);
EXPECT_EQ(received_packet.GetExtension<AbsoluteSendTime>(),
- AbsoluteSendTime::MsTo24Bits(fake_clock_.TimeInMilliseconds()));
+ AbsoluteSendTime::MsTo24Bits(clock_->TimeInMilliseconds()));
VideoSendTiming timing;
EXPECT_TRUE(received_packet.GetExtension<VideoTimingExtension>(&timing));
@@ -2289,12 +2343,12 @@
kTransportSequenceNumberExtensionId),
0);
std::unique_ptr<RtpPacketToSend> packet =
- BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
+ BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
packet->SetExtension<TransportSequenceNumber>(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 @@
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<TransportSequenceNumber>(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 @@
StrictMock<MockSendSideDelayObserver> 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 @@
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<RtpSenderContext>(config);
+ rtp_sender_context_ =
+ std::make_unique<RtpSenderContext>(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<RtpPacketToSend> 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<TransportSequenceNumber>(1);
std::unique_ptr<RtpPacketToSend> 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<TransportSequenceNumber>(2);
std::unique_ptr<RtpPacketToSend> 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<TransportSequenceNumber>(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 @@
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 @@
// Send a payload packet first, to enable padding and populate the packet
// history.
std::unique_ptr<RtpPacketToSend> 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<std::unique_ptr<RtpPacketToSend>> generated_packets =
@@ -2421,7 +2474,8 @@
EXPECT_TRUE(plain_padding->HasExtension<TransmissionOffset>());
// 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<TransportSequenceNumber>());
EXPECT_TRUE(sent_plain_padding.HasExtension<AbsoluteSendTime>());
@@ -2442,7 +2496,8 @@
EXPECT_TRUE(payload_padding->HasExtension<TransmissionOffset>());
// 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<TransportSequenceNumber>());
EXPECT_TRUE(sent_payload_padding.HasExtension<AbsoluteSendTime>());
@@ -2468,14 +2523,14 @@
const size_t kPayloadPacketSize = kMinPaddingSize;
std::unique_ptr<RtpPacketToSend> 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 @@
// Send a dummy video packet so it ends up in the packet history.
const size_t kPayloadPacketSize = 1234u;
std::unique_ptr<RtpPacketToSend> 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 @@
// 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<RtpPacketToSend> 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 @@
EXPECT_TRUE(packet->HasExtension<TransmissionOffset>());
// 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 @@
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<TransmissionOffset>();
- packet->AllocatePayload(sizeof(kPayloadData));
+ auto packet =
+ BuildRtpPacket(kPayload, kMarkerBit, clock_->TimeInMilliseconds(),
+ kMissingCaptureTimeMs);
+ packet->set_packet_type(RtpPacketMediaType::kVideo);
+ packet->ReserveExtension<TransmissionOffset>();
+ packet->AllocatePayload(sizeof(kPayloadData));
- std::unique_ptr<RtpPacketToSend> packet_to_pace;
- EXPECT_CALL(mock_paced_sender_, EnqueuePackets)
- .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
- EXPECT_EQ(packets.size(), 1u);
- EXPECT_GT(packets[0]->capture_time_ms(), 0);
- packet_to_pace = std::move(packets[0]);
- });
+ std::unique_ptr<RtpPacketToSend> packet_to_pace;
+ EXPECT_CALL(mock_paced_sender_, EnqueuePackets)
+ .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> 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<int32_t> transmission_time_extension =
- transport_.sent_packets_.back().GetExtension<TransmissionOffset>();
- ASSERT_TRUE(transmission_time_extension.has_value());
- EXPECT_EQ(*transmission_time_extension, kOffsetMs * kTimestampTicksPerMs);
+ EXPECT_EQ(1, transport_.packets_sent());
+ absl::optional<int32_t> transmission_time_extension =
+ transport_.sent_packets_.back().GetExtension<TransmissionOffset>();
+ 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<RtpPacketToSend> rtx_packet_to_pace;
- EXPECT_CALL(mock_paced_sender_, EnqueuePackets)
- .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
- EXPECT_GT(packets[0]->capture_time_ms(), 0);
- rtx_packet_to_pace = std::move(packets[0]);
- });
+ std::unique_ptr<RtpPacketToSend> rtx_packet_to_pace;
+ EXPECT_CALL(mock_paced_sender_, EnqueuePackets)
+ .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> 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<TransmissionOffset>();
- 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<TransmissionOffset>();
+ ASSERT_TRUE(transmission_time_extension.has_value());
+ EXPECT_EQ(*transmission_time_extension, 2 * kOffsetMs * kTimestampTicksPerMs);
}
TEST_P(RtpSenderTestWithoutPacer, ClearHistoryOnSequenceNumberCange) {
@@ -2730,13 +2786,13 @@
// 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 @@
});
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);
}
