From 075349f039f12302c4afc4a38fa44232cbed66af Mon Sep 17 00:00:00 2001 From: Xinyu Ma Date: Fri, 2 Aug 2024 10:29:09 -0700 Subject: [PATCH] Pass Environment into FlexfecSender MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit To make it available for FEC to use field trials in follow ups Bug: webrtc:355577231 Change-Id: Ie0b7761915696e6ee7453df3d0531b0f7ad30ee1 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/358240 Reviewed-by: Danil Chapovalov Commit-Queue: Danil Chapovalov Reviewed-by: Åsa Persson Cr-Commit-Position: refs/heads/main@{#42732} --- call/rtp_video_sender.cc | 4 +- modules/rtp_rtcp/BUILD.gn | 3 + modules/rtp_rtcp/include/flexfec_sender.h | 10 +- modules/rtp_rtcp/source/flexfec_sender.cc | 20 +-- .../source/flexfec_sender_unittest.cc | 118 ++++++++++-------- .../source/rtp_rtcp_impl2_unittest.cc | 51 ++++---- .../source/rtp_sender_egress_unittest.cc | 14 ++- .../rtp_rtcp/source/rtp_sender_unittest.cc | 91 +++++++------- test/fuzzers/BUILD.gn | 2 + test/fuzzers/flexfec_sender_fuzzer.cc | 17 ++- 10 files changed, 180 insertions(+), 150 deletions(-) diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc index 0eb639552e..5d8c4bf947 100644 --- a/call/rtp_video_sender.cc +++ b/call/rtp_video_sender.cc @@ -168,9 +168,9 @@ std::unique_ptr MaybeCreateFecGenerator( RTC_DCHECK_EQ(1U, rtp.flexfec.protected_media_ssrcs.size()); return std::make_unique( - rtp.flexfec.payload_type, rtp.flexfec.ssrc, + env, rtp.flexfec.payload_type, rtp.flexfec.ssrc, rtp.flexfec.protected_media_ssrcs[0], rtp.mid, rtp.extensions, - RTPSender::FecExtensionSizes(), rtp_state, &env.clock()); + RTPSender::FecExtensionSizes(), rtp_state); } else if (rtp.ulpfec.red_payload_type >= 0 && rtp.ulpfec.ulpfec_payload_type >= 0 && !ShouldDisableRedAndUlpfec(/*flexfec_enabled=*/false, rtp, diff --git a/modules/rtp_rtcp/BUILD.gn b/modules/rtp_rtcp/BUILD.gn index a1f563bcc7..0892a32747 100644 --- a/modules/rtp_rtcp/BUILD.gn +++ b/modules/rtp_rtcp/BUILD.gn @@ -288,6 +288,7 @@ rtc_library("rtp_rtcp") { "../../api:transport_api", "../../api/audio_codecs:audio_codecs_api", "../../api/crypto:frame_encryptor_interface", + "../../api/environment:environment", "../../api/rtc_event_log", "../../api/task_queue:pending_task_safety_flag", "../../api/task_queue:task_queue", @@ -677,6 +678,8 @@ if (rtc_include_tests) { "../../api:scoped_refptr", "../../api:time_controller", "../../api:transport_api", + "../../api/environment:environment", + "../../api/environment:environment_factory", "../../api/rtc_event_log", "../../api/task_queue", "../../api/transport/rtp:dependency_descriptor", diff --git a/modules/rtp_rtcp/include/flexfec_sender.h b/modules/rtp_rtcp/include/flexfec_sender.h index 8f21ab7517..65ac0e946f 100644 --- a/modules/rtp_rtcp/include/flexfec_sender.h +++ b/modules/rtp_rtcp/include/flexfec_sender.h @@ -17,6 +17,7 @@ #include "absl/strings/string_view.h" #include "api/array_view.h" +#include "api/environment/environment.h" #include "api/rtp_parameters.h" #include "api/units/timestamp.h" #include "modules/rtp_rtcp/include/rtp_header_extension_map.h" @@ -30,7 +31,6 @@ namespace webrtc { -class Clock; class RtpPacketToSend; // Note that this class is not thread safe, and thus requires external @@ -38,14 +38,14 @@ class RtpPacketToSend; class FlexfecSender : public VideoFecGenerator { public: - FlexfecSender(int payload_type, + FlexfecSender(const Environment& env, + int payload_type, uint32_t ssrc, uint32_t protected_media_ssrc, absl::string_view mid, const std::vector& rtp_header_extensions, rtc::ArrayView extension_sizes, - const RtpState* rtp_state, - Clock* clock); + const RtpState* rtp_state); ~FlexfecSender(); FecType GetFecType() const override { @@ -76,7 +76,7 @@ class FlexfecSender : public VideoFecGenerator { private: // Utility. - Clock* const clock_; + const Environment env_; Random random_; Timestamp last_generated_packet_ = Timestamp::MinusInfinity(); diff --git a/modules/rtp_rtcp/source/flexfec_sender.cc b/modules/rtp_rtcp/source/flexfec_sender.cc index 3a98778d16..d44b3bc750 100644 --- a/modules/rtp_rtcp/source/flexfec_sender.cc +++ b/modules/rtp_rtcp/source/flexfec_sender.cc @@ -16,6 +16,7 @@ #include #include "absl/strings/string_view.h" +#include "api/environment/environment.h" #include "api/units/time_delta.h" #include "api/units/timestamp.h" #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" @@ -71,16 +72,16 @@ RtpHeaderExtensionMap RegisterSupportedExtensions( } // namespace FlexfecSender::FlexfecSender( + const Environment& env, int payload_type, uint32_t ssrc, uint32_t protected_media_ssrc, absl::string_view mid, const std::vector& rtp_header_extensions, rtc::ArrayView extension_sizes, - const RtpState* rtp_state, - Clock* clock) - : clock_(clock), - random_(clock_->TimeInMicroseconds()), + const RtpState* rtp_state) + : env_(env), + random_(env_.clock().TimeInMicroseconds()), payload_type_(payload_type), // Reset RTP state if this is not the first time we are operating. // Otherwise, randomize the initial timestamp offset and RTP sequence @@ -94,7 +95,7 @@ FlexfecSender::FlexfecSender( : random_.Rand(1, kMaxInitRtpSeqNumber)), ulpfec_generator_( ForwardErrorCorrection::CreateFlexfec(ssrc, protected_media_ssrc), - clock_), + &env_.clock()), rtp_header_extension_map_( RegisterSupportedExtensions(rtp_header_extensions)), header_extensions_size_( @@ -141,10 +142,10 @@ std::vector> FlexfecSender::GetFecPackets() { fec_packet_to_send->SetTimestamp( timestamp_offset_ + static_cast(kMsToRtpTimestamp * - clock_->TimeInMilliseconds())); + env_.clock().TimeInMilliseconds())); // Set "capture time" so that the TransmissionOffset header extension // can be set by the RTPSender. - fec_packet_to_send->set_capture_time(clock_->CurrentTime()); + fec_packet_to_send->set_capture_time(env_.clock().CurrentTime()); fec_packet_to_send->SetSsrc(ssrc_); // Reserve extensions, if registered. These will be set by the RTPSender. fec_packet_to_send->ReserveExtension(); @@ -169,7 +170,7 @@ std::vector> FlexfecSender::GetFecPackets() { ulpfec_generator_.ResetState(); } - Timestamp now = clock_->CurrentTime(); + Timestamp now = env_.clock().CurrentTime(); if (!fec_packets_to_send.empty() && now - last_generated_packet_ > kPacketLogInterval) { RTC_LOG(LS_VERBOSE) << "Generated " << fec_packets_to_send.size() @@ -191,7 +192,8 @@ size_t FlexfecSender::MaxPacketOverhead() const { DataRate FlexfecSender::CurrentFecRate() const { MutexLock lock(&mutex_); - return fec_bitrate_.Rate(clock_->CurrentTime()).value_or(DataRate::Zero()); + return fec_bitrate_.Rate(env_.clock().CurrentTime()) + .value_or(DataRate::Zero()); } absl::optional FlexfecSender::GetRtpState() { diff --git a/modules/rtp_rtcp/source/flexfec_sender_unittest.cc b/modules/rtp_rtcp/source/flexfec_sender_unittest.cc index 19614d2bbd..3d46ee3be8 100644 --- a/modules/rtp_rtcp/source/flexfec_sender_unittest.cc +++ b/modules/rtp_rtcp/source/flexfec_sender_unittest.cc @@ -12,6 +12,8 @@ #include +#include "api/environment/environment.h" +#include "api/environment/environment_factory.h" #include "api/rtp_parameters.h" #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "modules/rtp_rtcp/source/fec_test_helper.h" @@ -83,27 +85,30 @@ std::unique_ptr GenerateSingleFlexfecPacket( TEST(FlexfecSenderTest, Ssrc) { SimulatedClock clock(kInitialSimulatedClockTime); - FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid, - kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, - nullptr /* rtp_state */, &clock); + const Environment env = CreateEnvironment(&clock); + FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, + kNoMid, kNoRtpHeaderExtensions, + kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */); EXPECT_EQ(kFlexfecSsrc, sender.FecSsrc()); } TEST(FlexfecSenderTest, NoFecAvailableBeforeMediaAdded) { SimulatedClock clock(kInitialSimulatedClockTime); - FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid, - kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, - nullptr /* rtp_state */, &clock); + const Environment env = CreateEnvironment(&clock); + FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, + kNoMid, kNoRtpHeaderExtensions, + kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */); EXPECT_TRUE(sender.GetFecPackets().empty()); } TEST(FlexfecSenderTest, ProtectOneFrameWithOneFecPacket) { SimulatedClock clock(kInitialSimulatedClockTime); - FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid, - kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, - nullptr /* rtp_state */, &clock); + const Environment env = CreateEnvironment(&clock); + FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, + kNoMid, kNoRtpHeaderExtensions, + kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */); auto fec_packet = GenerateSingleFlexfecPacket(&sender); EXPECT_EQ(kRtpHeaderSize, fec_packet->headers_size()); @@ -116,6 +121,8 @@ TEST(FlexfecSenderTest, ProtectOneFrameWithOneFecPacket) { } TEST(FlexfecSenderTest, ProtectTwoFramesWithOneFecPacket) { + SimulatedClock clock(kInitialSimulatedClockTime); + const Environment env = CreateEnvironment(&clock); // FEC parameters selected to generate a single FEC packet per frame. FecProtectionParams params; params.fec_rate = 15; @@ -123,10 +130,9 @@ TEST(FlexfecSenderTest, ProtectTwoFramesWithOneFecPacket) { params.fec_mask_type = kFecMaskRandom; constexpr size_t kNumFrames = 2; constexpr size_t kNumPacketsPerFrame = 2; - SimulatedClock clock(kInitialSimulatedClockTime); - FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid, - kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, - nullptr /* rtp_state */, &clock); + FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, + kNoMid, kNoRtpHeaderExtensions, + kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */); sender.SetProtectionParameters(params, params); AugmentedPacketGenerator packet_generator(kMediaSsrc); @@ -155,6 +161,8 @@ TEST(FlexfecSenderTest, ProtectTwoFramesWithOneFecPacket) { } TEST(FlexfecSenderTest, ProtectTwoFramesWithTwoFecPackets) { + SimulatedClock clock(kInitialSimulatedClockTime); + const Environment env = CreateEnvironment(&clock); // FEC parameters selected to generate a single FEC packet per frame. FecProtectionParams params; params.fec_rate = 30; @@ -162,10 +170,9 @@ TEST(FlexfecSenderTest, ProtectTwoFramesWithTwoFecPackets) { params.fec_mask_type = kFecMaskRandom; constexpr size_t kNumFrames = 2; constexpr size_t kNumPacketsPerFrame = 2; - SimulatedClock clock(kInitialSimulatedClockTime); - FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid, - kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, - nullptr /* rtp_state */, &clock); + FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, + kNoMid, kNoRtpHeaderExtensions, + kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */); sender.SetProtectionParameters(params, params); AugmentedPacketGenerator packet_generator(kMediaSsrc); @@ -196,11 +203,12 @@ TEST(FlexfecSenderTest, ProtectTwoFramesWithTwoFecPackets) { // In the tests, we only consider RTP header extensions that are useful for BWE. TEST(FlexfecSenderTest, NoRtpHeaderExtensionsForBweByDefault) { - const std::vector kRtpHeaderExtensions{}; SimulatedClock clock(kInitialSimulatedClockTime); - FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid, - kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, - nullptr /* rtp_state */, &clock); + const Environment env = CreateEnvironment(&clock); + const std::vector kRtpHeaderExtensions{}; + FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, + kNoMid, kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, + nullptr /* rtp_state */); auto fec_packet = GenerateSingleFlexfecPacket(&sender); EXPECT_FALSE(fec_packet->HasExtension()); @@ -209,12 +217,13 @@ TEST(FlexfecSenderTest, NoRtpHeaderExtensionsForBweByDefault) { } TEST(FlexfecSenderTest, RegisterAbsoluteSendTimeRtpHeaderExtension) { + SimulatedClock clock(kInitialSimulatedClockTime); + const Environment env = CreateEnvironment(&clock); const std::vector kRtpHeaderExtensions{ {RtpExtension::kAbsSendTimeUri, 1}}; - SimulatedClock clock(kInitialSimulatedClockTime); - FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid, - kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, - nullptr /* rtp_state */, &clock); + FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, + kNoMid, kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, + nullptr /* rtp_state */); auto fec_packet = GenerateSingleFlexfecPacket(&sender); EXPECT_TRUE(fec_packet->HasExtension()); @@ -223,12 +232,13 @@ TEST(FlexfecSenderTest, RegisterAbsoluteSendTimeRtpHeaderExtension) { } TEST(FlexfecSenderTest, RegisterTransmissionOffsetRtpHeaderExtension) { + SimulatedClock clock(kInitialSimulatedClockTime); + const Environment env = CreateEnvironment(&clock); const std::vector kRtpHeaderExtensions{ {RtpExtension::kTimestampOffsetUri, 1}}; - SimulatedClock clock(kInitialSimulatedClockTime); - FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid, - kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, - nullptr /* rtp_state */, &clock); + FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, + kNoMid, kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, + nullptr /* rtp_state */); auto fec_packet = GenerateSingleFlexfecPacket(&sender); EXPECT_FALSE(fec_packet->HasExtension()); @@ -237,12 +247,13 @@ TEST(FlexfecSenderTest, RegisterTransmissionOffsetRtpHeaderExtension) { } TEST(FlexfecSenderTest, RegisterTransportSequenceNumberRtpHeaderExtension) { + SimulatedClock clock(kInitialSimulatedClockTime); + const Environment env = CreateEnvironment(&clock); const std::vector kRtpHeaderExtensions{ {RtpExtension::kTransportSequenceNumberUri, 1}}; - SimulatedClock clock(kInitialSimulatedClockTime); - FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid, - kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, - nullptr /* rtp_state */, &clock); + FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, + kNoMid, kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, + nullptr /* rtp_state */); auto fec_packet = GenerateSingleFlexfecPacket(&sender); EXPECT_FALSE(fec_packet->HasExtension()); @@ -251,14 +262,15 @@ TEST(FlexfecSenderTest, RegisterTransportSequenceNumberRtpHeaderExtension) { } TEST(FlexfecSenderTest, RegisterAllRtpHeaderExtensionsForBwe) { + SimulatedClock clock(kInitialSimulatedClockTime); + const Environment env = CreateEnvironment(&clock); const std::vector kRtpHeaderExtensions{ {RtpExtension::kAbsSendTimeUri, 1}, {RtpExtension::kTimestampOffsetUri, 2}, {RtpExtension::kTransportSequenceNumberUri, 3}}; - SimulatedClock clock(kInitialSimulatedClockTime); - FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid, - kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, - nullptr /* rtp_state */, &clock); + FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, + kNoMid, kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, + nullptr /* rtp_state */); auto fec_packet = GenerateSingleFlexfecPacket(&sender); EXPECT_TRUE(fec_packet->HasExtension()); @@ -268,19 +280,21 @@ TEST(FlexfecSenderTest, RegisterAllRtpHeaderExtensionsForBwe) { TEST(FlexfecSenderTest, MaxPacketOverhead) { SimulatedClock clock(kInitialSimulatedClockTime); - FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid, - kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, - nullptr /* rtp_state */, &clock); + const Environment env = CreateEnvironment(&clock); + FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, + kNoMid, kNoRtpHeaderExtensions, + kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */); EXPECT_EQ(kFlexfecMaxHeaderSize, sender.MaxPacketOverhead()); } TEST(FlexfecSenderTest, MaxPacketOverheadWithExtensions) { + SimulatedClock clock(kInitialSimulatedClockTime); + const Environment env = CreateEnvironment(&clock); const std::vector kRtpHeaderExtensions{ {RtpExtension::kAbsSendTimeUri, 1}, {RtpExtension::kTimestampOffsetUri, 2}, {RtpExtension::kTransportSequenceNumberUri, 3}}; - SimulatedClock clock(kInitialSimulatedClockTime); const size_t kExtensionHeaderLength = 1; const size_t kRtpOneByteHeaderLength = 4; const size_t kExtensionsTotalSize = @@ -288,22 +302,23 @@ TEST(FlexfecSenderTest, MaxPacketOverheadWithExtensions) { AbsoluteSendTime::kValueSizeBytes + kExtensionHeaderLength + TransmissionOffset::kValueSizeBytes + kExtensionHeaderLength + TransportSequenceNumber::kValueSizeBytes); - FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid, - kRtpHeaderExtensions, RTPSender::FecExtensionSizes(), - nullptr /* rtp_state */, &clock); + FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, + kNoMid, kRtpHeaderExtensions, + RTPSender::FecExtensionSizes(), nullptr /* rtp_state */); EXPECT_EQ(kExtensionsTotalSize + kFlexfecMaxHeaderSize, sender.MaxPacketOverhead()); } TEST(FlexfecSenderTest, MidIncludedInPacketsWhenSet) { + SimulatedClock clock(kInitialSimulatedClockTime); + const Environment env = CreateEnvironment(&clock); const std::vector kRtpHeaderExtensions{ {RtpExtension::kMidUri, 1}}; const char kMid[] = "mid"; - SimulatedClock clock(kInitialSimulatedClockTime); - FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kMid, + FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kMid, kRtpHeaderExtensions, RTPSender::FecExtensionSizes(), - nullptr /* rtp_state */, &clock); + nullptr /* rtp_state */); auto fec_packet = GenerateSingleFlexfecPacket(&sender); @@ -313,13 +328,14 @@ TEST(FlexfecSenderTest, MidIncludedInPacketsWhenSet) { } TEST(FlexfecSenderTest, SetsAndGetsRtpState) { + SimulatedClock clock(kInitialSimulatedClockTime); + const Environment env = CreateEnvironment(&clock); RtpState initial_rtp_state; initial_rtp_state.sequence_number = 100; initial_rtp_state.start_timestamp = 200; - SimulatedClock clock(kInitialSimulatedClockTime); - FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid, - kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, - &initial_rtp_state, &clock); + FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, + kNoMid, kNoRtpHeaderExtensions, + kNoRtpHeaderExtensionSizes, &initial_rtp_state); auto fec_packet = GenerateSingleFlexfecPacket(&sender); EXPECT_EQ(initial_rtp_state.sequence_number, fec_packet->SequenceNumber()); diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc index 6dd6ae8684..d8085c2a79 100644 --- a/modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc @@ -17,6 +17,8 @@ #include #include "absl/types/optional.h" +#include "api/environment/environment.h" +#include "api/environment/environment_factory.h" #include "api/field_trials_registry.h" #include "api/units/time_delta.h" #include "modules/rtp_rtcp/include/rtp_header_extension_map.h" @@ -30,7 +32,6 @@ #include "rtc_base/logging.h" #include "rtc_base/rate_limiter.h" #include "rtc_base/strings/string_builder.h" -#include "test/explicit_key_value_config.h" #include "test/gmock.h" #include "test/gtest.h" #include "test/rtcp_packet_parser.h" @@ -46,8 +47,6 @@ using ::testing::Not; using ::testing::Optional; using ::testing::SizeIs; -using webrtc::test::ExplicitKeyValueConfig; - namespace webrtc { namespace { constexpr uint32_t kSenderSsrc = 0x12345; @@ -170,21 +169,18 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver, uint32_t ssrc; }; - RtpRtcpModule(GlobalSimulatedTimeController* time_controller, - bool is_sender, - const FieldTrialsRegistry& trials) - : time_controller_(time_controller), + RtpRtcpModule(const Environment& env, + GlobalSimulatedTimeController* time_controller, + bool is_sender) + : env_(env), is_sender_(is_sender), - trials_(trials), - receive_statistics_( - ReceiveStatistics::Create(time_controller->GetClock())), + receive_statistics_(ReceiveStatistics::Create(&env.clock())), transport_(kOneWayNetworkDelay, time_controller) { CreateModuleImpl(); } - TimeController* const time_controller_; + const Environment env_; const bool is_sender_; - const FieldTrialsRegistry& trials_; RtcpPacketTypeCounter packets_sent_; RtcpPacketTypeCounter packets_received_; std::unique_ptr receive_statistics_; @@ -242,7 +238,7 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver, void CreateModuleImpl() { RtpRtcpInterface::Configuration config; config.audio = false; - config.clock = time_controller_->GetClock(); + config.clock = &env_.clock(); config.outgoing_transport = &transport_; config.receive_statistics = receive_statistics_.get(); config.rtcp_packet_type_counter_observer = this; @@ -253,7 +249,7 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver, is_sender_ ? absl::make_optional(kRtxSenderSsrc) : absl::nullopt; config.need_rtp_packet_infos = true; config.non_sender_rtt_measurement = true; - config.field_trials = &trials_; + config.field_trials = &env_.field_trials(); config.send_packet_observer = this; config.fec_generator = fec_generator_; impl_.reset(new ModuleRtpRtcpImpl2(config)); @@ -273,13 +269,14 @@ class RtpRtcpImpl2Test : public ::testing::Test { protected: RtpRtcpImpl2Test() : time_controller_(Timestamp::Micros(133590000000000)), - field_trials_(""), - sender_(&time_controller_, - /*is_sender=*/true, - field_trials_), - receiver_(&time_controller_, - /*is_sender=*/false, - field_trials_) {} + env_(CreateEnvironment(time_controller_.GetClock(), + time_controller_.CreateTaskQueueFactory())), + sender_(env_, + &time_controller_, + /*is_sender=*/true), + receiver_(env_, + &time_controller_, + /*is_sender=*/false) {} void SetUp() override { // Send module. @@ -291,7 +288,7 @@ class RtpRtcpImpl2Test : public ::testing::Test { RTPSenderVideo::Config video_config; video_config.clock = time_controller_.GetClock(); video_config.rtp_sender = sender_.impl_->RtpSender(); - video_config.field_trials = &field_trials_; + video_config.field_trials = &env_.field_trials(); sender_video_ = std::make_unique(video_config); // Receive module. @@ -318,7 +315,7 @@ class RtpRtcpImpl2Test : public ::testing::Test { RTPSenderVideo::Config video_config; video_config.clock = time_controller_.GetClock(); video_config.rtp_sender = sender_.impl_->RtpSender(); - video_config.field_trials = &field_trials_; + video_config.field_trials = &env_.field_trials(); video_config.fec_overhead_bytes = fec_generator->MaxPacketOverhead(); video_config.fec_type = fec_generator->GetFecType(); video_config.red_payload_type = red_payload_type; @@ -326,7 +323,7 @@ class RtpRtcpImpl2Test : public ::testing::Test { } GlobalSimulatedTimeController time_controller_; - test::ExplicitKeyValueConfig field_trials_; + const Environment env_; RtpRtcpModule sender_; std::unique_ptr sender_video_; RtpRtcpModule receiver_; @@ -1008,9 +1005,9 @@ TEST_F(RtpRtcpImpl2Test, GeneratesFlexfec) { const uint16_t fec_start_seq = sender_.impl_->SequenceNumber() + 100; RtpState start_state; start_state.sequence_number = fec_start_seq; - FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kSenderSsrc, - kNoMid, kNoRtpExtensions, kNoRtpExtensionSizes, - &start_state, time_controller_.GetClock()); + FlexfecSender flexfec_sender(env_, kFlexfecPayloadType, kFlexfecSsrc, + kSenderSsrc, kNoMid, kNoRtpExtensions, + kNoRtpExtensionSizes, &start_state); ReinitWithFec(&flexfec_sender, /*red_payload_type=*/absl::nullopt); // Parameters selected to generate a single FEC packet per media packet. diff --git a/modules/rtp_rtcp/source/rtp_sender_egress_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_egress_unittest.cc index b833b65ed3..18356274e1 100644 --- a/modules/rtp_rtcp/source/rtp_sender_egress_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_sender_egress_unittest.cc @@ -16,6 +16,8 @@ #include "absl/types/optional.h" #include "api/array_view.h" #include "api/call/transport.h" +#include "api/environment/environment.h" +#include "api/environment/environment_factory.h" #include "api/field_trials_registry.h" #include "api/units/data_size.h" #include "api/units/timestamp.h" @@ -27,7 +29,6 @@ #include "modules/rtp_rtcp/source/rtp_packet_history.h" #include "modules/rtp_rtcp/source/rtp_packet_received.h" #include "modules/rtp_rtcp/source/rtp_packet_to_send.h" -#include "test/explicit_key_value_config.h" #include "test/gmock.h" #include "test/gtest.h" #include "test/time_controller/simulated_time_controller.h" @@ -115,11 +116,11 @@ class RtpSenderEgressTest : public ::testing::Test { protected: RtpSenderEgressTest() : time_controller_(kStartTime), + env_(CreateEnvironment(time_controller_.GetClock())), clock_(time_controller_.GetClock()), transport_(&header_extensions_), packet_history_(clock_, RtpPacketHistory::PaddingMode::kRecentLargePacket), - trials_(""), sequence_number_(kStartSequenceNumber) {} std::unique_ptr CreateRtpSenderEgress() { @@ -138,7 +139,7 @@ class RtpSenderEgressTest : public ::testing::Test { config.send_packet_observer = &send_packet_observer_; config.rtp_stats_callback = &mock_rtp_stats_callback_; config.populate_network2_timestamp = false; - config.field_trials = &trials_; + config.field_trials = &env_.field_trials(); return config; } @@ -164,6 +165,7 @@ class RtpSenderEgressTest : public ::testing::Test { } GlobalSimulatedTimeController time_controller_; + const Environment env_; Clock* const clock_; NiceMock mock_rtc_event_log_; NiceMock mock_rtp_stats_callback_; @@ -171,7 +173,6 @@ class RtpSenderEgressTest : public ::testing::Test { RtpHeaderExtensionMap header_extensions_; NiceMock transport_; RtpPacketHistory packet_history_; - test::ExplicitKeyValueConfig trials_; uint16_t sequence_number_; }; @@ -837,9 +838,10 @@ TEST_F(RtpSenderEgressTest, SendPacketUpdatesStats) { const size_t kPayloadSize = 1000; const rtc::ArrayView kNoRtpHeaderExtensionSizes; - FlexfecSender flexfec(kFlexfectPayloadType, kFlexFecSsrc, kSsrc, /*mid=*/"", + FlexfecSender flexfec(env_, kFlexfectPayloadType, kFlexFecSsrc, kSsrc, + /*mid=*/"", /*header_extensions=*/{}, kNoRtpHeaderExtensionSizes, - /*rtp_state=*/nullptr, time_controller_.GetClock()); + /*rtp_state=*/nullptr); RtpRtcpInterface::Configuration config = DefaultConfig(); config.fec_generator = &flexfec; auto sender = std::make_unique(config, &packet_history_); diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc index 8586f4b960..80ca3195a2 100644 --- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc @@ -14,6 +14,8 @@ #include #include "absl/strings/string_view.h" +#include "api/environment/environment.h" +#include "api/environment/environment_factory.h" #include "api/rtc_event_log/rtc_event.h" #include "api/rtp_packet_sender.h" #include "api/units/frequency.h" @@ -38,7 +40,6 @@ #include "rtc_base/logging.h" #include "rtc_base/rate_limiter.h" #include "rtc_base/strings/string_builder.h" -#include "test/explicit_key_value_config.h" #include "test/gmock.h" #include "test/gtest.h" #include "test/mock_transport.h" @@ -116,16 +117,16 @@ class RtpSenderTest : public ::testing::Test { protected: RtpSenderTest() : time_controller_(Timestamp::Millis(kStartTime)), - clock_(time_controller_.GetClock()), - retransmission_rate_limiter_(clock_, 1000), - flexfec_sender_(0, + env_(CreateEnvironment(time_controller_.GetClock())), + retransmission_rate_limiter_(&env_.clock(), 1000), + flexfec_sender_(env_, + 0, kFlexFecSsrc, kSsrc, "", std::vector(), std::vector(), - nullptr, - clock_) {} + nullptr) {} void SetUp() override { SetUpRtpSender(true, false, nullptr); } @@ -141,13 +142,13 @@ class RtpSenderTest : public ::testing::Test { RtpRtcpInterface::Configuration GetDefaultConfig() { RtpRtcpInterface::Configuration config; - config.clock = clock_; + config.clock = &env_.clock(); config.local_media_ssrc = kSsrc; config.rtx_send_ssrc = kRtxSsrc; config.event_log = &mock_rtc_event_log_; config.retransmission_rate_limiter = &retransmission_rate_limiter_; config.paced_sender = &mock_paced_sender_; - config.field_trials = &field_trials_; + config.field_trials = &env_.field_trials(); // Configure rid unconditionally, it has effect only if // corresponding header extension is enabled. config.rid = std::string(kRid); @@ -159,7 +160,7 @@ class RtpSenderTest : public ::testing::Test { config.clock, RtpPacketHistory::PaddingMode::kRecentLargePacket); sequencer_.emplace(kSsrc, kRtxSsrc, /*require_marker_before_media_padding=*/!config.audio, - clock_); + &env_.clock()); rtp_sender_ = std::make_unique(config, packet_history_.get(), config.paced_sender); sequencer_->set_media_sequence_number(kSeqNum); @@ -167,7 +168,7 @@ class RtpSenderTest : public ::testing::Test { } GlobalSimulatedTimeController time_controller_; - Clock* const clock_; + const Environment env_; NiceMock mock_rtc_event_log_; MockRtpPacketPacer mock_paced_sender_; RateLimiter retransmission_rate_limiter_; @@ -177,8 +178,6 @@ class RtpSenderTest : public ::testing::Test { std::unique_ptr packet_history_; std::unique_ptr rtp_sender_; - const test::ExplicitKeyValueConfig field_trials_{""}; - std::unique_ptr BuildRtpPacket(int payload_type, bool marker_bit, uint32_t rtp_timestamp, @@ -211,7 +210,7 @@ class RtpSenderTest : public ::testing::Test { // Use maximum allowed size to catch corner cases when packet is dropped // because of lack of capacity for the media packet, or for an rtx packet // containing the media packet. - return SendPacket(/*capture_time=*/clock_->CurrentTime(), + return SendPacket(/*capture_time=*/env_.clock().CurrentTime(), /*payload_length=*/rtp_sender_->MaxRtpPacketSize() - rtp_sender_->ExpectedPerPacketOverhead()); } @@ -345,7 +344,7 @@ TEST_F(RtpSenderTest, SendToNetworkForwardsPacketsToPacer) { std::vector> packets(1); packets[0] = BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, Timestamp::Zero()); - Timestamp now = clock_->CurrentTime(); + Timestamp now = env_.clock().CurrentTime(); EXPECT_CALL(mock_paced_sender_, EnqueuePackets(ElementsAre(AllOf( @@ -358,7 +357,7 @@ TEST_F(RtpSenderTest, SendToNetworkForwardsPacketsToPacer) { TEST_F(RtpSenderTest, ReSendPacketForwardsPacketsToPacer) { packet_history_->SetStorePacketsStatus( RtpPacketHistory::StorageMode::kStoreAndCull, 10); - Timestamp now = clock_->CurrentTime(); + Timestamp now = env_.clock().CurrentTime(); auto packet = BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, now); packet->SetSequenceNumber(kSeqNum); packet->set_allow_retransmission(true); @@ -380,7 +379,7 @@ TEST_F(RtpSenderTest, SendPadding) { constexpr int kNumPaddingPackets = 4; EXPECT_CALL(mock_paced_sender_, EnqueuePackets); std::unique_ptr media_packet = - SendPacket(/*capture_time=*/clock_->CurrentTime(), + SendPacket(/*capture_time=*/env_.clock().CurrentTime(), /*payload_size=*/100); sequencer_->Sequence(*media_packet); @@ -413,7 +412,7 @@ TEST_F(RtpSenderTest, SendPadding) { &RtpPacketToSend::Timestamp, Gt(media_packet->Timestamp())))))); std::unique_ptr next_media_packet = - SendPacket(/*capture_time=*/clock_->CurrentTime(), + SendPacket(/*capture_time=*/env_.clock().CurrentTime(), /*payload_size=*/100); } @@ -511,7 +510,7 @@ TEST_F(RtpSenderTest, AllowPaddingAsFirstPacketOnRtxWithAbsSendTime) { TEST_F(RtpSenderTest, UpdatesTimestampsOnPlainRtxPadding) { EnableRtx(); // Timestamps as set based on capture time in RtpSenderTest. - const Timestamp start_time = clock_->CurrentTime(); + const Timestamp start_time = env_.clock().CurrentTime(); const uint32_t start_timestamp = ToRtpTimestamp(start_time); // Start by sending one media packet. @@ -544,7 +543,7 @@ TEST_F(RtpSenderTest, KeepsTimestampsOnPayloadPadding) { TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId)); EnableRtx(); // Timestamps as set based on capture time in RtpSenderTest. - const Timestamp start_time = clock_->CurrentTime(); + const Timestamp start_time = env_.clock().CurrentTime(); const uint32_t start_timestamp = ToRtpTimestamp(start_time); const size_t kPayloadSize = 200; const size_t kRtxHeaderSize = 2; @@ -610,7 +609,7 @@ TEST_F(RtpSenderTest, RidIncludedOnRtxSentPackets) { .WillOnce([&](std::vector> packets) { sequencer_->Sequence(*packets[0]); packet_history_->PutRtpPacket(std::move(packets[0]), - clock_->CurrentTime()); + env_.clock().CurrentTime()); }); SendGenericPacket(); @@ -681,7 +680,7 @@ TEST_F(RtpSenderTest, MidAndRidIncludedOnFirstRtxPacket) { EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1))) .WillOnce([&](std::vector> packets) { packet_history_->PutRtpPacket(std::move(packets[0]), - clock_->CurrentTime()); + env_.clock().CurrentTime()); }); auto second_built_packet = SendGenericPacket(); @@ -707,7 +706,7 @@ TEST_F(RtpSenderTest, MidAndRidNotIncludedOnRtxPacketsAfterAck) { sequencer_->Sequence(*first_built_packet); packet_history_->PutRtpPacket( std::make_unique(*first_built_packet), - /*send_time=*/clock_->CurrentTime()); + /*send_time=*/env_.clock().CurrentTime()); rtp_sender_->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber()); // The second packet will include neither since an ack was received. @@ -715,7 +714,7 @@ TEST_F(RtpSenderTest, MidAndRidNotIncludedOnRtxPacketsAfterAck) { sequencer_->Sequence(*second_built_packet); packet_history_->PutRtpPacket( std::make_unique(*second_built_packet), - /*send_time=*/clock_->CurrentTime()); + /*send_time=*/env_.clock().CurrentTime()); // The first RTX packet will include MID and RRID. EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1))) @@ -753,7 +752,7 @@ TEST_F(RtpSenderTest, MidAndRidAlwaysIncludedOnRtxPacketsWhenConfigured) { .WillRepeatedly( [&](std::vector> packets) { packet_history_->PutRtpPacket(std::move(packets[0]), - clock_->CurrentTime()); + env_.clock().CurrentTime()); }); auto media_packet1 = SendGenericPacket(); rtp_sender_->OnReceivedAckOnSsrc(media_packet1->SequenceNumber()); @@ -815,7 +814,7 @@ TEST_F(RtpSenderTest, MidAndRridNotIncludedOnRtxPacketsAfterRtpStateRestored) { EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1))) .WillOnce([&](std::vector> packets) { packet_history_->PutRtpPacket(std::move(packets[0]), - clock_->CurrentTime()); + env_.clock().CurrentTime()); }); auto built_packet = SendGenericPacket(); @@ -837,12 +836,12 @@ TEST_F(RtpSenderTest, RespectsNackBitrateLimit) { for (int32_t i = 0; i < kNumPackets; ++i) { std::unique_ptr packet = BuildRtpPacket(kPayload, /*marker_bit=*/true, /*rtp_timestamp=*/0, - /*capture_time=*/clock_->CurrentTime()); + /*capture_time=*/env_.clock().CurrentTime()); packet->set_allow_retransmission(true); sequencer_->Sequence(*packet); sequence_numbers.push_back(packet->SequenceNumber()); packet_history_->PutRtpPacket(std::move(packet), - /*send_time=*/clock_->CurrentTime()); + /*send_time=*/env_.clock().CurrentTime()); time_controller_.AdvanceTime(TimeDelta::Millis(1)); } @@ -989,10 +988,10 @@ TEST_F(RtpSenderTest, SendPacketHandlesRetransmissionHistory) { // Build a media packet and put in the packet history. std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, clock_->CurrentTime()); + BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime()); const uint16_t media_sequence_number = packet->SequenceNumber(); packet->set_allow_retransmission(true); - packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime()); + packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime()); // Simulate successful retransmission request. time_controller_.AdvanceTime(TimeDelta::Millis(30)); @@ -1016,13 +1015,13 @@ TEST_F(RtpSenderTest, MarksRetransmittedPackets) { // Build a media packet and put in the packet history. std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, clock_->CurrentTime()); + BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime()); const uint32_t kMediaSsrc = 567; const uint16_t kMediaSequenceNumber = 123; packet->SetSsrc(kMediaSsrc); packet->SetSequenceNumber(kMediaSequenceNumber); packet->set_allow_retransmission(true); - packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime()); + packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime()); // Expect a retransmission packet marked with which packet it is a // retransmit of. @@ -1051,11 +1050,11 @@ TEST_F(RtpSenderTest, GeneratedPaddingHasBweExtensions) { // Put a packet in the history, in order to facilitate payload padding. std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, clock_->CurrentTime()); + BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime()); packet->set_allow_retransmission(true); packet->SetPayloadSize(kMinPaddingSize); packet->set_packet_type(RtpPacketMediaType::kVideo); - packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime()); + packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime()); // Generate a plain padding packet, check that extensions are registered. std::vector> generated_packets = @@ -1093,11 +1092,11 @@ TEST_F(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) { const size_t kPayloadPacketSize = kMinPaddingSize; std::unique_ptr packet = - BuildRtpPacket(kPayload, true, 0, clock_->CurrentTime()); + BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime()); packet->set_allow_retransmission(true); packet->SetPayloadSize(kPayloadPacketSize); packet->set_packet_type(RtpPacketMediaType::kVideo); - packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime()); + packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime()); // Generated padding has large enough budget that the video packet should be // retransmitted as padding. @@ -1142,11 +1141,11 @@ TEST_F(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, clock_->CurrentTime()); + BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime()); packet->set_allow_retransmission(true); packet->SetPayloadSize(kPayloadPacketSize); packet->set_packet_type(RtpPacketMediaType::kVideo); - packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime()); + packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime()); // Smallest target size that will result in the sent packet being returned as // padding. @@ -1182,12 +1181,12 @@ TEST_F(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, clock_->CurrentTime()); + BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime()); packet->set_allow_retransmission(true); packet->SetPayloadSize(kPayloadPacketSize); packet->set_packet_type(RtpPacketMediaType::kVideo); sequencer_->Sequence(*packet); - packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime()); + packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime()); // Payload padding not available without RTX, only generate plain padding on // the media SSRC. @@ -1258,7 +1257,7 @@ TEST_F(RtpSenderTest, SetsCaptureTimeOnRtxRetransmissions) { EnableRtx(); // Put a packet in the packet history, with current time as capture time. - const Timestamp start_time = clock_->CurrentTime(); + const Timestamp start_time = env_.clock().CurrentTime(); std::unique_ptr packet = BuildRtpPacket(kPayload, kMarkerBit, /*rtp_timestamp=*/0, /*capture_time=*/start_time); @@ -1283,7 +1282,7 @@ TEST_F(RtpSenderTest, IgnoresNackAfterDisablingMedia) { packet_history_->SetRtt(kRtt); // Put a packet in the history. - const Timestamp start_time = clock_->CurrentTime(); + const Timestamp start_time = env_.clock().CurrentTime(); std::unique_ptr packet = BuildRtpPacket(kPayload, kMarkerBit, 0, /*capture_time=*/start_time); packet->set_allow_retransmission(true); @@ -1307,7 +1306,7 @@ TEST_F(RtpSenderTest, DoesntFecProtectRetransmissions) { packet_history_->SetRtt(kRtt); // Put a fec protected packet in the history. - const Timestamp start_time = clock_->CurrentTime(); + const Timestamp start_time = env_.clock().CurrentTime(); std::unique_ptr packet = BuildRtpPacket(kPayload, kMarkerBit, 0, start_time); packet->set_allow_retransmission(true); @@ -1327,9 +1326,9 @@ TEST_F(RtpSenderTest, DoesntFecProtectRetransmissions) { TEST_F(RtpSenderTest, MarksPacketsWithKeyframeStatus) { RTPSenderVideo::Config video_config; - video_config.clock = clock_; + video_config.clock = &env_.clock(); video_config.rtp_sender = rtp_sender_.get(); - video_config.field_trials = &field_trials_; + video_config.field_trials = &env_.field_trials(); RTPSenderVideo rtp_sender_video(video_config); const uint8_t kPayloadType = 127; @@ -1345,7 +1344,7 @@ TEST_F(RtpSenderTest, MarksPacketsWithKeyframeStatus) { .Times(AtLeast(1)); RTPVideoHeader video_header; video_header.frame_type = VideoFrameType::kVideoFrameKey; - Timestamp capture_time = clock_->CurrentTime(); + Timestamp capture_time = env_.clock().CurrentTime(); EXPECT_TRUE(rtp_sender_video.SendVideo( kPayloadType, kCodecType, capture_time.ms() * kCaptureTimeMsToRtpTimestamp, capture_time, @@ -1362,7 +1361,7 @@ TEST_F(RtpSenderTest, MarksPacketsWithKeyframeStatus) { .Times(AtLeast(1)); RTPVideoHeader video_header; video_header.frame_type = VideoFrameType::kVideoFrameDelta; - Timestamp capture_time = clock_->CurrentTime(); + Timestamp capture_time = env_.clock().CurrentTime(); EXPECT_TRUE(rtp_sender_video.SendVideo( kPayloadType, kCodecType, capture_time.ms() * kCaptureTimeMsToRtpTimestamp, capture_time, diff --git a/test/fuzzers/BUILD.gn b/test/fuzzers/BUILD.gn index 16c7917909..7dbd9a1547 100644 --- a/test/fuzzers/BUILD.gn +++ b/test/fuzzers/BUILD.gn @@ -163,6 +163,8 @@ webrtc_fuzzer_test("flexfec_header_reader_fuzzer") { webrtc_fuzzer_test("flexfec_sender_fuzzer") { sources = [ "flexfec_sender_fuzzer.cc" ] deps = [ + "../../api/environment", + "../../api/environment:environment_factory", "../../modules/rtp_rtcp", "../../modules/rtp_rtcp:rtp_rtcp_format", "../../system_wrappers", diff --git a/test/fuzzers/flexfec_sender_fuzzer.cc b/test/fuzzers/flexfec_sender_fuzzer.cc index 8ddd1c0fe0..2c07fdf0b6 100644 --- a/test/fuzzers/flexfec_sender_fuzzer.cc +++ b/test/fuzzers/flexfec_sender_fuzzer.cc @@ -10,6 +10,8 @@ #include +#include "api/environment/environment.h" +#include "api/environment/environment_factory.h" #include "modules/rtp_rtcp/include/flexfec_sender.h" #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "modules/rtp_rtcp/source/byte_io.h" @@ -30,14 +32,21 @@ const std::vector kNoRtpHeaderExtensionSizes; } // namespace void FuzzOneInput(const uint8_t* data, size_t size) { + // Create Environment once because creating it for each input noticably + // reduces the speed of the fuzzer. + static SimulatedClock* const clock = new SimulatedClock(1); + static const Environment* const env = + new Environment(CreateEnvironment(clock)); + size_t i = 0; if (size < 5 || size > 200) { return; } - SimulatedClock clock(1 + data[i++]); - FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid, - kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes, - nullptr /* rtp_state */, &clock); + // Set time to (1 + data[i++]); + clock->AdvanceTimeMicroseconds(1 + data[i++] - clock->TimeInMicroseconds()); + FlexfecSender sender(*env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, + kNoMid, kNoRtpHeaderExtensions, + kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */); FecProtectionParams params = { data[i++], static_cast(data[i++] % 100), data[i++] <= 127 ? kFecMaskRandom : kFecMaskBursty};