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