src/third_party/webrtc/modules/pacing/paced_sender_unittest.cc

   1 /*
   2  *  Copyright (c) 2012 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 <list>
  12
  13 #include "testing/gmock/include/gmock/gmock.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "webrtc/modules/pacing/include/paced_sender.h"
  16 #include "webrtc/system_wrappers/interface/clock.h"
  17
  18 using testing::_;
  19 using testing::Return;
  20
  21 namespace webrtc {
  22 namespace test {
  23
  24 static const int kTargetBitrate = 800;
  25 static const float kPaceMultiplier = 1.5f;
  26
  27 class MockPacedSenderCallback : public PacedSender::Callback {
  28  public:
  29   MOCK_METHOD4(TimeToSendPacket,
  30                bool(uint32_t ssrc,
  31                     uint16_t sequence_number,
  32                     int64_t capture_time_ms,
  33                     bool retransmission));
  34   MOCK_METHOD1(TimeToSendPadding,
  35       int(int bytes));
  36 };
  37
  38 class PacedSenderPadding : public PacedSender::Callback {
  39  public:
  40   PacedSenderPadding() : padding_sent_(0) {}
  41
  42   bool TimeToSendPacket(uint32_t ssrc,
  43                         uint16_t sequence_number,
  44                         int64_t capture_time_ms,
  45                         bool retransmission) {
  46     return true;
  47   }
  48
  49   int TimeToSendPadding(int bytes) {
  50     const int kPaddingPacketSize = 224;
  51     int num_packets = (bytes + kPaddingPacketSize - 1) / kPaddingPacketSize;
  52     padding_sent_ += kPaddingPacketSize * num_packets;
  53     return kPaddingPacketSize * num_packets;
  54   }
  55
  56   int padding_sent() { return padding_sent_; }
  57
  58  private:
  59   int padding_sent_;
  60 };
  61
  62 class PacedSenderProbing : public PacedSender::Callback {
  63  public:
  64   PacedSenderProbing(const std::list<int>& expected_deltas, Clock* clock)
  65       : prev_packet_time_ms_(-1),
  66         expected_deltas_(expected_deltas),
  67         packets_sent_(0),
  68         clock_(clock) {}
  69
  70   bool TimeToSendPacket(uint32_t ssrc,
  71                         uint16_t sequence_number,
  72                         int64_t capture_time_ms,
  73                         bool retransmission) {
  74     ++packets_sent_;
  75     EXPECT_FALSE(expected_deltas_.empty());
  76     if (expected_deltas_.empty())
  77       return false;
  78     int64_t now_ms = clock_->TimeInMilliseconds();
  79     if (prev_packet_time_ms_ >= 0) {
  80       EXPECT_EQ(expected_deltas_.front(), now_ms - prev_packet_time_ms_);
  81       expected_deltas_.pop_front();
  82     }
  83     prev_packet_time_ms_ = now_ms;
  84     return true;
  85   }
  86
  87   int TimeToSendPadding(int bytes) {
  88     EXPECT_TRUE(false);
  89     return bytes;
  90   }
  91
  92   int packets_sent() const { return packets_sent_; }
  93
  94  private:
  95   int64_t prev_packet_time_ms_;
  96   std::list<int> expected_deltas_;
  97   int packets_sent_;
  98   Clock* clock_;
  99 };
 100
 101 class PacedSenderTest : public ::testing::Test {
 102  protected:
 103   PacedSenderTest() : clock_(123456) {
 104     srand(0);
 105     // Need to initialize PacedSender after we initialize clock.
 106     send_bucket_.reset(new PacedSender(&clock_,
 107                                        &callback_,
 108                                        kTargetBitrate,
 109                                        kPaceMultiplier * kTargetBitrate,
 110                                        0));
 111   }
 112
 113   void SendAndExpectPacket(PacedSender::Priority priority,
 114                            uint32_t ssrc,
 115                            uint16_t sequence_number,
 116                            int64_t capture_time_ms,
 117                            int size,
 118                            bool retransmission) {
 119     EXPECT_FALSE(send_bucket_->SendPacket(priority, ssrc,
 120         sequence_number, capture_time_ms, size, retransmission));
 121     EXPECT_CALL(callback_,
 122                 TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
 123         .Times(1)
 124         .WillRepeatedly(Return(true));
 125   }
 126
 127   SimulatedClock clock_;
 128   MockPacedSenderCallback callback_;
 129   scoped_ptr<PacedSender> send_bucket_;
 130 };
 131
 132 TEST_F(PacedSenderTest, QueuePacket) {
 133   uint32_t ssrc = 12345;
 134   uint16_t sequence_number = 1234;
 135   // Due to the multiplicative factor we can send 3 packets not 2 packets.
 136   SendAndExpectPacket(PacedSender::kNormalPriority,
 137                       ssrc,
 138                       sequence_number++,
 139                       clock_.TimeInMilliseconds(),
 140                       250,
 141                       false);
 142   SendAndExpectPacket(PacedSender::kNormalPriority,
 143                       ssrc,
 144                       sequence_number++,
 145                       clock_.TimeInMilliseconds(),
 146                       250,
 147                       false);
 148   SendAndExpectPacket(PacedSender::kNormalPriority,
 149                       ssrc,
 150                       sequence_number++,
 151                       clock_.TimeInMilliseconds(),
 152                       250,
 153                       false);
 154   int64_t queued_packet_timestamp = clock_.TimeInMilliseconds();
 155   EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
 156       sequence_number, queued_packet_timestamp, 250, false));
 157   send_bucket_->Process();
 158   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
 159   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
 160   clock_.AdvanceTimeMilliseconds(4);
 161   EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess());
 162   clock_.AdvanceTimeMilliseconds(1);
 163   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
 164   EXPECT_CALL(
 165       callback_,
 166       TimeToSendPacket(ssrc, sequence_number++, queued_packet_timestamp, false))
 167       .Times(1)
 168       .WillRepeatedly(Return(true));
 169   send_bucket_->Process();
 170   sequence_number++;
 171   SendAndExpectPacket(PacedSender::kNormalPriority,
 172                       ssrc,
 173                       sequence_number++,
 174                       clock_.TimeInMilliseconds(),
 175                       250,
 176                       false);
 177   SendAndExpectPacket(PacedSender::kNormalPriority,
 178                       ssrc,
 179                       sequence_number++,
 180                       clock_.TimeInMilliseconds(),
 181                       250,
 182                       false);
 183   EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
 184       sequence_number++, clock_.TimeInMilliseconds(), 250, false));
 185   send_bucket_->Process();
 186 }
 187
 188 TEST_F(PacedSenderTest, PaceQueuedPackets) {
 189   uint32_t ssrc = 12345;
 190   uint16_t sequence_number = 1234;
 191
 192   // Due to the multiplicative factor we can send 3 packets not 2 packets.
 193   for (int i = 0; i < 3; ++i) {
 194     SendAndExpectPacket(PacedSender::kNormalPriority,
 195                         ssrc,
 196                         sequence_number++,
 197                         clock_.TimeInMilliseconds(),
 198                         250,
 199                         false);
 200   }
 201   for (int j = 0; j < 30; ++j) {
 202     EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
 203         sequence_number++, clock_.TimeInMilliseconds(), 250, false));
 204   }
 205   send_bucket_->Process();
 206   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
 207   for (int k = 0; k < 10; ++k) {
 208     EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
 209     clock_.AdvanceTimeMilliseconds(5);
 210     EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, _, false))
 211         .Times(3)
 212         .WillRepeatedly(Return(true));
 213     EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
 214     EXPECT_EQ(0, send_bucket_->Process());
 215   }
 216   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
 217   clock_.AdvanceTimeMilliseconds(5);
 218   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
 219   EXPECT_EQ(0, send_bucket_->Process());
 220   SendAndExpectPacket(PacedSender::kNormalPriority,
 221                       ssrc,
 222                       sequence_number++,
 223                       clock_.TimeInMilliseconds(),
 224                       250,
 225                       false);
 226   SendAndExpectPacket(PacedSender::kNormalPriority,
 227                       ssrc,
 228                       sequence_number++,
 229                       clock_.TimeInMilliseconds(),
 230                       250,
 231                       false);
 232   SendAndExpectPacket(PacedSender::kNormalPriority,
 233                       ssrc,
 234                       sequence_number++,
 235                       clock_.TimeInMilliseconds(),
 236                       250,
 237                       false);
 238   EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
 239       sequence_number, clock_.TimeInMilliseconds(), 250, false));
 240   send_bucket_->Process();
 241 }
 242
 243 TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) {
 244   uint32_t ssrc = 12345;
 245   uint16_t sequence_number = 1234;
 246   uint16_t queued_sequence_number;
 247
 248   // Due to the multiplicative factor we can send 3 packets not 2 packets.
 249   for (int i = 0; i < 3; ++i) {
 250     SendAndExpectPacket(PacedSender::kNormalPriority,
 251                         ssrc,
 252                         sequence_number++,
 253                         clock_.TimeInMilliseconds(),
 254                         250,
 255                         false);
 256   }
 257   queued_sequence_number = sequence_number;
 258
 259   for (int j = 0; j < 30; ++j) {
 260     // Send in duplicate packets.
 261     EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
 262         sequence_number, clock_.TimeInMilliseconds(), 250, false));
 263     EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
 264         sequence_number++, clock_.TimeInMilliseconds(), 250, false));
 265   }
 266   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
 267   send_bucket_->Process();
 268   for (int k = 0; k < 10; ++k) {
 269     EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
 270     clock_.AdvanceTimeMilliseconds(5);
 271
 272     for (int i = 0; i < 3; ++i) {
 273       EXPECT_CALL(callback_,
 274                   TimeToSendPacket(ssrc, queued_sequence_number++, _, false))
 275           .Times(1)
 276           .WillRepeatedly(Return(true));
 277    }
 278     EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
 279     EXPECT_EQ(0, send_bucket_->Process());
 280   }
 281   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
 282   clock_.AdvanceTimeMilliseconds(5);
 283   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
 284   EXPECT_EQ(0, send_bucket_->Process());
 285   SendAndExpectPacket(PacedSender::kNormalPriority,
 286                       ssrc,
 287                       sequence_number++,
 288                       clock_.TimeInMilliseconds(),
 289                       250,
 290                       false);
 291   SendAndExpectPacket(PacedSender::kNormalPriority,
 292                       ssrc,
 293                       sequence_number++,
 294                       clock_.TimeInMilliseconds(),
 295                       250,
 296                       false);
 297   SendAndExpectPacket(PacedSender::kNormalPriority,
 298                       ssrc,
 299                       sequence_number++,
 300                       clock_.TimeInMilliseconds(),
 301                       250,
 302                       false);
 303   EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
 304       sequence_number++, clock_.TimeInMilliseconds(), 250, false));
 305   send_bucket_->Process();
 306 }
 307
 308 TEST_F(PacedSenderTest, CanQueuePacketsWithSameSequenceNumberOnDifferentSsrcs) {
 309   uint32_t ssrc = 12345;
 310   uint16_t sequence_number = 1234;
 311
 312   SendAndExpectPacket(PacedSender::kNormalPriority,
 313                       ssrc,
 314                       sequence_number,
 315                       clock_.TimeInMilliseconds(),
 316                       250,
 317                       false);
 318
 319   // Expect packet on second ssrc to be queued and sent as well.
 320   SendAndExpectPacket(PacedSender::kNormalPriority,
 321                       ssrc + 1,
 322                       sequence_number,
 323                       clock_.TimeInMilliseconds(),
 324                       250,
 325                       false);
 326
 327   clock_.AdvanceTimeMilliseconds(1000);
 328   send_bucket_->Process();
 329 }
 330
 331 TEST_F(PacedSenderTest, Padding) {
 332   uint32_t ssrc = 12345;
 333   uint16_t sequence_number = 1234;
 334
 335   send_bucket_->UpdateBitrate(
 336       kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate);
 337   // Due to the multiplicative factor we can send 3 packets not 2 packets.
 338   SendAndExpectPacket(PacedSender::kNormalPriority,
 339                       ssrc,
 340                       sequence_number++,
 341                       clock_.TimeInMilliseconds(),
 342                       250,
 343                       false);
 344   SendAndExpectPacket(PacedSender::kNormalPriority,
 345                       ssrc,
 346                       sequence_number++,
 347                       clock_.TimeInMilliseconds(),
 348                       250,
 349                       false);
 350   SendAndExpectPacket(PacedSender::kNormalPriority,
 351                       ssrc,
 352                       sequence_number++,
 353                       clock_.TimeInMilliseconds(),
 354                       250,
 355                       false);
 356   // No padding is expected since we have sent too much already.
 357   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
 358   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
 359   clock_.AdvanceTimeMilliseconds(5);
 360   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
 361   EXPECT_EQ(0, send_bucket_->Process());
 362
 363   // 5 milliseconds later we have enough budget to send some padding.
 364   EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1).
 365       WillOnce(Return(250));
 366   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
 367   clock_.AdvanceTimeMilliseconds(5);
 368   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
 369   EXPECT_EQ(0, send_bucket_->Process());
 370 }
 371
 372 TEST_F(PacedSenderTest, NoPaddingWhenDisabled) {
 373   send_bucket_->SetStatus(false);
 374   send_bucket_->UpdateBitrate(
 375       kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate);
 376   // No padding is expected since the pacer is disabled.
 377   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
 378   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
 379   clock_.AdvanceTimeMilliseconds(5);
 380   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
 381   EXPECT_EQ(0, send_bucket_->Process());
 382   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
 383   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
 384   clock_.AdvanceTimeMilliseconds(5);
 385   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
 386   EXPECT_EQ(0, send_bucket_->Process());
 387 }
 388
 389 TEST_F(PacedSenderTest, VerifyPaddingUpToBitrate) {
 390   uint32_t ssrc = 12345;
 391   uint16_t sequence_number = 1234;
 392   int64_t capture_time_ms = 56789;
 393   const int kTimeStep = 5;
 394   const int64_t kBitrateWindow = 100;
 395   send_bucket_->UpdateBitrate(
 396       kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate);
 397   int64_t start_time = clock_.TimeInMilliseconds();
 398   while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) {
 399     SendAndExpectPacket(PacedSender::kNormalPriority,
 400                         ssrc,
 401                         sequence_number++,
 402                         capture_time_ms,
 403                         250,
 404                         false);
 405     clock_.AdvanceTimeMilliseconds(kTimeStep);
 406     EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1).
 407         WillOnce(Return(250));
 408     send_bucket_->Process();
 409   }
 410 }
 411
 412 TEST_F(PacedSenderTest, VerifyAverageBitrateVaryingMediaPayload) {
 413   uint32_t ssrc = 12345;
 414   uint16_t sequence_number = 1234;
 415   int64_t capture_time_ms = 56789;
 416   const int kTimeStep = 5;
 417   const int64_t kBitrateWindow = 10000;
 418   PacedSenderPadding callback;
 419   send_bucket_.reset(new PacedSender(
 420       &clock_, &callback, kTargetBitrate, kPaceMultiplier * kTargetBitrate, 0));
 421   send_bucket_->UpdateBitrate(
 422       kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate);
 423   int64_t start_time = clock_.TimeInMilliseconds();
 424   int media_bytes = 0;
 425   while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) {
 426     int media_payload = rand() % 100 + 200;  // [200, 300] bytes.
 427     EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
 428                                           sequence_number++, capture_time_ms,
 429                                           media_payload, false));
 430     media_bytes += media_payload;
 431     clock_.AdvanceTimeMilliseconds(kTimeStep);
 432     send_bucket_->Process();
 433   }
 434   EXPECT_NEAR(kTargetBitrate, 8 * (media_bytes + callback.padding_sent()) /
 435               kBitrateWindow, 1);
 436 }
 437
 438 TEST_F(PacedSenderTest, Priority) {
 439   uint32_t ssrc_low_priority = 12345;
 440   uint32_t ssrc = 12346;
 441   uint16_t sequence_number = 1234;
 442   int64_t capture_time_ms = 56789;
 443   int64_t capture_time_ms_low_priority = 1234567;
 444
 445   // Due to the multiplicative factor we can send 3 packets not 2 packets.
 446   SendAndExpectPacket(PacedSender::kLowPriority,
 447                       ssrc,
 448                       sequence_number++,
 449                       capture_time_ms,
 450                       250,
 451                       false);
 452   SendAndExpectPacket(PacedSender::kNormalPriority,
 453                       ssrc,
 454                       sequence_number++,
 455                       capture_time_ms,
 456                       250,
 457                       false);
 458   SendAndExpectPacket(PacedSender::kNormalPriority,
 459                       ssrc,
 460                       sequence_number++,
 461                       capture_time_ms,
 462                       250,
 463                       false);
 464   send_bucket_->Process();
 465
 466   // Expect normal and low priority to be queued and high to pass through.
 467   EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kLowPriority,
 468       ssrc_low_priority, sequence_number++, capture_time_ms_low_priority, 250,
 469       false));
 470   EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
 471       ssrc, sequence_number++, capture_time_ms, 250, false));
 472   EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
 473       ssrc, sequence_number++, capture_time_ms, 250, false));
 474   EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kHighPriority,
 475       ssrc, sequence_number++, capture_time_ms, 250, false));
 476
 477   // Expect all high and normal priority to be sent out first.
 478   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
 479   EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false))
 480       .Times(3)
 481       .WillRepeatedly(Return(true));
 482
 483   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
 484   clock_.AdvanceTimeMilliseconds(5);
 485   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
 486   EXPECT_EQ(0, send_bucket_->Process());
 487
 488   EXPECT_CALL(callback_,
 489               TimeToSendPacket(
 490                   ssrc_low_priority, _, capture_time_ms_low_priority, false))
 491       .Times(1)
 492       .WillRepeatedly(Return(true));
 493
 494   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
 495   clock_.AdvanceTimeMilliseconds(5);
 496   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
 497   EXPECT_EQ(0, send_bucket_->Process());
 498 }
 499
 500 TEST_F(PacedSenderTest, Pause) {
 501   uint32_t ssrc_low_priority = 12345;
 502   uint32_t ssrc = 12346;
 503   uint16_t sequence_number = 1234;
 504   int64_t capture_time_ms = clock_.TimeInMilliseconds();
 505
 506   EXPECT_EQ(0, send_bucket_->QueueInMs());
 507
 508   // Due to the multiplicative factor we can send 3 packets not 2 packets.
 509   SendAndExpectPacket(PacedSender::kLowPriority,
 510                       ssrc,
 511                       sequence_number++,
 512                       capture_time_ms,
 513                       250,
 514                       false);
 515   SendAndExpectPacket(PacedSender::kNormalPriority,
 516                       ssrc,
 517                       sequence_number++,
 518                       capture_time_ms,
 519                       250,
 520                       false);
 521   SendAndExpectPacket(PacedSender::kNormalPriority,
 522                       ssrc,
 523                       sequence_number++,
 524                       capture_time_ms,
 525                       250,
 526                       false);
 527   send_bucket_->Process();
 528
 529   send_bucket_->Pause();
 530
 531   EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
 532       ssrc, sequence_number++, capture_time_ms, 250, false));
 533   EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
 534       ssrc, sequence_number++, capture_time_ms, 250, false));
 535   EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kHighPriority,
 536       ssrc, sequence_number++, capture_time_ms, 250, false));
 537
 538   clock_.AdvanceTimeMilliseconds(10000);
 539   int64_t second_capture_time_ms = clock_.TimeInMilliseconds();
 540
 541   // Expect everything to be queued.
 542   EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kLowPriority,
 543       ssrc_low_priority, sequence_number++, second_capture_time_ms, 250,
 544       false));
 545
 546   EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
 547             send_bucket_->QueueInMs());
 548
 549   // Expect no packet to come out while paused.
 550   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
 551   EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _)).Times(0);
 552
 553   for (int i = 0; i < 10; ++i) {
 554     clock_.AdvanceTimeMilliseconds(5);
 555     EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
 556     EXPECT_EQ(0, send_bucket_->Process());
 557   }
 558   // Expect high prio packets to come out first followed by all packets in the
 559   // way they were added.
 560   EXPECT_CALL(callback_, TimeToSendPacket(_, _, capture_time_ms, false))
 561       .Times(3)
 562       .WillRepeatedly(Return(true));
 563   send_bucket_->Resume();
 564
 565   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
 566   clock_.AdvanceTimeMilliseconds(5);
 567   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
 568   EXPECT_EQ(0, send_bucket_->Process());
 569
 570   EXPECT_CALL(callback_, TimeToSendPacket(_, _, second_capture_time_ms, false))
 571       .Times(1)
 572       .WillRepeatedly(Return(true));
 573   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
 574   clock_.AdvanceTimeMilliseconds(5);
 575   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
 576   EXPECT_EQ(0, send_bucket_->Process());
 577   EXPECT_EQ(0, send_bucket_->QueueInMs());
 578 }
 579
 580 TEST_F(PacedSenderTest, ResendPacket) {
 581   uint32_t ssrc = 12346;
 582   uint16_t sequence_number = 1234;
 583   int64_t capture_time_ms = clock_.TimeInMilliseconds();
 584   EXPECT_EQ(0, send_bucket_->QueueInMs());
 585
 586   EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
 587                                         ssrc,
 588                                         sequence_number,
 589                                         capture_time_ms,
 590                                         250,
 591                                         false));
 592   clock_.AdvanceTimeMilliseconds(1);
 593   EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
 594                                         ssrc,
 595                                         sequence_number + 1,
 596                                         capture_time_ms + 1,
 597                                         250,
 598                                         false));
 599   clock_.AdvanceTimeMilliseconds(9999);
 600   EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
 601             send_bucket_->QueueInMs());
 602   // Fails to send first packet so only one call.
 603   EXPECT_CALL(callback_,
 604               TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
 605       .Times(1)
 606       .WillOnce(Return(false));
 607   clock_.AdvanceTimeMilliseconds(10000);
 608   send_bucket_->Process();
 609
 610   // Queue remains unchanged.
 611   EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
 612             send_bucket_->QueueInMs());
 613
 614   // Fails to send second packet.
 615   EXPECT_CALL(callback_,
 616               TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
 617       .Times(1)
 618       .WillOnce(Return(true));
 619   EXPECT_CALL(
 620       callback_,
 621       TimeToSendPacket(ssrc, sequence_number + 1, capture_time_ms + 1, false))
 622       .Times(1)
 623       .WillOnce(Return(false));
 624   clock_.AdvanceTimeMilliseconds(10000);
 625   send_bucket_->Process();
 626
 627   // Queue is reduced by 1 packet.
 628   EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms - 1,
 629             send_bucket_->QueueInMs());
 630
 631   // Send second packet and queue becomes empty.
 632   EXPECT_CALL(
 633       callback_,
 634       TimeToSendPacket(ssrc, sequence_number + 1, capture_time_ms + 1, false))
 635       .Times(1)
 636       .WillOnce(Return(true));
 637   clock_.AdvanceTimeMilliseconds(10000);
 638   send_bucket_->Process();
 639   EXPECT_EQ(0, send_bucket_->QueueInMs());
 640 }
 641
 642 TEST_F(PacedSenderTest, ExpectedQueueTimeMs) {
 643   uint32_t ssrc = 12346;
 644   uint16_t sequence_number = 1234;
 645   const int32_t kNumPackets = 60;
 646   const int32_t kPacketSize = 1200;
 647   const int32_t kMaxBitrate = kPaceMultiplier * 30;
 648   EXPECT_EQ(0, send_bucket_->ExpectedQueueTimeMs());
 649
 650   send_bucket_->UpdateBitrate(30, kMaxBitrate, 0);
 651   for (int i = 0; i < kNumPackets; ++i) {
 652     SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
 653                         clock_.TimeInMilliseconds(), kPacketSize, false);
 654   }
 655
 656   // Queue in ms = 1000 * (bytes in queue) / (kbit per second * 1000 / 8)
 657   int32_t queue_in_ms = kNumPackets * kPacketSize * 8 / kMaxBitrate;
 658   EXPECT_EQ(queue_in_ms, send_bucket_->ExpectedQueueTimeMs());
 659
 660   int64_t time_start = clock_.TimeInMilliseconds();
 661   while (send_bucket_->QueueSizePackets() > 0) {
 662     int time_until_process = send_bucket_->TimeUntilNextProcess();
 663     if (time_until_process <= 0) {
 664       send_bucket_->Process();
 665     } else {
 666       clock_.AdvanceTimeMilliseconds(time_until_process);
 667     }
 668   }
 669   int64_t duration = clock_.TimeInMilliseconds() - time_start;
 670
 671   EXPECT_EQ(0, send_bucket_->ExpectedQueueTimeMs());
 672
 673   // Allow for aliasing, duration should be in [expected(n - 1), expected(n)].
 674   EXPECT_LE(duration, queue_in_ms);
 675   EXPECT_GE(duration, queue_in_ms - (kPacketSize * 8 / kMaxBitrate));
 676 }
 677
 678 TEST_F(PacedSenderTest, QueueTimeGrowsOverTime) {
 679   uint32_t ssrc = 12346;
 680   uint16_t sequence_number = 1234;
 681   EXPECT_EQ(0, send_bucket_->QueueInMs());
 682
 683   send_bucket_->UpdateBitrate(30, kPaceMultiplier * 30, 0);
 684   SendAndExpectPacket(PacedSender::kNormalPriority,
 685                       ssrc,
 686                       sequence_number,
 687                       clock_.TimeInMilliseconds(),
 688                       1200,
 689                       false);
 690
 691   clock_.AdvanceTimeMilliseconds(500);
 692   EXPECT_EQ(500, send_bucket_->QueueInMs());
 693   send_bucket_->Process();
 694   EXPECT_EQ(0, send_bucket_->QueueInMs());
 695 }
 696
 697 class ProbingPacedSender : public PacedSender {
 698  public:
 699   ProbingPacedSender(Clock* clock,
 700                      Callback* callback,
 701                      int bitrate_kbps,
 702                      int max_bitrate_kbps,
 703                      int min_bitrate_kbps)
 704       : PacedSender(clock,
 705                     callback,
 706                     bitrate_kbps,
 707                     max_bitrate_kbps,
 708                     min_bitrate_kbps) {}
 709
 710   virtual bool ProbingExperimentIsEnabled() const OVERRIDE { return true; }
 711 };
 712
 713 TEST_F(PacedSenderTest, ProbingWithInitialFrame) {
 714   const int kNumPackets = 11;
 715   const int kNumDeltas = kNumPackets - 1;
 716   const int kPacketSize = 1200;
 717   const int kInitialBitrateKbps = 300;
 718   uint32_t ssrc = 12346;
 719   uint16_t sequence_number = 1234;
 720   const int expected_deltas[kNumDeltas] = {
 721       10, 10, 10, 10, 10, 5, 5, 5, 5, 5};
 722   std::list<int> expected_deltas_list(expected_deltas,
 723                                       expected_deltas + kNumPackets - 1);
 724   PacedSenderProbing callback(expected_deltas_list, &clock_);
 725   send_bucket_.reset(
 726       new ProbingPacedSender(&clock_,
 727                              &callback,
 728                              kInitialBitrateKbps,
 729                              kPaceMultiplier * kInitialBitrateKbps,
 730                              0));
 731   for (int i = 0; i < kNumPackets; ++i) {
 732     EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
 733                                           ssrc,
 734                                           sequence_number++,
 735                                           clock_.TimeInMilliseconds(),
 736                                           kPacketSize,
 737                                           false));
 738   }
 739   while (callback.packets_sent() < kNumPackets) {
 740     int time_until_process = send_bucket_->TimeUntilNextProcess();
 741     if (time_until_process <= 0) {
 742       send_bucket_->Process();
 743     } else {
 744       clock_.AdvanceTimeMilliseconds(time_until_process);
 745     }
 746   }
 747 }
 748
 749 TEST_F(PacedSenderTest, PriorityInversion) {
 750   uint32_t ssrc = 12346;
 751   uint16_t sequence_number = 1234;
 752   const int32_t kPacketSize = 1200;
 753
 754   EXPECT_FALSE(send_bucket_->SendPacket(
 755       PacedSender::kHighPriority, ssrc, sequence_number + 3,
 756       clock_.TimeInMilliseconds() + 33, kPacketSize, true));
 757
 758   EXPECT_FALSE(send_bucket_->SendPacket(
 759       PacedSender::kHighPriority, ssrc, sequence_number + 2,
 760       clock_.TimeInMilliseconds() + 33, kPacketSize, true));
 761
 762   EXPECT_FALSE(send_bucket_->SendPacket(
 763       PacedSender::kHighPriority, ssrc, sequence_number,
 764       clock_.TimeInMilliseconds(), kPacketSize, true));
 765
 766   EXPECT_FALSE(send_bucket_->SendPacket(
 767       PacedSender::kHighPriority, ssrc, sequence_number + 1,
 768       clock_.TimeInMilliseconds(), kPacketSize, true));
 769
 770   // Packets from earlier frames should be sent first.
 771   {
 772     ::testing::InSequence sequence;
 773     EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number,
 774                                             clock_.TimeInMilliseconds(), true))
 775         .WillOnce(Return(true));
 776     EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 1,
 777                                             clock_.TimeInMilliseconds(), true))
 778         .WillOnce(Return(true));
 779     EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 3,
 780                                             clock_.TimeInMilliseconds() + 33,
 781                                             true)).WillOnce(Return(true));
 782     EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 2,
 783                                             clock_.TimeInMilliseconds() + 33,
 784                                             true)).WillOnce(Return(true));
 785
 786     while (send_bucket_->QueueSizePackets() > 0) {
 787       int time_until_process = send_bucket_->TimeUntilNextProcess();
 788       if (time_until_process <= 0) {
 789         send_bucket_->Process();
 790       } else {
 791         clock_.AdvanceTimeMilliseconds(time_until_process);
 792       }
 793     }
 794   }
 795 }
 796
 797 TEST_F(PacedSenderTest, PaddingOveruse) {
 798   uint32_t ssrc = 12346;
 799   uint16_t sequence_number = 1234;
 800   const int32_t kPacketSize = 1200;
 801
 802   // Min bitrate 0 => no padding, padding budget will stay at 0.
 803   send_bucket_->UpdateBitrate(60, 90, 0);
 804   SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
 805                       clock_.TimeInMilliseconds(), kPacketSize, false);
 806   send_bucket_->Process();
 807
 808   // Add 30kbit padding. When increasing budget, media budget will increase from
 809   // negative (overuse) while padding budget will increase form 0.
 810   clock_.AdvanceTimeMilliseconds(5);
 811   send_bucket_->UpdateBitrate(60, 90, 30);
 812
 813   EXPECT_FALSE(send_bucket_->SendPacket(
 814       PacedSender::kHighPriority, ssrc, sequence_number++,
 815       clock_.TimeInMilliseconds(), kPacketSize, false));
 816
 817   // Don't send padding if queue is non-empty, even if padding budget > 0.
 818   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
 819   send_bucket_->Process();
 820 }
 821
 822 }  // namespace test
 823 }  // namespace webrtc