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 ? nullptr
: new PacedSender(clock, : new PacedSender(clock,
&packet_router_, &packet_router_,
event_log,
trials, trials,
process_thread_.get())), process_thread_.get())),
task_queue_pacer_( task_queue_pacer_(
pacer_settings_.use_task_queue_pacer() pacer_settings_.use_task_queue_pacer()
? new TaskQueuePacedSender(clock, ? new TaskQueuePacedSender(clock,
&packet_router_, &packet_router_,
event_log,
trials, trials,
task_queue_factory, task_queue_factory,
pacer_settings_.holdback_window.Get(), pacer_settings_.holdback_window.Get(),

8
modules/pacing/paced_sender.cc
View File

@ -16,7 +16,6 @@
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
#include "absl/strings/match.h" #include "absl/strings/match.h"
#include "api/rtc_event_log/rtc_event_log.h"
#include "modules/utility/include/process_thread.h" #include "modules/utility/include/process_thread.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/location.h" #include "rtc_base/location.h"
@ -31,7 +30,6 @@ const float PacedSender::kDefaultPaceMultiplier = 2.5f;
PacedSender::PacedSender(Clock* clock, PacedSender::PacedSender(Clock* clock,
PacketRouter* packet_router, PacketRouter* packet_router,
RtcEventLog* event_log,
const WebRtcKeyValueConfig& field_trials, const WebRtcKeyValueConfig& field_trials,
ProcessThread* process_thread) ProcessThread* process_thread)
: process_mode_( : process_mode_(
@ -39,11 +37,7 @@ PacedSender::PacedSender(Clock* clock,
"Enabled") "Enabled")
? PacingController::ProcessMode::kDynamic ? PacingController::ProcessMode::kDynamic
: PacingController::ProcessMode::kPeriodic), : PacingController::ProcessMode::kPeriodic),
pacing_controller_(clock, pacing_controller_(clock, packet_router, field_trials, process_mode_),
packet_router,
event_log,
field_trials,
process_mode_),
clock_(clock), clock_(clock),
process_thread_(process_thread) { process_thread_(process_thread) {
if (process_thread_) if (process_thread_)

2
modules/pacing/paced_sender.h
View File

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

4
modules/pacing/paced_sender_unittest.cc
View File

@ -78,8 +78,8 @@ class PacedSenderTest
EXPECT_CALL(process_thread_, RegisterModule) EXPECT_CALL(process_thread_, RegisterModule)
.WillOnce(SaveArg<0>(&paced_module_)); .WillOnce(SaveArg<0>(&paced_module_));
pacer_ = std::make_unique<PacedSender>(&clock_, &callback_, nullptr, pacer_ = std::make_unique<PacedSender>(&clock_, &callback_, trials_,
trials_, &process_thread_); &process_thread_);
EXPECT_CALL(process_thread_, WakeUp).WillRepeatedly([&](Module* module) { EXPECT_CALL(process_thread_, WakeUp).WillRepeatedly([&](Module* module) {
clock_.AdvanceTimeMilliseconds(module->TimeUntilNextProcess()); 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, PacingController::PacingController(Clock* clock,
PacketSender* packet_sender, PacketSender* packet_sender,
RtcEventLog* event_log,
const WebRtcKeyValueConfig& field_trials, const WebRtcKeyValueConfig& field_trials,
ProcessMode mode) ProcessMode mode)
: mode_(mode), : mode_(mode),

2
modules/pacing/pacing_controller.h
View File

@ -20,7 +20,6 @@
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/function_view.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/field_trial_based_config.h"
#include "api/transport/network_types.h" #include "api/transport/network_types.h"
#include "api/transport/webrtc_key_value_config.h" #include "api/transport/webrtc_key_value_config.h"
@ -81,7 +80,6 @@ class PacingController {
PacingController(Clock* clock, PacingController(Clock* clock,
PacketSender* packet_sender, PacketSender* packet_sender,
RtcEventLog* event_log,
const WebRtcKeyValueConfig& field_trials, const WebRtcKeyValueConfig& field_trials,
ProcessMode mode); ProcessMode mode);

64
modules/pacing/pacing_controller_unittest.cc
View File

@ -29,6 +29,7 @@ using ::testing::Field;
using ::testing::Pointee; using ::testing::Pointee;
using ::testing::Property; using ::testing::Property;
using ::testing::Return; using ::testing::Return;
using ::testing::WithoutArgs;
namespace webrtc { namespace webrtc {
namespace test { namespace test {
@ -213,8 +214,8 @@ class PacingControllerTest
void SetUp() override { void SetUp() override {
srand(0); srand(0);
// Need to initialize PacingController after we initialize clock. // Need to initialize PacingController after we initialize clock.
pacer_ = std::make_unique<PacingController>(&clock_, &callback_, nullptr, pacer_ = std::make_unique<PacingController>(&clock_, &callback_, trials_,
trials_, GetParam()); GetParam());
Init(); Init();
} }
@ -365,7 +366,7 @@ class PacingControllerFieldTrialTest
TEST_P(PacingControllerFieldTrialTest, DefaultNoPaddingInSilence) { TEST_P(PacingControllerFieldTrialTest, DefaultNoPaddingInSilence) {
const test::ExplicitKeyValueConfig trials(""); const test::ExplicitKeyValueConfig trials("");
PacingController pacer(&clock_, &callback_, nullptr, trials, GetParam()); PacingController pacer(&clock_, &callback_, trials, GetParam());
pacer.SetPacingRates(kTargetRate, DataRate::Zero()); pacer.SetPacingRates(kTargetRate, DataRate::Zero());
// Video packet to reset last send time and provide padding data. // Video packet to reset last send time and provide padding data.
InsertPacket(&pacer, &video); InsertPacket(&pacer, &video);
@ -381,7 +382,7 @@ TEST_P(PacingControllerFieldTrialTest, DefaultNoPaddingInSilence) {
TEST_P(PacingControllerFieldTrialTest, PaddingInSilenceWithTrial) { TEST_P(PacingControllerFieldTrialTest, PaddingInSilenceWithTrial) {
const test::ExplicitKeyValueConfig trials( const test::ExplicitKeyValueConfig trials(
"WebRTC-Pacer-PadInSilence/Enabled/"); "WebRTC-Pacer-PadInSilence/Enabled/");
PacingController pacer(&clock_, &callback_, nullptr, trials, GetParam()); PacingController pacer(&clock_, &callback_, trials, GetParam());
pacer.SetPacingRates(kTargetRate, DataRate::Zero()); pacer.SetPacingRates(kTargetRate, DataRate::Zero());
// Video packet to reset last send time and provide padding data. // Video packet to reset last send time and provide padding data.
InsertPacket(&pacer, &video); InsertPacket(&pacer, &video);
@ -397,7 +398,7 @@ TEST_P(PacingControllerFieldTrialTest, PaddingInSilenceWithTrial) {
TEST_P(PacingControllerFieldTrialTest, CongestionWindowAffectsAudioInTrial) { TEST_P(PacingControllerFieldTrialTest, CongestionWindowAffectsAudioInTrial) {
const test::ExplicitKeyValueConfig trials("WebRTC-Pacer-BlockAudio/Enabled/"); const test::ExplicitKeyValueConfig trials("WebRTC-Pacer-BlockAudio/Enabled/");
EXPECT_CALL(callback_, SendPadding).Times(0); 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()); pacer.SetPacingRates(DataRate::KilobitsPerSec(10000), DataRate::Zero());
// Video packet fills congestion window. // Video packet fills congestion window.
InsertPacket(&pacer, &video); InsertPacket(&pacer, &video);
@ -424,7 +425,7 @@ TEST_P(PacingControllerFieldTrialTest,
DefaultCongestionWindowDoesNotAffectAudio) { DefaultCongestionWindowDoesNotAffectAudio) {
EXPECT_CALL(callback_, SendPadding).Times(0); EXPECT_CALL(callback_, SendPadding).Times(0);
const test::ExplicitKeyValueConfig trials(""); const test::ExplicitKeyValueConfig trials("");
PacingController pacer(&clock_, &callback_, nullptr, trials, GetParam()); PacingController pacer(&clock_, &callback_, trials, GetParam());
pacer.SetPacingRates(DataRate::BitsPerSec(10000000), DataRate::Zero()); pacer.SetPacingRates(DataRate::BitsPerSec(10000000), DataRate::Zero());
// Video packet fills congestion window. // Video packet fills congestion window.
InsertPacket(&pacer, &video); InsertPacket(&pacer, &video);
@ -439,7 +440,7 @@ TEST_P(PacingControllerFieldTrialTest,
TEST_P(PacingControllerFieldTrialTest, BudgetAffectsAudioInTrial) { TEST_P(PacingControllerFieldTrialTest, BudgetAffectsAudioInTrial) {
ExplicitKeyValueConfig trials("WebRTC-Pacer-BlockAudio/Enabled/"); 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 * DataRate pacing_rate = DataRate::BitsPerSec(video.packet_size / 3 * 8 *
kProcessIntervalsPerSecond); kProcessIntervalsPerSecond);
pacer.SetPacingRates(pacing_rate, DataRate::Zero()); pacer.SetPacingRates(pacing_rate, DataRate::Zero());
@ -451,10 +452,9 @@ TEST_P(PacingControllerFieldTrialTest, BudgetAffectsAudioInTrial) {
InsertPacket(&pacer, &audio); InsertPacket(&pacer, &audio);
Timestamp wait_start_time = clock_.CurrentTime(); Timestamp wait_start_time = clock_.CurrentTime();
Timestamp wait_end_time = Timestamp::MinusInfinity(); Timestamp wait_end_time = Timestamp::MinusInfinity();
EXPECT_CALL(callback_, SendPacket) EXPECT_CALL(callback_, SendPacket).WillOnce(WithoutArgs([&]() {
.WillOnce([&](uint32_t ssrc, uint16_t sequence_number, wait_end_time = clock_.CurrentTime();
int64_t capture_timestamp, bool retransmission, }));
bool padding) { wait_end_time = clock_.CurrentTime(); });
while (!wait_end_time.IsFinite()) { while (!wait_end_time.IsFinite()) {
ProcessNext(&pacer); ProcessNext(&pacer);
} }
@ -470,7 +470,7 @@ TEST_P(PacingControllerFieldTrialTest, BudgetAffectsAudioInTrial) {
TEST_P(PacingControllerFieldTrialTest, DefaultBudgetDoesNotAffectAudio) { TEST_P(PacingControllerFieldTrialTest, DefaultBudgetDoesNotAffectAudio) {
EXPECT_CALL(callback_, SendPadding).Times(0); EXPECT_CALL(callback_, SendPadding).Times(0);
const test::ExplicitKeyValueConfig trials(""); 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 * pacer.SetPacingRates(DataRate::BitsPerSec(video.packet_size / 3 * 8 *
kProcessIntervalsPerSecond), kProcessIntervalsPerSecond),
DataRate::Zero()); DataRate::Zero());
@ -868,8 +868,8 @@ TEST_P(PacingControllerTest, VerifyAverageBitrateVaryingMediaPayload) {
const int kTimeStep = 5; const int kTimeStep = 5;
const TimeDelta kAveragingWindowLength = TimeDelta::Seconds(10); const TimeDelta kAveragingWindowLength = TimeDelta::Seconds(10);
PacingControllerPadding callback; PacingControllerPadding callback;
pacer_ = std::make_unique<PacingController>(&clock_, &callback, nullptr, pacer_ = std::make_unique<PacingController>(&clock_, &callback, trials_,
trials_, GetParam()); GetParam());
pacer_->SetProbingEnabled(false); pacer_->SetProbingEnabled(false);
pacer_->SetPacingRates(kTargetRate * kPaceMultiplier, kTargetRate); pacer_->SetPacingRates(kTargetRate * kPaceMultiplier, kTargetRate);
@ -1246,8 +1246,8 @@ TEST_P(PacingControllerTest, Pause) {
TEST_P(PacingControllerTest, InactiveFromStart) { TEST_P(PacingControllerTest, InactiveFromStart) {
// Recreate the pacer without the inital time forwarding. // Recreate the pacer without the inital time forwarding.
pacer_ = std::make_unique<PacingController>(&clock_, &callback_, nullptr, pacer_ = std::make_unique<PacingController>(&clock_, &callback_, trials_,
trials_, GetParam()); GetParam());
pacer_->SetProbingEnabled(false); pacer_->SetProbingEnabled(false);
pacer_->SetPacingRates(kTargetRate * kPaceMultiplier, kTargetRate); pacer_->SetPacingRates(kTargetRate * kPaceMultiplier, kTargetRate);
@ -1345,8 +1345,8 @@ TEST_P(PacingControllerTest, ProbingWithInsertedPackets) {
uint16_t sequence_number = 1234; uint16_t sequence_number = 1234;
PacingControllerProbing packet_sender; PacingControllerProbing packet_sender;
pacer_ = std::make_unique<PacingController>(&clock_, &packet_sender, nullptr, pacer_ = std::make_unique<PacingController>(&clock_, &packet_sender, trials_,
trials_, GetParam()); GetParam());
pacer_->CreateProbeCluster(kFirstClusterRate, pacer_->CreateProbeCluster(kFirstClusterRate,
/*cluster_id=*/0); /*cluster_id=*/0);
pacer_->CreateProbeCluster(kSecondClusterRate, pacer_->CreateProbeCluster(kSecondClusterRate,
@ -1405,8 +1405,8 @@ TEST_P(PacingControllerTest, SkipsProbesWhenProcessIntervalTooLarge) {
"abort_delayed_probes:1,max_probe_delay:2ms/" "abort_delayed_probes:1,max_probe_delay:2ms/"
: "WebRTC-Bwe-ProbingBehavior/" : "WebRTC-Bwe-ProbingBehavior/"
"abort_delayed_probes:0,max_probe_delay:2ms/"); "abort_delayed_probes:0,max_probe_delay:2ms/");
pacer_ = std::make_unique<PacingController>(&clock_, &packet_sender, pacer_ = std::make_unique<PacingController>(&clock_, &packet_sender, trials,
nullptr, trials, GetParam()); GetParam());
pacer_->SetPacingRates( pacer_->SetPacingRates(
DataRate::BitsPerSec(kInitialBitrateBps * kPaceMultiplier), DataRate::BitsPerSec(kInitialBitrateBps * kPaceMultiplier),
DataRate::BitsPerSec(kInitialBitrateBps)); DataRate::BitsPerSec(kInitialBitrateBps));
@ -1512,8 +1512,8 @@ TEST_P(PacingControllerTest, ProbingWithPaddingSupport) {
uint16_t sequence_number = 1234; uint16_t sequence_number = 1234;
PacingControllerProbing packet_sender; PacingControllerProbing packet_sender;
pacer_ = std::make_unique<PacingController>(&clock_, &packet_sender, nullptr, pacer_ = std::make_unique<PacingController>(&clock_, &packet_sender, trials_,
trials_, GetParam()); GetParam());
pacer_->CreateProbeCluster(kFirstClusterRate, pacer_->CreateProbeCluster(kFirstClusterRate,
/*cluster_id=*/0); /*cluster_id=*/0);
pacer_->SetPacingRates( pacer_->SetPacingRates(
@ -1578,8 +1578,8 @@ TEST_P(PacingControllerTest, PaddingOveruse) {
TEST_P(PacingControllerTest, ProbeClusterId) { TEST_P(PacingControllerTest, ProbeClusterId) {
MockPacketSender callback; MockPacketSender callback;
pacer_ = std::make_unique<PacingController>(&clock_, &callback, nullptr, pacer_ = std::make_unique<PacingController>(&clock_, &callback, trials_,
trials_, GetParam()); GetParam());
Init(); Init();
uint32_t ssrc = 12346; uint32_t ssrc = 12346;
@ -1635,8 +1635,8 @@ TEST_P(PacingControllerTest, ProbeClusterId) {
TEST_P(PacingControllerTest, OwnedPacketPrioritizedOnType) { TEST_P(PacingControllerTest, OwnedPacketPrioritizedOnType) {
MockPacketSender callback; MockPacketSender callback;
pacer_ = std::make_unique<PacingController>(&clock_, &callback, nullptr, pacer_ = std::make_unique<PacingController>(&clock_, &callback, trials_,
trials_, GetParam()); GetParam());
Init(); Init();
// Insert a packet of each type, from low to high priority. Since priority // 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) { TEST_P(PacingControllerTest, SmallFirstProbePacket) {
MockPacketSender callback; MockPacketSender callback;
pacer_ = std::make_unique<PacingController>(&clock_, &callback, nullptr, pacer_ = std::make_unique<PacingController>(&clock_, &callback, trials_,
trials_, GetParam()); GetParam());
pacer_->CreateProbeCluster(kFirstClusterRate, /*cluster_id=*/0); pacer_->CreateProbeCluster(kFirstClusterRate, /*cluster_id=*/0);
pacer_->SetPacingRates(kTargetRate * kPaceMultiplier, DataRate::Zero()); pacer_->SetPacingRates(kTargetRate * kPaceMultiplier, DataRate::Zero());
@ -1841,8 +1841,8 @@ TEST_P(PacingControllerTest,
uint16_t sequence_number = 1234; uint16_t sequence_number = 1234;
MockPacketSender callback; MockPacketSender callback;
EXPECT_CALL(callback, SendPacket).Times(::testing::AnyNumber()); EXPECT_CALL(callback, SendPacket).Times(::testing::AnyNumber());
pacer_ = std::make_unique<PacingController>(&clock_, &callback, nullptr, pacer_ = std::make_unique<PacingController>(&clock_, &callback, trials_,
trials_, GetParam()); GetParam());
pacer_->SetAccountForAudioPackets(account_for_audio); pacer_->SetAccountForAudioPackets(account_for_audio);
// First, saturate the padding budget. // First, saturate the padding budget.
@ -2020,8 +2020,8 @@ TEST_P(PacingControllerTest, PaddingTargetAccountsForPaddingRate) {
"WebRTC-Pacer-DynamicPaddingTarget/timedelta:10ms/"); "WebRTC-Pacer-DynamicPaddingTarget/timedelta:10ms/");
srand(0); srand(0);
// Need to initialize PacingController after we initialize clock. // Need to initialize PacingController after we initialize clock.
pacer_ = std::make_unique<PacingController>(&clock_, &callback_, nullptr, pacer_ = std::make_unique<PacingController>(&clock_, &callback_, field_trials,
field_trials, GetParam()); GetParam());
Init(); Init();
const uint32_t kSsrc = 12345; 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) int max_hold_back_window_in_packets)
: TaskQueuePacedSender(clock, : TaskQueuePacedSender(clock,
packet_sender, packet_sender,
event_log,
*field_trials, *field_trials,
task_queue_factory, task_queue_factory,
max_hold_back_window, max_hold_back_window,
@ -48,7 +47,6 @@ TaskQueuePacedSender::TaskQueuePacedSender(
TaskQueuePacedSender::TaskQueuePacedSender( TaskQueuePacedSender::TaskQueuePacedSender(
Clock* clock, Clock* clock,
PacingController::PacketSender* packet_sender, PacingController::PacketSender* packet_sender,
RtcEventLog* event_log,
const WebRtcKeyValueConfig& field_trials, const WebRtcKeyValueConfig& field_trials,
TaskQueueFactory* task_queue_factory, TaskQueueFactory* task_queue_factory,
TimeDelta max_hold_back_window, TimeDelta max_hold_back_window,
@ -63,7 +61,6 @@ TaskQueuePacedSender::TaskQueuePacedSender(
allow_low_precision_ ? 0 : max_hold_back_window_in_packets), allow_low_precision_ ? 0 : max_hold_back_window_in_packets),
pacing_controller_(clock, pacing_controller_(clock,
packet_sender, packet_sender,
event_log,
field_trials, field_trials,
PacingController::ProcessMode::kDynamic), PacingController::ProcessMode::kDynamic),
next_process_time_(Timestamp::MinusInfinity()), next_process_time_(Timestamp::MinusInfinity()),

19
modules/pacing/task_queue_paced_sender.h
View File

@ -37,11 +37,11 @@
namespace webrtc { namespace webrtc {
class Clock; class Clock;
class RtcEventLog;
class TaskQueuePacedSender : public RtpPacketPacer, public RtpPacketSender { class TaskQueuePacedSender : public RtpPacketPacer, public RtpPacketSender {
public: 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( TaskQueuePacedSender(
Clock* clock, Clock* clock,
PacingController::PacketSender* packet_sender, 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 // there is currently a pacer queue and packets can't immediately be
// processed. Increasing this reduces thread wakeups at the expense of higher // processed. Increasing this reduces thread wakeups at the expense of higher
// latency. // latency.
// TODO(bugs.webrtc.org/10809): Remove default values. TaskQueuePacedSender(Clock* clock,
TaskQueuePacedSender( PacingController::PacketSender* packet_sender,
Clock* clock, const WebRtcKeyValueConfig& field_trials,
PacingController::PacketSender* packet_sender, TaskQueueFactory* task_queue_factory,
RtcEventLog* event_log, TimeDelta max_hold_back_window,
const WebRtcKeyValueConfig& field_trials, int max_hold_back_window_in_packets);
TaskQueueFactory* task_queue_factory,
TimeDelta max_hold_back_window = PacingController::kMinSleepTime,
int max_hold_back_window_in_packets = -1);
~TaskQueuePacedSender() override; ~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)); GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
MockPacketRouter packet_router; MockPacketRouter packet_router;
ScopedKeyValueConfig trials; ScopedKeyValueConfig trials;
TaskQueuePacedSender pacer( TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
time_controller.GetClock(), &packet_router, time_controller.GetTaskQueueFactory(),
/*event_log=*/nullptr, trials, time_controller.GetTaskQueueFactory(), PacingController::kMinSleepTime,
PacingController::kMinSleepTime, kNoPacketHoldback); kNoPacketHoldback);
// Insert a number of packets, covering one second. // Insert a number of packets, covering one second.
static constexpr size_t kPacketsToSend = 42; static constexpr size_t kPacketsToSend = 42;
@ -243,10 +243,10 @@ TEST(TaskQueuePacedSenderTest, ReschedulesProcessOnRateChange) {
GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234)); GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
MockPacketRouter packet_router; MockPacketRouter packet_router;
ScopedKeyValueConfig trials; ScopedKeyValueConfig trials;
TaskQueuePacedSender pacer( TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
time_controller.GetClock(), &packet_router, time_controller.GetTaskQueueFactory(),
/*event_log=*/nullptr, trials, time_controller.GetTaskQueueFactory(), PacingController::kMinSleepTime,
PacingController::kMinSleepTime, kNoPacketHoldback); kNoPacketHoldback);
// Insert a number of packets to be sent 200ms apart. // Insert a number of packets to be sent 200ms apart.
const size_t kPacketsPerSecond = 5; const size_t kPacketsPerSecond = 5;
@ -295,10 +295,10 @@ TEST(TaskQueuePacedSenderTest, SendsAudioImmediately) {
GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234)); GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
MockPacketRouter packet_router; MockPacketRouter packet_router;
ScopedKeyValueConfig trials; ScopedKeyValueConfig trials;
TaskQueuePacedSender pacer( TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
time_controller.GetClock(), &packet_router, time_controller.GetTaskQueueFactory(),
/*event_log=*/nullptr, trials, time_controller.GetTaskQueueFactory(), PacingController::kMinSleepTime,
PacingController::kMinSleepTime, kNoPacketHoldback); kNoPacketHoldback);
const DataRate kPacingDataRate = DataRate::KilobitsPerSec(125); const DataRate kPacingDataRate = DataRate::KilobitsPerSec(125);
const DataSize kPacketSize = DataSize::Bytes(kDefaultPacketSize); const DataSize kPacketSize = DataSize::Bytes(kDefaultPacketSize);
@ -328,8 +328,7 @@ TEST(TaskQueuePacedSenderTest, SleepsDuringCoalscingWindow) {
GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234)); GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
MockPacketRouter packet_router; MockPacketRouter packet_router;
ScopedKeyValueConfig trials; ScopedKeyValueConfig trials;
TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
/*event_log=*/nullptr, trials,
time_controller.GetTaskQueueFactory(), time_controller.GetTaskQueueFactory(),
kCoalescingWindow, kNoPacketHoldback); kCoalescingWindow, kNoPacketHoldback);
@ -365,8 +364,7 @@ TEST(TaskQueuePacedSenderTest, ProbingOverridesCoalescingWindow) {
GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234)); GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
MockPacketRouter packet_router; MockPacketRouter packet_router;
ScopedKeyValueConfig trials; ScopedKeyValueConfig trials;
TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
/*event_log=*/nullptr, trials,
time_controller.GetTaskQueueFactory(), time_controller.GetTaskQueueFactory(),
kCoalescingWindow, kNoPacketHoldback); kCoalescingWindow, kNoPacketHoldback);
@ -397,10 +395,10 @@ TEST(TaskQueuePacedSenderTest, SchedulesProbeAtSetTime) {
"WebRTC-Bwe-ProbingBehavior/min_probe_delta:1ms/"); "WebRTC-Bwe-ProbingBehavior/min_probe_delta:1ms/");
GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234)); GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
MockPacketRouter packet_router; MockPacketRouter packet_router;
TaskQueuePacedSender pacer( TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
time_controller.GetClock(), &packet_router, time_controller.GetTaskQueueFactory(),
/*event_log=*/nullptr, trials, time_controller.GetTaskQueueFactory(), PacingController::kMinSleepTime,
PacingController::kMinSleepTime, kNoPacketHoldback); kNoPacketHoldback);
// Set rates so one packet adds 4ms of buffer level. // Set rates so one packet adds 4ms of buffer level.
const DataSize kPacketSize = DataSize::Bytes(kDefaultPacketSize); const DataSize kPacketSize = DataSize::Bytes(kDefaultPacketSize);
@ -464,10 +462,10 @@ TEST(TaskQueuePacedSenderTest, NoMinSleepTimeWhenProbing) {
"WebRTC-Bwe-ProbingBehavior/min_probe_delta:100us/"); "WebRTC-Bwe-ProbingBehavior/min_probe_delta:100us/");
GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234)); GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
MockPacketRouter packet_router; MockPacketRouter packet_router;
TaskQueuePacedSender pacer( TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
time_controller.GetClock(), &packet_router, time_controller.GetTaskQueueFactory(),
/*event_log=*/nullptr, trials, time_controller.GetTaskQueueFactory(), PacingController::kMinSleepTime,
PacingController::kMinSleepTime, kNoPacketHoldback); kNoPacketHoldback);
// Set rates so one packet adds 4ms of buffer level. // Set rates so one packet adds 4ms of buffer level.
const DataSize kPacketSize = DataSize::Bytes(kDefaultPacketSize); const DataSize kPacketSize = DataSize::Bytes(kDefaultPacketSize);
@ -520,8 +518,7 @@ TEST(TaskQueuePacedSenderTest, PacketBasedCoalescing) {
GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234)); GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
MockPacketRouter packet_router; MockPacketRouter packet_router;
ScopedKeyValueConfig trials; ScopedKeyValueConfig trials;
TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
/*event_log=*/nullptr, trials,
time_controller.GetTaskQueueFactory(), time_controller.GetTaskQueueFactory(),
kFixedCoalescingWindow, kPacketBasedHoldback); kFixedCoalescingWindow, kPacketBasedHoldback);
@ -571,8 +568,7 @@ TEST(TaskQueuePacedSenderTest, FixedHoldBackHasPriorityOverPackets) {
GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234)); GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
MockPacketRouter packet_router; MockPacketRouter packet_router;
ScopedKeyValueConfig trials; ScopedKeyValueConfig trials;
TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
/*event_log=*/nullptr, trials,
time_controller.GetTaskQueueFactory(), time_controller.GetTaskQueueFactory(),
kFixedCoalescingWindow, kPacketBasedHoldback); kFixedCoalescingWindow, kPacketBasedHoldback);
@ -617,10 +613,10 @@ TEST(TaskQueuePacedSenderTest, Stats) {
GlobalSimulatedTimeController time_controller(kStartTime); GlobalSimulatedTimeController time_controller(kStartTime);
MockPacketRouter packet_router; MockPacketRouter packet_router;
ScopedKeyValueConfig trials; ScopedKeyValueConfig trials;
TaskQueuePacedSender pacer( TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
time_controller.GetClock(), &packet_router, time_controller.GetTaskQueueFactory(),
/*event_log=*/nullptr, trials, time_controller.GetTaskQueueFactory(), PacingController::kMinSleepTime,
PacingController::kMinSleepTime, kNoPacketHoldback); kNoPacketHoldback);
// Simulate ~2mbps video stream, covering one second. // Simulate ~2mbps video stream, covering one second.
static constexpr size_t kPacketsToSend = 200; static constexpr size_t kPacketsToSend = 200;
@ -693,9 +689,8 @@ TEST(TaskQueuePacedSenderTest, HighPrecisionPacingWhenSlackIsDisabled) {
MockPacketRouter packet_router; MockPacketRouter packet_router;
TaskQueuePacedSender pacer( TaskQueuePacedSender pacer(
time_controller.GetClock(), &packet_router, /*event_log=*/nullptr, time_controller.GetClock(), &packet_router, experiments,
experiments, &task_queue_factory, PacingController::kMinSleepTime, &task_queue_factory, PacingController::kMinSleepTime, kNoPacketHoldback);
kNoPacketHoldback);
// Send enough packets (covering one second) that pacing is triggered, i.e. // Send enough packets (covering one second) that pacing is triggered, i.e.
// delayed tasks being scheduled. // delayed tasks being scheduled.
@ -737,9 +732,8 @@ TEST(TaskQueuePacedSenderTest, LowPrecisionPacingWhenSlackIsEnabled) {
MockPacketRouter packet_router; MockPacketRouter packet_router;
TaskQueuePacedSender pacer( TaskQueuePacedSender pacer(
time_controller.GetClock(), &packet_router, /*event_log=*/nullptr, time_controller.GetClock(), &packet_router, experiments,
experiments, &task_queue_factory, PacingController::kMinSleepTime, &task_queue_factory, PacingController::kMinSleepTime, kNoPacketHoldback);
kNoPacketHoldback);
// Send enough packets (covering one second) that pacing is triggered, i.e. // Send enough packets (covering one second) that pacing is triggered, i.e.
// delayed tasks being scheduled. // delayed tasks being scheduled.