zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clean up the TaskQueuePacedSender constructor.

Browse Source 
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}
This commit is contained in:
Erik Språng
2022-03-17 15:16:59 +01:00
committed by WebRTC LUCI CQ
parent 8e1ae8cf57
commit 1a08096998
10 changed files with 75 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
call/rtp_transport_controller_send.cc
View File

@ -101,14 +101,12 @@ RtpTransportControllerSend::RtpTransportControllerSend(
? 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(),

8
modules/pacing/paced_sender.cc
View File

@ -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 @@ const float PacedSender::kDefaultPaceMultiplier = 2.5f;
PacedSender::PacedSender(Clock* clock,
PacketRouter* packet_router,
RtcEventLog* event_log,
const WebRtcKeyValueConfig& field_trials,
ProcessThread* process_thread)
: process_mode_(
@ -39,11 +37,7 @@ PacedSender::PacedSender(Clock* clock,
"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_)

2
modules/pacing/paced_sender.h
View File

@ -37,7 +37,6 @@
namespace webrtc {
class Clock;
class RtcEventLog;
class PacedSender : public RtpPacketPacer, public RtpPacketSender {
public:
@ -57,7 +56,6 @@ class PacedSender : public RtpPacketPacer, public RtpPacketSender {
// optional once all callers have been updated.
PacedSender(Clock* clock,
PacketRouter* packet_router,
RtcEventLog* event_log,
const WebRtcKeyValueConfig& field_trials,
ProcessThread* process_thread = nullptr);

4
modules/pacing/paced_sender_unittest.cc
View File

@ -78,8 +78,8 @@ class PacedSenderTest
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());
});

1
modules/pacing/pacing_controller.cc
View File

@ -97,7 +97,6 @@ const TimeDelta PacingController::kMinSleepTime = TimeDelta::Millis(1);
PacingController::PacingController(Clock* clock,
PacketSender* packet_sender,
RtcEventLog* event_log,
const WebRtcKeyValueConfig& field_trials,
ProcessMode mode)
: mode_(mode),

2
modules/pacing/pacing_controller.h
View File

@ -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 @@ class PacingController {
PacingController(Clock* clock,
PacketSender* packet_sender,
RtcEventLog* event_log,
const WebRtcKeyValueConfig& field_trials,
ProcessMode mode);

64
modules/pacing/pacing_controller_unittest.cc
View File

@ -29,6 +29,7 @@ using ::testing::Field;
using ::testing::Pointee;
using ::testing::Property;
using ::testing::Return;
using ::testing::WithoutArgs;
namespace webrtc {
namespace test {
@ -213,8 +214,8 @@ class PacingControllerTest
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 @@ class PacingControllerFieldTrialTest
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, DefaultNoPaddingInSilence) {
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, PaddingInSilenceWithTrial) {
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 @@ TEST_P(PacingControllerFieldTrialTest,
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,
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 @@ TEST_P(PacingControllerFieldTrialTest, BudgetAffectsAudioInTrial) {
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, BudgetAffectsAudioInTrial) {
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 @@ TEST_P(PacingControllerTest, VerifyAverageBitrateVaryingMediaPayload) {
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, Pause) {
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 @@ TEST_P(PacingControllerTest, ProbingWithInsertedPackets) {
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 @@ TEST_P(PacingControllerTest, SkipsProbesWhenProcessIntervalTooLarge) {
"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 @@ TEST_P(PacingControllerTest, ProbingWithPaddingSupport) {
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, PaddingOveruse) {
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, ProbeClusterId) {
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, OwnedPacketPrioritizedOnType) {
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 @@ TEST_P(PacingControllerTest,
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 @@ TEST_P(PacingControllerTest, PaddingTargetAccountsForPaddingRate) {
"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;

3
modules/pacing/task_queue_paced_sender.cc
View File

@ -39,7 +39,6 @@ TaskQueuePacedSender::TaskQueuePacedSender(
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(
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 @@ TaskQueuePacedSender::TaskQueuePacedSender(
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()),

19
modules/pacing/task_queue_paced_sender.h
View File

@ -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 @@ class TaskQueuePacedSender : public RtpPacketPacer, public RtpPacketSender {
// 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;

70
modules/pacing/task_queue_paced_sender_unittest.cc
View File

@ -203,10 +203,10 @@ TEST(TaskQueuePacedSenderTest, PacesPackets) {
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 @@ TEST(TaskQueuePacedSenderTest, ReschedulesProcessOnRateChange) {
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 @@ TEST(TaskQueuePacedSenderTest, SendsAudioImmediately) {
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 @@ TEST(TaskQueuePacedSenderTest, SleepsDuringCoalscingWindow) {
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 @@ TEST(TaskQueuePacedSenderTest, ProbingOverridesCoalescingWindow) {
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 @@ TEST(TaskQueuePacedSenderTest, SchedulesProbeAtSetTime) {
"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 @@ TEST(TaskQueuePacedSenderTest, NoMinSleepTimeWhenProbing) {
"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 @@ TEST(TaskQueuePacedSenderTest, PacketBasedCoalescing) {
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 @@ TEST(TaskQueuePacedSenderTest, FixedHoldBackHasPriorityOverPackets) {
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 @@ TEST(TaskQueuePacedSenderTest, Stats) {
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 @@ TEST(TaskQueuePacedSenderTest, HighPrecisionPacingWhenSlackIsDisabled) {
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 @@ TEST(TaskQueuePacedSenderTest, LowPrecisionPacingWhenSlackIsEnabled) {
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.