Clean up the TaskQueuePacedSender constructor.

Removes the unused event log pointer and the default arguments.

Bug: webrtc:13417
Change-Id: I90341528cdfd7a5c102addaa4e7c83e875525386
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/255562
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36238}
diff --git a/call/rtp_transport_controller_send.cc b/call/rtp_transport_controller_send.cc
index 2bf24e1..9b3f3cc 100644
--- a/call/rtp_transport_controller_send.cc
+++ b/call/rtp_transport_controller_send.cc
@@ -101,14 +101,12 @@
                                 ? nullptr
                                 : new PacedSender(clock,
                                                   &packet_router_,
-                                                  event_log,
                                                   trials,
                                                   process_thread_.get())),
       task_queue_pacer_(
           pacer_settings_.use_task_queue_pacer()
               ? new TaskQueuePacedSender(clock,
                                          &packet_router_,
-                                         event_log,
                                          trials,
                                          task_queue_factory,
                                          pacer_settings_.holdback_window.Get(),
diff --git a/modules/pacing/paced_sender.cc b/modules/pacing/paced_sender.cc
index 9b419f0..56a1410 100644
--- a/modules/pacing/paced_sender.cc
+++ b/modules/pacing/paced_sender.cc
@@ -16,7 +16,6 @@
 
 #include "absl/memory/memory.h"
 #include "absl/strings/match.h"
-#include "api/rtc_event_log/rtc_event_log.h"
 #include "modules/utility/include/process_thread.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/location.h"
@@ -31,7 +30,6 @@
 
 PacedSender::PacedSender(Clock* clock,
                          PacketRouter* packet_router,
-                         RtcEventLog* event_log,
                          const WebRtcKeyValueConfig& field_trials,
                          ProcessThread* process_thread)
     : process_mode_(
@@ -39,11 +37,7 @@
                            "Enabled")
               ? PacingController::ProcessMode::kDynamic
               : PacingController::ProcessMode::kPeriodic),
-      pacing_controller_(clock,
-                         packet_router,
-                         event_log,
-                         field_trials,
-                         process_mode_),
+      pacing_controller_(clock, packet_router, field_trials, process_mode_),
       clock_(clock),
       process_thread_(process_thread) {
   if (process_thread_)
diff --git a/modules/pacing/paced_sender.h b/modules/pacing/paced_sender.h
index bf82e78..e938a1e 100644
--- a/modules/pacing/paced_sender.h
+++ b/modules/pacing/paced_sender.h
@@ -37,7 +37,6 @@
 
 namespace webrtc {
 class Clock;
-class RtcEventLog;
 
 class PacedSender : public RtpPacketPacer, public RtpPacketSender {
  public:
@@ -57,7 +56,6 @@
   // optional once all callers have been updated.
   PacedSender(Clock* clock,
               PacketRouter* packet_router,
-              RtcEventLog* event_log,
               const WebRtcKeyValueConfig& field_trials,
               ProcessThread* process_thread = nullptr);
 
diff --git a/modules/pacing/paced_sender_unittest.cc b/modules/pacing/paced_sender_unittest.cc
index 27f3737..6f2728b 100644
--- a/modules/pacing/paced_sender_unittest.cc
+++ b/modules/pacing/paced_sender_unittest.cc
@@ -78,8 +78,8 @@
     EXPECT_CALL(process_thread_, RegisterModule)
         .WillOnce(SaveArg<0>(&paced_module_));
 
-    pacer_ = std::make_unique<PacedSender>(&clock_, &callback_, nullptr,
-                                           trials_, &process_thread_);
+    pacer_ = std::make_unique<PacedSender>(&clock_, &callback_, trials_,
+                                           &process_thread_);
     EXPECT_CALL(process_thread_, WakeUp).WillRepeatedly([&](Module* module) {
       clock_.AdvanceTimeMilliseconds(module->TimeUntilNextProcess());
     });
diff --git a/modules/pacing/pacing_controller.cc b/modules/pacing/pacing_controller.cc
index c9628e0..93bfe7f 100644
--- a/modules/pacing/pacing_controller.cc
+++ b/modules/pacing/pacing_controller.cc
@@ -97,7 +97,6 @@
 
 PacingController::PacingController(Clock* clock,
                                    PacketSender* packet_sender,
-                                   RtcEventLog* event_log,
                                    const WebRtcKeyValueConfig& field_trials,
                                    ProcessMode mode)
     : mode_(mode),
diff --git a/modules/pacing/pacing_controller.h b/modules/pacing/pacing_controller.h
index d0c2e73..4ec4efa 100644
--- a/modules/pacing/pacing_controller.h
+++ b/modules/pacing/pacing_controller.h
@@ -20,7 +20,6 @@
 
 #include "absl/types/optional.h"
 #include "api/function_view.h"
-#include "api/rtc_event_log/rtc_event_log.h"
 #include "api/transport/field_trial_based_config.h"
 #include "api/transport/network_types.h"
 #include "api/transport/webrtc_key_value_config.h"
@@ -81,7 +80,6 @@
 
   PacingController(Clock* clock,
                    PacketSender* packet_sender,
-                   RtcEventLog* event_log,
                    const WebRtcKeyValueConfig& field_trials,
                    ProcessMode mode);
 
diff --git a/modules/pacing/pacing_controller_unittest.cc b/modules/pacing/pacing_controller_unittest.cc
index c3ab266..33592e3 100644
--- a/modules/pacing/pacing_controller_unittest.cc
+++ b/modules/pacing/pacing_controller_unittest.cc
@@ -29,6 +29,7 @@
 using ::testing::Pointee;
 using ::testing::Property;
 using ::testing::Return;
+using ::testing::WithoutArgs;
 
 namespace webrtc {
 namespace test {
@@ -213,8 +214,8 @@
   void SetUp() override {
     srand(0);
     // Need to initialize PacingController after we initialize clock.
-    pacer_ = std::make_unique<PacingController>(&clock_, &callback_, nullptr,
-                                                trials_, GetParam());
+    pacer_ = std::make_unique<PacingController>(&clock_, &callback_, trials_,
+                                                GetParam());
     Init();
   }
 
@@ -365,7 +366,7 @@
 
 TEST_P(PacingControllerFieldTrialTest, DefaultNoPaddingInSilence) {
   const test::ExplicitKeyValueConfig trials("");
-  PacingController pacer(&clock_, &callback_, nullptr, trials, GetParam());
+  PacingController pacer(&clock_, &callback_, trials, GetParam());
   pacer.SetPacingRates(kTargetRate, DataRate::Zero());
   // Video packet to reset last send time and provide padding data.
   InsertPacket(&pacer, &video);
@@ -381,7 +382,7 @@
 TEST_P(PacingControllerFieldTrialTest, PaddingInSilenceWithTrial) {
   const test::ExplicitKeyValueConfig trials(
       "WebRTC-Pacer-PadInSilence/Enabled/");
-  PacingController pacer(&clock_, &callback_, nullptr, trials, GetParam());
+  PacingController pacer(&clock_, &callback_, trials, GetParam());
   pacer.SetPacingRates(kTargetRate, DataRate::Zero());
   // Video packet to reset last send time and provide padding data.
   InsertPacket(&pacer, &video);
@@ -397,7 +398,7 @@
 TEST_P(PacingControllerFieldTrialTest, CongestionWindowAffectsAudioInTrial) {
   const test::ExplicitKeyValueConfig trials("WebRTC-Pacer-BlockAudio/Enabled/");
   EXPECT_CALL(callback_, SendPadding).Times(0);
-  PacingController pacer(&clock_, &callback_, nullptr, trials, GetParam());
+  PacingController pacer(&clock_, &callback_, trials, GetParam());
   pacer.SetPacingRates(DataRate::KilobitsPerSec(10000), DataRate::Zero());
   // Video packet fills congestion window.
   InsertPacket(&pacer, &video);
@@ -424,7 +425,7 @@
        DefaultCongestionWindowDoesNotAffectAudio) {
   EXPECT_CALL(callback_, SendPadding).Times(0);
   const test::ExplicitKeyValueConfig trials("");
-  PacingController pacer(&clock_, &callback_, nullptr, trials, GetParam());
+  PacingController pacer(&clock_, &callback_, trials, GetParam());
   pacer.SetPacingRates(DataRate::BitsPerSec(10000000), DataRate::Zero());
   // Video packet fills congestion window.
   InsertPacket(&pacer, &video);
@@ -439,7 +440,7 @@
 
 TEST_P(PacingControllerFieldTrialTest, BudgetAffectsAudioInTrial) {
   ExplicitKeyValueConfig trials("WebRTC-Pacer-BlockAudio/Enabled/");
-  PacingController pacer(&clock_, &callback_, nullptr, trials, GetParam());
+  PacingController pacer(&clock_, &callback_, trials, GetParam());
   DataRate pacing_rate = DataRate::BitsPerSec(video.packet_size / 3 * 8 *
                                               kProcessIntervalsPerSecond);
   pacer.SetPacingRates(pacing_rate, DataRate::Zero());
@@ -451,10 +452,9 @@
   InsertPacket(&pacer, &audio);
   Timestamp wait_start_time = clock_.CurrentTime();
   Timestamp wait_end_time = Timestamp::MinusInfinity();
-  EXPECT_CALL(callback_, SendPacket)
-      .WillOnce([&](uint32_t ssrc, uint16_t sequence_number,
-                    int64_t capture_timestamp, bool retransmission,
-                    bool padding) { wait_end_time = clock_.CurrentTime(); });
+  EXPECT_CALL(callback_, SendPacket).WillOnce(WithoutArgs([&]() {
+    wait_end_time = clock_.CurrentTime();
+  }));
   while (!wait_end_time.IsFinite()) {
     ProcessNext(&pacer);
   }
@@ -470,7 +470,7 @@
 TEST_P(PacingControllerFieldTrialTest, DefaultBudgetDoesNotAffectAudio) {
   EXPECT_CALL(callback_, SendPadding).Times(0);
   const test::ExplicitKeyValueConfig trials("");
-  PacingController pacer(&clock_, &callback_, nullptr, trials, GetParam());
+  PacingController pacer(&clock_, &callback_, trials, GetParam());
   pacer.SetPacingRates(DataRate::BitsPerSec(video.packet_size / 3 * 8 *
                                             kProcessIntervalsPerSecond),
                        DataRate::Zero());
@@ -868,8 +868,8 @@
   const int kTimeStep = 5;
   const TimeDelta kAveragingWindowLength = TimeDelta::Seconds(10);
   PacingControllerPadding callback;
-  pacer_ = std::make_unique<PacingController>(&clock_, &callback, nullptr,
-                                              trials_, GetParam());
+  pacer_ = std::make_unique<PacingController>(&clock_, &callback, trials_,
+                                              GetParam());
   pacer_->SetProbingEnabled(false);
   pacer_->SetPacingRates(kTargetRate * kPaceMultiplier, kTargetRate);
 
@@ -1246,8 +1246,8 @@
 
 TEST_P(PacingControllerTest, InactiveFromStart) {
   // Recreate the pacer without the inital time forwarding.
-  pacer_ = std::make_unique<PacingController>(&clock_, &callback_, nullptr,
-                                              trials_, GetParam());
+  pacer_ = std::make_unique<PacingController>(&clock_, &callback_, trials_,
+                                              GetParam());
   pacer_->SetProbingEnabled(false);
   pacer_->SetPacingRates(kTargetRate * kPaceMultiplier, kTargetRate);
 
@@ -1345,8 +1345,8 @@
   uint16_t sequence_number = 1234;
 
   PacingControllerProbing packet_sender;
-  pacer_ = std::make_unique<PacingController>(&clock_, &packet_sender, nullptr,
-                                              trials_, GetParam());
+  pacer_ = std::make_unique<PacingController>(&clock_, &packet_sender, trials_,
+                                              GetParam());
   pacer_->CreateProbeCluster(kFirstClusterRate,
                              /*cluster_id=*/0);
   pacer_->CreateProbeCluster(kSecondClusterRate,
@@ -1405,8 +1405,8 @@
                                "abort_delayed_probes:1,max_probe_delay:2ms/"
                              : "WebRTC-Bwe-ProbingBehavior/"
                                "abort_delayed_probes:0,max_probe_delay:2ms/");
-    pacer_ = std::make_unique<PacingController>(&clock_, &packet_sender,
-                                                nullptr, trials, GetParam());
+    pacer_ = std::make_unique<PacingController>(&clock_, &packet_sender, trials,
+                                                GetParam());
     pacer_->SetPacingRates(
         DataRate::BitsPerSec(kInitialBitrateBps * kPaceMultiplier),
         DataRate::BitsPerSec(kInitialBitrateBps));
@@ -1512,8 +1512,8 @@
   uint16_t sequence_number = 1234;
 
   PacingControllerProbing packet_sender;
-  pacer_ = std::make_unique<PacingController>(&clock_, &packet_sender, nullptr,
-                                              trials_, GetParam());
+  pacer_ = std::make_unique<PacingController>(&clock_, &packet_sender, trials_,
+                                              GetParam());
   pacer_->CreateProbeCluster(kFirstClusterRate,
                              /*cluster_id=*/0);
   pacer_->SetPacingRates(
@@ -1578,8 +1578,8 @@
 TEST_P(PacingControllerTest, ProbeClusterId) {
   MockPacketSender callback;
 
-  pacer_ = std::make_unique<PacingController>(&clock_, &callback, nullptr,
-                                              trials_, GetParam());
+  pacer_ = std::make_unique<PacingController>(&clock_, &callback, trials_,
+                                              GetParam());
   Init();
 
   uint32_t ssrc = 12346;
@@ -1635,8 +1635,8 @@
 
 TEST_P(PacingControllerTest, OwnedPacketPrioritizedOnType) {
   MockPacketSender callback;
-  pacer_ = std::make_unique<PacingController>(&clock_, &callback, nullptr,
-                                              trials_, GetParam());
+  pacer_ = std::make_unique<PacingController>(&clock_, &callback, trials_,
+                                              GetParam());
   Init();
 
   // Insert a packet of each type, from low to high priority. Since priority
@@ -1682,8 +1682,8 @@
 
 TEST_P(PacingControllerTest, SmallFirstProbePacket) {
   MockPacketSender callback;
-  pacer_ = std::make_unique<PacingController>(&clock_, &callback, nullptr,
-                                              trials_, GetParam());
+  pacer_ = std::make_unique<PacingController>(&clock_, &callback, trials_,
+                                              GetParam());
   pacer_->CreateProbeCluster(kFirstClusterRate, /*cluster_id=*/0);
   pacer_->SetPacingRates(kTargetRate * kPaceMultiplier, DataRate::Zero());
 
@@ -1841,8 +1841,8 @@
     uint16_t sequence_number = 1234;
     MockPacketSender callback;
     EXPECT_CALL(callback, SendPacket).Times(::testing::AnyNumber());
-    pacer_ = std::make_unique<PacingController>(&clock_, &callback, nullptr,
-                                                trials_, GetParam());
+    pacer_ = std::make_unique<PacingController>(&clock_, &callback, trials_,
+                                                GetParam());
     pacer_->SetAccountForAudioPackets(account_for_audio);
 
     // First, saturate the padding budget.
@@ -2020,8 +2020,8 @@
       "WebRTC-Pacer-DynamicPaddingTarget/timedelta:10ms/");
   srand(0);
   // Need to initialize PacingController after we initialize clock.
-  pacer_ = std::make_unique<PacingController>(&clock_, &callback_, nullptr,
-                                              field_trials, GetParam());
+  pacer_ = std::make_unique<PacingController>(&clock_, &callback_, field_trials,
+                                              GetParam());
   Init();
 
   const uint32_t kSsrc = 12345;
diff --git a/modules/pacing/task_queue_paced_sender.cc b/modules/pacing/task_queue_paced_sender.cc
index 4294bd8..ebfc7ec 100644
--- a/modules/pacing/task_queue_paced_sender.cc
+++ b/modules/pacing/task_queue_paced_sender.cc
@@ -39,7 +39,6 @@
     int max_hold_back_window_in_packets)
     : TaskQueuePacedSender(clock,
                            packet_sender,
-                           event_log,
                            *field_trials,
                            task_queue_factory,
                            max_hold_back_window,
@@ -48,7 +47,6 @@
 TaskQueuePacedSender::TaskQueuePacedSender(
     Clock* clock,
     PacingController::PacketSender* packet_sender,
-    RtcEventLog* event_log,
     const WebRtcKeyValueConfig& field_trials,
     TaskQueueFactory* task_queue_factory,
     TimeDelta max_hold_back_window,
@@ -63,7 +61,6 @@
           allow_low_precision_ ? 0 : max_hold_back_window_in_packets),
       pacing_controller_(clock,
                          packet_sender,
-                         event_log,
                          field_trials,
                          PacingController::ProcessMode::kDynamic),
       next_process_time_(Timestamp::MinusInfinity()),
diff --git a/modules/pacing/task_queue_paced_sender.h b/modules/pacing/task_queue_paced_sender.h
index 5c8dba7..7a1d5f2 100644
--- a/modules/pacing/task_queue_paced_sender.h
+++ b/modules/pacing/task_queue_paced_sender.h
@@ -37,11 +37,11 @@
 
 namespace webrtc {
 class Clock;
-class RtcEventLog;
 
 class TaskQueuePacedSender : public RtpPacketPacer, public RtpPacketSender {
  public:
-  ABSL_DEPRECATED("Use the version with field_trials reference instead.")
+  // TODO(bugs.webrtc.org/13417): Remove when downstream usage is gone.
+  ABSL_DEPRECATED("Use the other version instead.")
   TaskQueuePacedSender(
       Clock* clock,
       PacingController::PacketSender* packet_sender,
@@ -55,15 +55,12 @@
   // there is currently a pacer queue and packets can't immediately be
   // processed. Increasing this reduces thread wakeups at the expense of higher
   // latency.
-  // TODO(bugs.webrtc.org/10809): Remove default values.
-  TaskQueuePacedSender(
-      Clock* clock,
-      PacingController::PacketSender* packet_sender,
-      RtcEventLog* event_log,
-      const WebRtcKeyValueConfig& field_trials,
-      TaskQueueFactory* task_queue_factory,
-      TimeDelta max_hold_back_window = PacingController::kMinSleepTime,
-      int max_hold_back_window_in_packets = -1);
+  TaskQueuePacedSender(Clock* clock,
+                       PacingController::PacketSender* packet_sender,
+                       const WebRtcKeyValueConfig& field_trials,
+                       TaskQueueFactory* task_queue_factory,
+                       TimeDelta max_hold_back_window,
+                       int max_hold_back_window_in_packets);
 
   ~TaskQueuePacedSender() override;
 
diff --git a/modules/pacing/task_queue_paced_sender_unittest.cc b/modules/pacing/task_queue_paced_sender_unittest.cc
index cb6d615..420d4f4 100644
--- a/modules/pacing/task_queue_paced_sender_unittest.cc
+++ b/modules/pacing/task_queue_paced_sender_unittest.cc
@@ -203,10 +203,10 @@
   GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
   MockPacketRouter packet_router;
   ScopedKeyValueConfig trials;
-  TaskQueuePacedSender pacer(
-      time_controller.GetClock(), &packet_router,
-      /*event_log=*/nullptr, trials, time_controller.GetTaskQueueFactory(),
-      PacingController::kMinSleepTime, kNoPacketHoldback);
+  TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
+                             time_controller.GetTaskQueueFactory(),
+                             PacingController::kMinSleepTime,
+                             kNoPacketHoldback);
 
   // Insert a number of packets, covering one second.
   static constexpr size_t kPacketsToSend = 42;
@@ -243,10 +243,10 @@
   GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
   MockPacketRouter packet_router;
   ScopedKeyValueConfig trials;
-  TaskQueuePacedSender pacer(
-      time_controller.GetClock(), &packet_router,
-      /*event_log=*/nullptr, trials, time_controller.GetTaskQueueFactory(),
-      PacingController::kMinSleepTime, kNoPacketHoldback);
+  TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
+                             time_controller.GetTaskQueueFactory(),
+                             PacingController::kMinSleepTime,
+                             kNoPacketHoldback);
 
   // Insert a number of packets to be sent 200ms apart.
   const size_t kPacketsPerSecond = 5;
@@ -295,10 +295,10 @@
   GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
   MockPacketRouter packet_router;
   ScopedKeyValueConfig trials;
-  TaskQueuePacedSender pacer(
-      time_controller.GetClock(), &packet_router,
-      /*event_log=*/nullptr, trials, time_controller.GetTaskQueueFactory(),
-      PacingController::kMinSleepTime, kNoPacketHoldback);
+  TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
+                             time_controller.GetTaskQueueFactory(),
+                             PacingController::kMinSleepTime,
+                             kNoPacketHoldback);
 
   const DataRate kPacingDataRate = DataRate::KilobitsPerSec(125);
   const DataSize kPacketSize = DataSize::Bytes(kDefaultPacketSize);
@@ -328,8 +328,7 @@
   GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
   MockPacketRouter packet_router;
   ScopedKeyValueConfig trials;
-  TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router,
-                             /*event_log=*/nullptr, trials,
+  TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
                              time_controller.GetTaskQueueFactory(),
                              kCoalescingWindow, kNoPacketHoldback);
 
@@ -365,8 +364,7 @@
   GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
   MockPacketRouter packet_router;
   ScopedKeyValueConfig trials;
-  TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router,
-                             /*event_log=*/nullptr, trials,
+  TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
                              time_controller.GetTaskQueueFactory(),
                              kCoalescingWindow, kNoPacketHoldback);
 
@@ -397,10 +395,10 @@
       "WebRTC-Bwe-ProbingBehavior/min_probe_delta:1ms/");
   GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
   MockPacketRouter packet_router;
-  TaskQueuePacedSender pacer(
-      time_controller.GetClock(), &packet_router,
-      /*event_log=*/nullptr, trials, time_controller.GetTaskQueueFactory(),
-      PacingController::kMinSleepTime, kNoPacketHoldback);
+  TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
+                             time_controller.GetTaskQueueFactory(),
+                             PacingController::kMinSleepTime,
+                             kNoPacketHoldback);
 
   // Set rates so one packet adds 4ms of buffer level.
   const DataSize kPacketSize = DataSize::Bytes(kDefaultPacketSize);
@@ -464,10 +462,10 @@
       "WebRTC-Bwe-ProbingBehavior/min_probe_delta:100us/");
   GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
   MockPacketRouter packet_router;
-  TaskQueuePacedSender pacer(
-      time_controller.GetClock(), &packet_router,
-      /*event_log=*/nullptr, trials, time_controller.GetTaskQueueFactory(),
-      PacingController::kMinSleepTime, kNoPacketHoldback);
+  TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
+                             time_controller.GetTaskQueueFactory(),
+                             PacingController::kMinSleepTime,
+                             kNoPacketHoldback);
 
   // Set rates so one packet adds 4ms of buffer level.
   const DataSize kPacketSize = DataSize::Bytes(kDefaultPacketSize);
@@ -520,8 +518,7 @@
   GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
   MockPacketRouter packet_router;
   ScopedKeyValueConfig trials;
-  TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router,
-                             /*event_log=*/nullptr, trials,
+  TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
                              time_controller.GetTaskQueueFactory(),
                              kFixedCoalescingWindow, kPacketBasedHoldback);
 
@@ -571,8 +568,7 @@
   GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
   MockPacketRouter packet_router;
   ScopedKeyValueConfig trials;
-  TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router,
-                             /*event_log=*/nullptr, trials,
+  TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
                              time_controller.GetTaskQueueFactory(),
                              kFixedCoalescingWindow, kPacketBasedHoldback);
 
@@ -617,10 +613,10 @@
   GlobalSimulatedTimeController time_controller(kStartTime);
   MockPacketRouter packet_router;
   ScopedKeyValueConfig trials;
-  TaskQueuePacedSender pacer(
-      time_controller.GetClock(), &packet_router,
-      /*event_log=*/nullptr, trials, time_controller.GetTaskQueueFactory(),
-      PacingController::kMinSleepTime, kNoPacketHoldback);
+  TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
+                             time_controller.GetTaskQueueFactory(),
+                             PacingController::kMinSleepTime,
+                             kNoPacketHoldback);
 
   // Simulate ~2mbps video stream, covering one second.
   static constexpr size_t kPacketsToSend = 200;
@@ -693,9 +689,8 @@
 
   MockPacketRouter packet_router;
   TaskQueuePacedSender pacer(
-      time_controller.GetClock(), &packet_router, /*event_log=*/nullptr,
-      experiments, &task_queue_factory, PacingController::kMinSleepTime,
-      kNoPacketHoldback);
+      time_controller.GetClock(), &packet_router, experiments,
+      &task_queue_factory, PacingController::kMinSleepTime, kNoPacketHoldback);
 
   // Send enough packets (covering one second) that pacing is triggered, i.e.
   // delayed tasks being scheduled.
@@ -737,9 +732,8 @@
 
   MockPacketRouter packet_router;
   TaskQueuePacedSender pacer(
-      time_controller.GetClock(), &packet_router, /*event_log=*/nullptr,
-      experiments, &task_queue_factory, PacingController::kMinSleepTime,
-      kNoPacketHoldback);
+      time_controller.GetClock(), &packet_router, experiments,
+      &task_queue_factory, PacingController::kMinSleepTime, kNoPacketHoldback);
 
   // Send enough packets (covering one second) that pacing is triggered, i.e.
   // delayed tasks being scheduled.