1 /*
2 * Copyright (c) 2019 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "modules/pacing/task_queue_paced_sender.h"
12
13 #include <algorithm>
14 #include <list>
15 #include <memory>
16 #include <string>
17 #include <utility>
18 #include <vector>
19
20 #include "api/transport/network_types.h"
21 #include "modules/pacing/packet_router.h"
22 #include "modules/utility/include/mock/mock_process_thread.h"
23 #include "test/field_trial.h"
24 #include "test/gmock.h"
25 #include "test/gtest.h"
26 #include "test/time_controller/simulated_time_controller.h"
27
28 using ::testing::_;
29 using ::testing::AtLeast;
30 using ::testing::Return;
31 using ::testing::SaveArg;
32
33 namespace webrtc {
34 namespace {
35 constexpr uint32_t kAudioSsrc = 12345;
36 constexpr uint32_t kVideoSsrc = 234565;
37 constexpr uint32_t kVideoRtxSsrc = 34567;
38 constexpr uint32_t kFlexFecSsrc = 45678;
39 constexpr size_t kDefaultPacketSize = 1234;
40
41 class MockPacketRouter : public PacketRouter {
42 public:
43 MOCK_METHOD(void,
44 SendPacket,
45 (std::unique_ptr<RtpPacketToSend> packet,
46 const PacedPacketInfo& cluster_info),
47 (override));
48 MOCK_METHOD(std::vector<std::unique_ptr<RtpPacketToSend>>,
49 FetchFec,
50 (),
51 (override));
52 MOCK_METHOD(std::vector<std::unique_ptr<RtpPacketToSend>>,
53 GeneratePadding,
54 (DataSize target_size),
55 (override));
56 };
57
58 class StatsUpdateObserver {
59 public:
60 StatsUpdateObserver() = default;
61 virtual ~StatsUpdateObserver() = default;
62
63 virtual void OnStatsUpdated() = 0;
64 };
65
66 class TaskQueuePacedSenderForTest : public TaskQueuePacedSender {
67 public:
TaskQueuePacedSenderForTest(Clock * clock,PacketRouter * packet_router,RtcEventLog * event_log,const WebRtcKeyValueConfig * field_trials,TaskQueueFactory * task_queue_factory,TimeDelta hold_back_window)68 TaskQueuePacedSenderForTest(Clock* clock,
69 PacketRouter* packet_router,
70 RtcEventLog* event_log,
71 const WebRtcKeyValueConfig* field_trials,
72 TaskQueueFactory* task_queue_factory,
73 TimeDelta hold_back_window)
74 : TaskQueuePacedSender(clock,
75 packet_router,
76 event_log,
77 field_trials,
78 task_queue_factory,
79 hold_back_window) {}
80
OnStatsUpdated(const Stats & stats)81 void OnStatsUpdated(const Stats& stats) override {
82 ++num_stats_updates_;
83 TaskQueuePacedSender::OnStatsUpdated(stats);
84 }
85
86 size_t num_stats_updates_ = 0;
87 };
88
GeneratePadding(DataSize target_size)89 std::vector<std::unique_ptr<RtpPacketToSend>> GeneratePadding(
90 DataSize target_size) {
91 // 224 bytes is the max padding size for plain padding packets generated by
92 // RTPSender::GeneratePadding().
93 const DataSize kMaxPaddingPacketSize = DataSize::Bytes(224);
94 DataSize padding_generated = DataSize::Zero();
95 std::vector<std::unique_ptr<RtpPacketToSend>> padding_packets;
96 while (padding_generated < target_size) {
97 DataSize packet_size =
98 std::min(target_size - padding_generated, kMaxPaddingPacketSize);
99 padding_generated += packet_size;
100 auto padding_packet =
101 std::make_unique<RtpPacketToSend>(/*extensions=*/nullptr);
102 padding_packet->set_packet_type(RtpPacketMediaType::kPadding);
103 padding_packet->SetPadding(packet_size.bytes());
104 padding_packets.push_back(std::move(padding_packet));
105 }
106 return padding_packets;
107 }
108
109 } // namespace
110
111 namespace test {
112
BuildRtpPacket(RtpPacketMediaType type)113 std::unique_ptr<RtpPacketToSend> BuildRtpPacket(RtpPacketMediaType type) {
114 auto packet = std::make_unique<RtpPacketToSend>(nullptr);
115 packet->set_packet_type(type);
116 switch (type) {
117 case RtpPacketMediaType::kAudio:
118 packet->SetSsrc(kAudioSsrc);
119 break;
120 case RtpPacketMediaType::kVideo:
121 packet->SetSsrc(kVideoSsrc);
122 break;
123 case RtpPacketMediaType::kRetransmission:
124 case RtpPacketMediaType::kPadding:
125 packet->SetSsrc(kVideoRtxSsrc);
126 break;
127 case RtpPacketMediaType::kForwardErrorCorrection:
128 packet->SetSsrc(kFlexFecSsrc);
129 break;
130 }
131
132 packet->SetPayloadSize(kDefaultPacketSize);
133 return packet;
134 }
135
GeneratePackets(RtpPacketMediaType type,size_t num_packets)136 std::vector<std::unique_ptr<RtpPacketToSend>> GeneratePackets(
137 RtpPacketMediaType type,
138 size_t num_packets) {
139 std::vector<std::unique_ptr<RtpPacketToSend>> packets;
140 for (size_t i = 0; i < num_packets; ++i) {
141 packets.push_back(BuildRtpPacket(type));
142 }
143 return packets;
144 }
145
TEST(TaskQueuePacedSenderTest,PacesPackets)146 TEST(TaskQueuePacedSenderTest, PacesPackets) {
147 GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
148 MockPacketRouter packet_router;
149 TaskQueuePacedSenderForTest pacer(
150 time_controller.GetClock(), &packet_router,
151 /*event_log=*/nullptr,
152 /*field_trials=*/nullptr, time_controller.GetTaskQueueFactory(),
153 PacingController::kMinSleepTime);
154
155 // Insert a number of packets, covering one second.
156 static constexpr size_t kPacketsToSend = 42;
157 pacer.SetPacingRates(
158 DataRate::BitsPerSec(kDefaultPacketSize * 8 * kPacketsToSend),
159 DataRate::Zero());
160 pacer.EnqueuePackets(
161 GeneratePackets(RtpPacketMediaType::kVideo, kPacketsToSend));
162
163 // Expect all of them to be sent.
164 size_t packets_sent = 0;
165 Timestamp end_time = Timestamp::PlusInfinity();
166 EXPECT_CALL(packet_router, SendPacket)
167 .WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> packet,
168 const PacedPacketInfo& cluster_info) {
169 ++packets_sent;
170 if (packets_sent == kPacketsToSend) {
171 end_time = time_controller.GetClock()->CurrentTime();
172 }
173 });
174
175 const Timestamp start_time = time_controller.GetClock()->CurrentTime();
176
177 // Packets should be sent over a period of close to 1s. Expect a little
178 // lower than this since initial probing is a bit quicker.
179 time_controller.AdvanceTime(TimeDelta::Seconds(1));
180 EXPECT_EQ(packets_sent, kPacketsToSend);
181 ASSERT_TRUE(end_time.IsFinite());
182 EXPECT_NEAR((end_time - start_time).ms<double>(), 1000.0, 50.0);
183 }
184
TEST(TaskQueuePacedSenderTest,ReschedulesProcessOnRateChange)185 TEST(TaskQueuePacedSenderTest, ReschedulesProcessOnRateChange) {
186 GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
187 MockPacketRouter packet_router;
188 TaskQueuePacedSenderForTest pacer(
189 time_controller.GetClock(), &packet_router,
190 /*event_log=*/nullptr,
191 /*field_trials=*/nullptr, time_controller.GetTaskQueueFactory(),
192 PacingController::kMinSleepTime);
193
194 // Insert a number of packets to be sent 200ms apart.
195 const size_t kPacketsPerSecond = 5;
196 const DataRate kPacingRate =
197 DataRate::BitsPerSec(kDefaultPacketSize * 8 * kPacketsPerSecond);
198 pacer.SetPacingRates(kPacingRate, DataRate::Zero());
199
200 // Send some initial packets to be rid of any probes.
201 EXPECT_CALL(packet_router, SendPacket).Times(kPacketsPerSecond);
202 pacer.EnqueuePackets(
203 GeneratePackets(RtpPacketMediaType::kVideo, kPacketsPerSecond));
204 time_controller.AdvanceTime(TimeDelta::Seconds(1));
205
206 // Insert three packets, and record send time of each of them.
207 // After the second packet is sent, double the send rate so we can
208 // check the third packets is sent after half the wait time.
209 Timestamp first_packet_time = Timestamp::MinusInfinity();
210 Timestamp second_packet_time = Timestamp::MinusInfinity();
211 Timestamp third_packet_time = Timestamp::MinusInfinity();
212
213 EXPECT_CALL(packet_router, SendPacket)
214 .Times(3)
215 .WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> packet,
216 const PacedPacketInfo& cluster_info) {
217 if (first_packet_time.IsInfinite()) {
218 first_packet_time = time_controller.GetClock()->CurrentTime();
219 } else if (second_packet_time.IsInfinite()) {
220 second_packet_time = time_controller.GetClock()->CurrentTime();
221 pacer.SetPacingRates(2 * kPacingRate, DataRate::Zero());
222 } else {
223 third_packet_time = time_controller.GetClock()->CurrentTime();
224 }
225 });
226
227 pacer.EnqueuePackets(GeneratePackets(RtpPacketMediaType::kVideo, 3));
228 time_controller.AdvanceTime(TimeDelta::Millis(500));
229 ASSERT_TRUE(third_packet_time.IsFinite());
230 EXPECT_NEAR((second_packet_time - first_packet_time).ms<double>(), 200.0,
231 1.0);
232 EXPECT_NEAR((third_packet_time - second_packet_time).ms<double>(), 100.0,
233 1.0);
234 }
235
TEST(TaskQueuePacedSenderTest,SendsAudioImmediately)236 TEST(TaskQueuePacedSenderTest, SendsAudioImmediately) {
237 GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
238 MockPacketRouter packet_router;
239 TaskQueuePacedSenderForTest pacer(
240 time_controller.GetClock(), &packet_router,
241 /*event_log=*/nullptr,
242 /*field_trials=*/nullptr, time_controller.GetTaskQueueFactory(),
243 PacingController::kMinSleepTime);
244
245 const DataRate kPacingDataRate = DataRate::KilobitsPerSec(125);
246 const DataSize kPacketSize = DataSize::Bytes(kDefaultPacketSize);
247 const TimeDelta kPacketPacingTime = kPacketSize / kPacingDataRate;
248
249 pacer.SetPacingRates(kPacingDataRate, DataRate::Zero());
250
251 // Add some initial video packets, only one should be sent.
252 EXPECT_CALL(packet_router, SendPacket);
253 pacer.EnqueuePackets(GeneratePackets(RtpPacketMediaType::kVideo, 10));
254 time_controller.AdvanceTime(TimeDelta::Zero());
255 ::testing::Mock::VerifyAndClearExpectations(&packet_router);
256
257 // Advance time, but still before next packet should be sent.
258 time_controller.AdvanceTime(kPacketPacingTime / 2);
259
260 // Insert an audio packet, it should be sent immediately.
261 EXPECT_CALL(packet_router, SendPacket);
262 pacer.EnqueuePackets(GeneratePackets(RtpPacketMediaType::kAudio, 1));
263 time_controller.AdvanceTime(TimeDelta::Zero());
264 ::testing::Mock::VerifyAndClearExpectations(&packet_router);
265 }
266
TEST(TaskQueuePacedSenderTest,SleepsDuringCoalscingWindow)267 TEST(TaskQueuePacedSenderTest, SleepsDuringCoalscingWindow) {
268 const TimeDelta kCoalescingWindow = TimeDelta::Millis(5);
269 GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
270 MockPacketRouter packet_router;
271 TaskQueuePacedSenderForTest pacer(
272 time_controller.GetClock(), &packet_router,
273 /*event_log=*/nullptr,
274 /*field_trials=*/nullptr, time_controller.GetTaskQueueFactory(),
275 kCoalescingWindow);
276
277 // Set rates so one packet adds one ms of buffer level.
278 const DataSize kPacketSize = DataSize::Bytes(kDefaultPacketSize);
279 const TimeDelta kPacketPacingTime = TimeDelta::Millis(1);
280 const DataRate kPacingDataRate = kPacketSize / kPacketPacingTime;
281
282 pacer.SetPacingRates(kPacingDataRate, DataRate::Zero());
283
284 // Add 10 packets. The first should be sent immediately since the buffers
285 // are clear.
286 EXPECT_CALL(packet_router, SendPacket);
287 pacer.EnqueuePackets(GeneratePackets(RtpPacketMediaType::kVideo, 10));
288 time_controller.AdvanceTime(TimeDelta::Zero());
289 ::testing::Mock::VerifyAndClearExpectations(&packet_router);
290
291 // Advance time to 1ms before the coalescing window ends. No packets should
292 // be sent.
293 EXPECT_CALL(packet_router, SendPacket).Times(0);
294 time_controller.AdvanceTime(kCoalescingWindow - TimeDelta::Millis(1));
295
296 // Advance time to where coalescing window ends. All packets that should
297 // have been sent up til now will be sent.
298 EXPECT_CALL(packet_router, SendPacket).Times(5);
299 time_controller.AdvanceTime(TimeDelta::Millis(1));
300 ::testing::Mock::VerifyAndClearExpectations(&packet_router);
301 }
302
TEST(TaskQueuePacedSenderTest,ProbingOverridesCoalescingWindow)303 TEST(TaskQueuePacedSenderTest, ProbingOverridesCoalescingWindow) {
304 const TimeDelta kCoalescingWindow = TimeDelta::Millis(5);
305 GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
306 MockPacketRouter packet_router;
307 TaskQueuePacedSenderForTest pacer(
308 time_controller.GetClock(), &packet_router,
309 /*event_log=*/nullptr,
310 /*field_trials=*/nullptr, time_controller.GetTaskQueueFactory(),
311 kCoalescingWindow);
312
313 // Set rates so one packet adds one ms of buffer level.
314 const DataSize kPacketSize = DataSize::Bytes(kDefaultPacketSize);
315 const TimeDelta kPacketPacingTime = TimeDelta::Millis(1);
316 const DataRate kPacingDataRate = kPacketSize / kPacketPacingTime;
317
318 pacer.SetPacingRates(kPacingDataRate, DataRate::Zero());
319
320 // Add 10 packets. The first should be sent immediately since the buffers
321 // are clear. This will also trigger the probe to start.
322 EXPECT_CALL(packet_router, SendPacket).Times(AtLeast(1));
323 pacer.CreateProbeCluster(kPacingDataRate * 2, 17);
324 pacer.EnqueuePackets(GeneratePackets(RtpPacketMediaType::kVideo, 10));
325 time_controller.AdvanceTime(TimeDelta::Zero());
326 ::testing::Mock::VerifyAndClearExpectations(&packet_router);
327
328 // Advance time to 1ms before the coalescing window ends. Packets should be
329 // flying.
330 EXPECT_CALL(packet_router, SendPacket).Times(AtLeast(1));
331 time_controller.AdvanceTime(kCoalescingWindow - TimeDelta::Millis(1));
332 }
333
TEST(TaskQueuePacedSenderTest,RespectedMinTimeBetweenStatsUpdates)334 TEST(TaskQueuePacedSenderTest, RespectedMinTimeBetweenStatsUpdates) {
335 const TimeDelta kCoalescingWindow = TimeDelta::Millis(5);
336 GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
337 MockPacketRouter packet_router;
338 TaskQueuePacedSenderForTest pacer(
339 time_controller.GetClock(), &packet_router,
340 /*event_log=*/nullptr,
341 /*field_trials=*/nullptr, time_controller.GetTaskQueueFactory(),
342 kCoalescingWindow);
343 const DataRate kPacingDataRate = DataRate::KilobitsPerSec(300);
344 pacer.SetPacingRates(kPacingDataRate, DataRate::Zero());
345
346 const TimeDelta kMinTimeBetweenStatsUpdates = TimeDelta::Millis(1);
347
348 // Nothing inserted, no stats updates yet.
349 EXPECT_EQ(pacer.num_stats_updates_, 0u);
350
351 // Insert one packet, stats should be updated.
352 pacer.EnqueuePackets(GeneratePackets(RtpPacketMediaType::kVideo, 1));
353 time_controller.AdvanceTime(TimeDelta::Zero());
354 EXPECT_EQ(pacer.num_stats_updates_, 1u);
355
356 // Advance time half of the min stats update interval, and trigger a
357 // refresh - stats should not be updated yet.
358 time_controller.AdvanceTime(kMinTimeBetweenStatsUpdates / 2);
359 pacer.EnqueuePackets({});
360 time_controller.AdvanceTime(TimeDelta::Zero());
361 EXPECT_EQ(pacer.num_stats_updates_, 1u);
362
363 // Advance time the next half, now stats update is triggered.
364 time_controller.AdvanceTime(kMinTimeBetweenStatsUpdates / 2);
365 pacer.EnqueuePackets({});
366 time_controller.AdvanceTime(TimeDelta::Zero());
367 EXPECT_EQ(pacer.num_stats_updates_, 2u);
368 }
369
TEST(TaskQueuePacedSenderTest,ThrottlesStatsUpdates)370 TEST(TaskQueuePacedSenderTest, ThrottlesStatsUpdates) {
371 const TimeDelta kCoalescingWindow = TimeDelta::Millis(5);
372 GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
373 MockPacketRouter packet_router;
374 TaskQueuePacedSenderForTest pacer(
375 time_controller.GetClock(), &packet_router,
376 /*event_log=*/nullptr,
377 /*field_trials=*/nullptr, time_controller.GetTaskQueueFactory(),
378 kCoalescingWindow);
379
380 // Set rates so one packet adds 10ms of buffer level.
381 const DataSize kPacketSize = DataSize::Bytes(kDefaultPacketSize);
382 const TimeDelta kPacketPacingTime = TimeDelta::Millis(10);
383 const DataRate kPacingDataRate = kPacketSize / kPacketPacingTime;
384 const TimeDelta kMinTimeBetweenStatsUpdates = TimeDelta::Millis(1);
385 const TimeDelta kMaxTimeBetweenStatsUpdates = TimeDelta::Millis(33);
386
387 // Nothing inserted, no stats updates yet.
388 size_t num_expected_stats_updates = 0;
389 EXPECT_EQ(pacer.num_stats_updates_, num_expected_stats_updates);
390 pacer.SetPacingRates(kPacingDataRate, DataRate::Zero());
391 time_controller.AdvanceTime(kMinTimeBetweenStatsUpdates);
392 // Updating pacing rates refreshes stats.
393 EXPECT_EQ(pacer.num_stats_updates_, ++num_expected_stats_updates);
394
395 // Record time when we insert first packet, this triggers the scheduled
396 // stats updating.
397 Clock* const clock = time_controller.GetClock();
398 const Timestamp start_time = clock->CurrentTime();
399
400 while (clock->CurrentTime() - start_time <=
401 kMaxTimeBetweenStatsUpdates - kPacketPacingTime) {
402 // Enqueue packet, expect stats update.
403 pacer.EnqueuePackets(GeneratePackets(RtpPacketMediaType::kVideo, 1));
404 time_controller.AdvanceTime(TimeDelta::Zero());
405 EXPECT_EQ(pacer.num_stats_updates_, ++num_expected_stats_updates);
406
407 // Advance time to halfway through pacing time, expect another stats
408 // update.
409 time_controller.AdvanceTime(kPacketPacingTime / 2);
410 pacer.EnqueuePackets({});
411 time_controller.AdvanceTime(TimeDelta::Zero());
412 EXPECT_EQ(pacer.num_stats_updates_, ++num_expected_stats_updates);
413
414 // Advance time the rest of the way.
415 time_controller.AdvanceTime(kPacketPacingTime / 2);
416 }
417
418 // At this point, the pace queue is drained so there is no more intersting
419 // update to be made - but there is still as schduled task that should run
420 // |kMaxTimeBetweenStatsUpdates| after the first update.
421 time_controller.AdvanceTime(start_time + kMaxTimeBetweenStatsUpdates -
422 clock->CurrentTime());
423 EXPECT_EQ(pacer.num_stats_updates_, ++num_expected_stats_updates);
424
425 // Advance time a significant time - don't expect any more calls as stats
426 // updating does not happen when queue is drained.
427 time_controller.AdvanceTime(TimeDelta::Millis(400));
428 EXPECT_EQ(pacer.num_stats_updates_, num_expected_stats_updates);
429 }
430
TEST(TaskQueuePacedSenderTest,SchedulesProbeAtSetTime)431 TEST(TaskQueuePacedSenderTest, SchedulesProbeAtSetTime) {
432 ScopedFieldTrials trials("WebRTC-Bwe-ProbingBehavior/min_probe_delta:1ms/");
433 GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
434 MockPacketRouter packet_router;
435 TaskQueuePacedSenderForTest pacer(
436 time_controller.GetClock(), &packet_router,
437 /*event_log=*/nullptr,
438 /*field_trials=*/nullptr, time_controller.GetTaskQueueFactory(),
439 PacingController::kMinSleepTime);
440
441 // Set rates so one packet adds 4ms of buffer level.
442 const DataSize kPacketSize = DataSize::Bytes(kDefaultPacketSize);
443 const TimeDelta kPacketPacingTime = TimeDelta::Millis(4);
444 const DataRate kPacingDataRate = kPacketSize / kPacketPacingTime;
445 pacer.SetPacingRates(kPacingDataRate, /*padding_rate=*/DataRate::Zero());
446 EXPECT_CALL(packet_router, FetchFec).WillRepeatedly([]() {
447 return std::vector<std::unique_ptr<RtpPacketToSend>>();
448 });
449 EXPECT_CALL(packet_router, GeneratePadding(_))
450 .WillRepeatedly(
451 [](DataSize target_size) { return GeneratePadding(target_size); });
452
453 // Enqueue two packets, only the first is sent immediately and the next
454 // will be scheduled for sending in 4ms.
455 pacer.EnqueuePackets(GeneratePackets(RtpPacketMediaType::kVideo, 2));
456 const int kNotAProbe = PacedPacketInfo::kNotAProbe;
457 EXPECT_CALL(
458 packet_router,
459 SendPacket(_, ::testing::Field(&PacedPacketInfo::probe_cluster_id,
460 kNotAProbe)));
461 // Advance to less than 3ms before next packet send time.
462 time_controller.AdvanceTime(TimeDelta::Micros(1001));
463
464 // Trigger a probe at 4x the current pacing rate and insert the number of
465 // packets the probe needs.
466 const DataRate kProbeRate = 2 * kPacingDataRate;
467 const int kProbeClusterId = 1;
468 pacer.CreateProbeCluster(kProbeRate, kProbeClusterId);
469
470 // Expected size for each probe in a cluster is twice the expected bits
471 // sent during min_probe_delta.
472 // Expect one additional call since probe always starts with a small
473 const TimeDelta kProbeTimeDelta = TimeDelta::Millis(2);
474 const DataSize kProbeSize = kProbeRate * kProbeTimeDelta;
475 const size_t kNumPacketsInProbe =
476 (kProbeSize + kPacketSize - DataSize::Bytes(1)) / kPacketSize;
477 EXPECT_CALL(
478 packet_router,
479 SendPacket(_, ::testing::Field(&PacedPacketInfo::probe_cluster_id,
480 kProbeClusterId)))
481 .Times(kNumPacketsInProbe + 1);
482
483 pacer.EnqueuePackets(
484 GeneratePackets(RtpPacketMediaType::kVideo, kNumPacketsInProbe));
485 time_controller.AdvanceTime(TimeDelta::Zero());
486
487 // The pacer should have scheduled the next probe to be sent in
488 // kProbeTimeDelta. That there was existing scheduled call less than
489 // PacingController::kMinSleepTime before this should not matter.
490
491 EXPECT_CALL(
492 packet_router,
493 SendPacket(_, ::testing::Field(&PacedPacketInfo::probe_cluster_id,
494 kProbeClusterId)))
495 .Times(AtLeast(1));
496 time_controller.AdvanceTime(TimeDelta::Millis(2));
497 }
498
TEST(TaskQueuePacedSenderTest,NoMinSleepTimeWhenProbing)499 TEST(TaskQueuePacedSenderTest, NoMinSleepTimeWhenProbing) {
500 // Set min_probe_delta to be less than kMinSleepTime (1ms).
501 const TimeDelta kMinProbeDelta = TimeDelta::Micros(100);
502 ScopedFieldTrials trials(
503 "WebRTC-Bwe-ProbingBehavior/min_probe_delta:100us/");
504 GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
505 MockPacketRouter packet_router;
506 TaskQueuePacedSenderForTest pacer(
507 time_controller.GetClock(), &packet_router,
508 /*event_log=*/nullptr,
509 /*field_trials=*/nullptr, time_controller.GetTaskQueueFactory(),
510 PacingController::kMinSleepTime);
511
512 // Set rates so one packet adds 4ms of buffer level.
513 const DataSize kPacketSize = DataSize::Bytes(kDefaultPacketSize);
514 const TimeDelta kPacketPacingTime = TimeDelta::Millis(4);
515 const DataRate kPacingDataRate = kPacketSize / kPacketPacingTime;
516 pacer.SetPacingRates(kPacingDataRate, /*padding_rate=*/DataRate::Zero());
517 EXPECT_CALL(packet_router, FetchFec).WillRepeatedly([]() {
518 return std::vector<std::unique_ptr<RtpPacketToSend>>();
519 });
520 EXPECT_CALL(packet_router, GeneratePadding)
521 .WillRepeatedly(
522 [](DataSize target_size) { return GeneratePadding(target_size); });
523
524 // Set a high probe rate.
525 const int kProbeClusterId = 1;
526 DataRate kProbingRate = kPacingDataRate * 10;
527 pacer.CreateProbeCluster(kProbingRate, kProbeClusterId);
528
529 // Advance time less than PacingController::kMinSleepTime, probing packets
530 // for the first millisecond should be sent immediately. Min delta between
531 // probes is 2x 100us, meaning 4 times per ms we will get least one call to
532 // SendPacket().
533 DataSize data_sent = DataSize::Zero();
534 EXPECT_CALL(
535 packet_router,
536 SendPacket(_, ::testing::Field(&PacedPacketInfo::probe_cluster_id,
537 kProbeClusterId)))
538 .Times(AtLeast(4))
539 .WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> packet,
540 const PacedPacketInfo&) {
541 data_sent +=
542 DataSize::Bytes(packet->payload_size() + packet->padding_size());
543 });
544
545 // Add one packet to kickstart probing, the rest will be padding packets.
546 pacer.EnqueuePackets(GeneratePackets(RtpPacketMediaType::kVideo, 1));
547 time_controller.AdvanceTime(kMinProbeDelta);
548
549 // Verify the amount of probing data sent.
550 // Probe always starts with a small (1 byte) padding packet that's not
551 // counted into the probe rate here.
552 EXPECT_EQ(data_sent,
553 kProbingRate * TimeDelta::Millis(1) + DataSize::Bytes(1));
554 }
555 } // namespace test
556 } // namespace webrtc
557