Pass Environment into FlexfecSender

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 <danilchap@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#42732}

call/rtp_video_sender.cc

@@ -168,9 +168,9 @@ std::unique_ptr<VideoFecGenerator> MaybeCreateFecGenerator(
 
     RTC_DCHECK_EQ(1U, rtp.flexfec.protected_media_ssrcs.size());
     return std::make_unique<FlexfecSender>(
-        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,

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",

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<RtpExtension>& rtp_header_extensions,
                 rtc::ArrayView<const RtpExtensionSize> extension_sizes,
-                const RtpState* rtp_state,
+                const RtpState* rtp_state);
-                Clock* clock);
   ~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();
 

modules/rtp_rtcp/source/flexfec_sender.cc

@@ -16,6 +16,7 @@
 #include <utility>
 
 #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<RtpExtension>& rtp_header_extensions,
     rtc::ArrayView<const RtpExtensionSize> extension_sizes,
-    const RtpState* rtp_state,
+    const RtpState* rtp_state)
-    Clock* clock)
+    : env_(env),
-    : clock_(clock),
+      random_(env_.clock().TimeInMicroseconds()),
-      random_(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<std::unique_ptr<RtpPacketToSend>> FlexfecSender::GetFecPackets() {
     fec_packet_to_send->SetTimestamp(
         timestamp_offset_ +
         static_cast<uint32_t>(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<AbsoluteSendTime>();
@@ -169,7 +170,7 @@ std::vector<std::unique_ptr<RtpPacketToSend>> 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<RtpState> FlexfecSender::GetRtpState() {

modules/rtp_rtcp/source/flexfec_sender_unittest.cc

@@ -12,6 +12,8 @@
 
 #include <vector>
 
+#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<RtpPacketToSend> GenerateSingleFlexfecPacket(
 
 TEST(FlexfecSenderTest, Ssrc) {
   SimulatedClock clock(kInitialSimulatedClockTime);
-  FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
+  const Environment env = CreateEnvironment(&clock);
-                       kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
+  FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-                       nullptr /* rtp_state */, &clock);
+                       kNoMid, kNoRtpHeaderExtensions,
+                       kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */);
 
   EXPECT_EQ(kFlexfecSsrc, sender.FecSsrc());
 }
 
 TEST(FlexfecSenderTest, NoFecAvailableBeforeMediaAdded) {
   SimulatedClock clock(kInitialSimulatedClockTime);
-  FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
+  const Environment env = CreateEnvironment(&clock);
-                       kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
+  FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-                       nullptr /* rtp_state */, &clock);
+                       kNoMid, kNoRtpHeaderExtensions,
+                       kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */);
 
   EXPECT_TRUE(sender.GetFecPackets().empty());
 }
 
 TEST(FlexfecSenderTest, ProtectOneFrameWithOneFecPacket) {
   SimulatedClock clock(kInitialSimulatedClockTime);
-  FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
+  const Environment env = CreateEnvironment(&clock);
-                       kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
+  FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-                       nullptr /* rtp_state */, &clock);
+                       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(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-  FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
+                       kNoMid, kNoRtpHeaderExtensions,
-                       kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
+                       kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */);
-                       nullptr /* rtp_state */, &clock);
   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(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-  FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
+                       kNoMid, kNoRtpHeaderExtensions,
-                       kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
+                       kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */);
-                       nullptr /* rtp_state */, &clock);
   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<RtpExtension> kRtpHeaderExtensions{};
   SimulatedClock clock(kInitialSimulatedClockTime);
-  FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
+  const Environment env = CreateEnvironment(&clock);
-                       kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
+  const std::vector<RtpExtension> kRtpHeaderExtensions{};
-                       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<AbsoluteSendTime>());
@@ -209,12 +217,13 @@ TEST(FlexfecSenderTest, NoRtpHeaderExtensionsForBweByDefault) {
 }
 
 TEST(FlexfecSenderTest, RegisterAbsoluteSendTimeRtpHeaderExtension) {
+  SimulatedClock clock(kInitialSimulatedClockTime);
+  const Environment env = CreateEnvironment(&clock);
   const std::vector<RtpExtension> kRtpHeaderExtensions{
       {RtpExtension::kAbsSendTimeUri, 1}};
-  SimulatedClock clock(kInitialSimulatedClockTime);
+  FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-  FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
+                       kNoMid, kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
-                       kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
+                       nullptr /* rtp_state */);
-                       nullptr /* rtp_state */, &clock);
   auto fec_packet = GenerateSingleFlexfecPacket(&sender);
 
   EXPECT_TRUE(fec_packet->HasExtension<AbsoluteSendTime>());
@@ -223,12 +232,13 @@ TEST(FlexfecSenderTest, RegisterAbsoluteSendTimeRtpHeaderExtension) {
 }
 
 TEST(FlexfecSenderTest, RegisterTransmissionOffsetRtpHeaderExtension) {
+  SimulatedClock clock(kInitialSimulatedClockTime);
+  const Environment env = CreateEnvironment(&clock);
   const std::vector<RtpExtension> kRtpHeaderExtensions{
       {RtpExtension::kTimestampOffsetUri, 1}};
-  SimulatedClock clock(kInitialSimulatedClockTime);
+  FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-  FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
+                       kNoMid, kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
-                       kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
+                       nullptr /* rtp_state */);
-                       nullptr /* rtp_state */, &clock);
   auto fec_packet = GenerateSingleFlexfecPacket(&sender);
 
   EXPECT_FALSE(fec_packet->HasExtension<AbsoluteSendTime>());
@@ -237,12 +247,13 @@ TEST(FlexfecSenderTest, RegisterTransmissionOffsetRtpHeaderExtension) {
 }
 
 TEST(FlexfecSenderTest, RegisterTransportSequenceNumberRtpHeaderExtension) {
+  SimulatedClock clock(kInitialSimulatedClockTime);
+  const Environment env = CreateEnvironment(&clock);
   const std::vector<RtpExtension> kRtpHeaderExtensions{
       {RtpExtension::kTransportSequenceNumberUri, 1}};
-  SimulatedClock clock(kInitialSimulatedClockTime);
+  FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-  FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
+                       kNoMid, kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
-                       kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
+                       nullptr /* rtp_state */);
-                       nullptr /* rtp_state */, &clock);
   auto fec_packet = GenerateSingleFlexfecPacket(&sender);
 
   EXPECT_FALSE(fec_packet->HasExtension<AbsoluteSendTime>());
@@ -251,14 +262,15 @@ TEST(FlexfecSenderTest, RegisterTransportSequenceNumberRtpHeaderExtension) {
 }
 
 TEST(FlexfecSenderTest, RegisterAllRtpHeaderExtensionsForBwe) {
+  SimulatedClock clock(kInitialSimulatedClockTime);
+  const Environment env = CreateEnvironment(&clock);
   const std::vector<RtpExtension> kRtpHeaderExtensions{
       {RtpExtension::kAbsSendTimeUri, 1},
       {RtpExtension::kTimestampOffsetUri, 2},
       {RtpExtension::kTransportSequenceNumberUri, 3}};
-  SimulatedClock clock(kInitialSimulatedClockTime);
+  FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-  FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
+                       kNoMid, kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
-                       kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
+                       nullptr /* rtp_state */);
-                       nullptr /* rtp_state */, &clock);
   auto fec_packet = GenerateSingleFlexfecPacket(&sender);
 
   EXPECT_TRUE(fec_packet->HasExtension<AbsoluteSendTime>());
@@ -268,19 +280,21 @@ TEST(FlexfecSenderTest, RegisterAllRtpHeaderExtensionsForBwe) {
 
 TEST(FlexfecSenderTest, MaxPacketOverhead) {
   SimulatedClock clock(kInitialSimulatedClockTime);
-  FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
+  const Environment env = CreateEnvironment(&clock);
-                       kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
+  FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-                       nullptr /* rtp_state */, &clock);
+                       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<RtpExtension> 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,
+  FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-                       kRtpHeaderExtensions, RTPSender::FecExtensionSizes(),
+                       kNoMid, kRtpHeaderExtensions,
-                       nullptr /* rtp_state */, &clock);
+                       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<RtpExtension> kRtpHeaderExtensions{
       {RtpExtension::kMidUri, 1}};
   const char kMid[] = "mid";
-  SimulatedClock clock(kInitialSimulatedClockTime);
+  FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kMid,
-  FlexfecSender sender(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(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-  FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
+                       kNoMid, kNoRtpHeaderExtensions,
-                       kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
+                       kNoRtpHeaderExtensionSizes, &initial_rtp_state);
-                       &initial_rtp_state, &clock);
 
   auto fec_packet = GenerateSingleFlexfecPacket(&sender);
   EXPECT_EQ(initial_rtp_state.sequence_number, fec_packet->SequenceNumber());

modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc

@@ -17,6 +17,8 @@
 #include <utility>
 
 #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,
+  RtpRtcpModule(const Environment& env,
-                bool is_sender,
+                GlobalSimulatedTimeController* time_controller,
-                const FieldTrialsRegistry& trials)
+                bool is_sender)
-      : time_controller_(time_controller),
+      : env_(env),
         is_sender_(is_sender),
-        trials_(trials),
+        receive_statistics_(ReceiveStatistics::Create(&env.clock())),
-        receive_statistics_(
-            ReceiveStatistics::Create(time_controller->GetClock())),
         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<ReceiveStatistics> 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_(""),
+        env_(CreateEnvironment(time_controller_.GetClock(),
-        sender_(&time_controller_,
+                               time_controller_.CreateTaskQueueFactory())),
-                /*is_sender=*/true,
+        sender_(env_,
-                field_trials_),
+                &time_controller_,
-        receiver_(&time_controller_,
+                /*is_sender=*/true),
-                  /*is_sender=*/false,
+        receiver_(env_,
-                  field_trials_) {}
+                  &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<RTPSenderVideo>(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<RTPSenderVideo> 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,
+  FlexfecSender flexfec_sender(env_, kFlexfecPayloadType, kFlexfecSsrc,
-                               kNoMid, kNoRtpExtensions, kNoRtpExtensionSizes,
+                               kSenderSsrc, kNoMid, kNoRtpExtensions,
-                               &start_state, time_controller_.GetClock());
+                               kNoRtpExtensionSizes, &start_state);
   ReinitWithFec(&flexfec_sender, /*red_payload_type=*/absl::nullopt);
 
   // Parameters selected to generate a single FEC packet per media packet.

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<RtpSenderEgress> 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<MockRtcEventLog> mock_rtc_event_log_;
   NiceMock<MockStreamDataCountersCallback> mock_rtp_stats_callback_;
@@ -171,7 +173,6 @@ class RtpSenderEgressTest : public ::testing::Test {
   RtpHeaderExtensionMap header_extensions_;
   NiceMock<TestTransport> 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<const RtpExtensionSize> 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<RtpSenderEgress>(config, &packet_history_);

modules/rtp_rtcp/source/rtp_sender_unittest.cc

@@ -14,6 +14,8 @@
 #include <vector>
 
 #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()),
+        env_(CreateEnvironment(time_controller_.GetClock())),
-        retransmission_rate_limiter_(clock_, 1000),
+        retransmission_rate_limiter_(&env_.clock(), 1000),
-        flexfec_sender_(0,
+        flexfec_sender_(env_,
+                        0,
                         kFlexFecSsrc,
                         kSsrc,
                         "",
                         std::vector<RtpExtension>(),
                         std::vector<RtpExtensionSize>(),
-                        nullptr,
+                        nullptr) {}
-                        clock_) {}
 
   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<RTPSender>(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<MockRtcEventLog> mock_rtc_event_log_;
   MockRtpPacketPacer mock_paced_sender_;
   RateLimiter retransmission_rate_limiter_;
@@ -177,8 +178,6 @@ class RtpSenderTest : public ::testing::Test {
   std::unique_ptr<RtpPacketHistory> packet_history_;
   std::unique_ptr<RTPSender> rtp_sender_;
 
-  const test::ExplicitKeyValueConfig field_trials_{""};
-
   std::unique_ptr<RtpPacketToSend> 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<std::unique_ptr<RtpPacketToSend>> 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<RtpPacketToSend> 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<RtpPacketToSend> 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<std::unique_ptr<RtpPacketToSend>> 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<std::unique_ptr<RtpPacketToSend>> 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<RtpPacketToSend>(*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<RtpPacketToSend>(*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<std::unique_ptr<RtpPacketToSend>> 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<std::unique_ptr<RtpPacketToSend>> 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<RtpPacketToSend> 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<RtpPacketToSend> 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<RtpPacketToSend> 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<RtpPacketToSend> 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<std::unique_ptr<RtpPacketToSend>> generated_packets =
@@ -1093,11 +1092,11 @@ TEST_F(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) {
 
   const size_t kPayloadPacketSize = kMinPaddingSize;
   std::unique_ptr<RtpPacketToSend> 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<RtpPacketToSend> 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<RtpPacketToSend> 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<RtpPacketToSend> 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<RtpPacketToSend> 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<RtpPacketToSend> 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,

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",

test/fuzzers/flexfec_sender_fuzzer.cc

@@ -10,6 +10,8 @@
 
 #include <memory>
 
+#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<RtpExtensionSize> 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++]);
+  // Set time to (1 + data[i++]);
-  FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
+  clock->AdvanceTimeMicroseconds(1 + data[i++] - clock->TimeInMicroseconds());
-                       kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
+  FlexfecSender sender(*env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
-                       nullptr /* rtp_state */, &clock);
+                       kNoMid, kNoRtpHeaderExtensions,
+                       kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */);
   FecProtectionParams params = {
       data[i++], static_cast<int>(data[i++] % 100),
       data[i++] <= 127 ? kFecMaskRandom : kFecMaskBursty};