Refactor how padding is calculated.

webrtc/modules/pacing/paced_sender_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 304 matching lines @@
 
   clock_.AdvanceTimeMilliseconds(1000);
   send_bucket_->Process();
 }
 
 TEST_F(PacedSenderTest, Padding) {
   uint32_t ssrc = 12345;
   uint16_t sequence_number = 1234;
 
   send_bucket_->SetEstimatedBitrate(kTargetBitrateBps);
-  send_bucket_->SetAllocatedSendBitrate(kTargetBitrateBps, kTargetBitrateBps);
+  send_bucket_->SetSendBitrateLimits(kTargetBitrateBps, kTargetBitrateBps);
 
   // Due to the multiplicative factor we can send 5 packets during a send
   // interval. (network capacity * multiplier / (8 bits per byte *
   // (packet size * #send intervals per second)
   const size_t packets_to_send_per_interval =
       kTargetBitrateBps * PacedSender::kDefaultPaceMultiplier / (8 * 250 * 200);
   for (size_t i = 0; i < packets_to_send_per_interval; ++i) {
     SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
                         clock_.TimeInMilliseconds(), 250, false);
   }
@@ skipping 14 matching lines @@
   // 5 milliseconds later we have enough budget to send some padding.
   EXPECT_CALL(callback_, TimeToSendPadding(250, _))
       .Times(1)
       .WillOnce(Return(250));
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
   clock_.AdvanceTimeMilliseconds(5);
   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
   send_bucket_->Process();
 }
 
+TEST_F(PacedSenderTest, NoPaddingBeforeNormalPacket) {
+  send_bucket_->SetEstimatedBitrate(kTargetBitrateBps);
+  send_bucket_->SetSendBitrateLimits(kTargetBitrateBps, kTargetBitrateBps);
+
+  EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
+  send_bucket_->Process();
+  clock_.AdvanceTimeMilliseconds(send_bucket_->TimeUntilNextProcess());
+
+  send_bucket_->Process();
+  clock_.AdvanceTimeMilliseconds(send_bucket_->TimeUntilNextProcess());
+
+  uint32_t ssrc = 12345;
+  uint16_t sequence_number = 1234;
+  int64_t capture_time_ms = 56789;
+
+  SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
+                      capture_time_ms, 250, false);
+  EXPECT_CALL(callback_, TimeToSendPadding(250, _))
+      .Times(1)
+      .WillOnce(Return(250));
+  send_bucket_->Process();
+}
+
 TEST_F(PacedSenderTest, VerifyPaddingUpToBitrate) {
   uint32_t ssrc = 12345;
   uint16_t sequence_number = 1234;
   int64_t capture_time_ms = 56789;
   const int kTimeStep = 5;
   const int64_t kBitrateWindow = 100;
   send_bucket_->SetEstimatedBitrate(kTargetBitrateBps);
-  send_bucket_->SetAllocatedSendBitrate(kTargetBitrateBps, kTargetBitrateBps);
+  send_bucket_->SetSendBitrateLimits(kTargetBitrateBps, kTargetBitrateBps);
 
   int64_t start_time = clock_.TimeInMilliseconds();
   while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) {
     SendAndExpectPacket(PacedSender::kNormalPriority,
                         ssrc,
                         sequence_number++,
                         capture_time_ms,
                         250,
                         false);
     EXPECT_CALL(callback_, TimeToSendPadding(250, _))
         .Times(1)
         .WillOnce(Return(250));
     send_bucket_->Process();
     clock_.AdvanceTimeMilliseconds(kTimeStep);
   }
 }
 
 TEST_F(PacedSenderTest, VerifyAverageBitrateVaryingMediaPayload) {
   uint32_t ssrc = 12345;
   uint16_t sequence_number = 1234;
   int64_t capture_time_ms = 56789;
   const int kTimeStep = 5;
   const int64_t kBitrateWindow = 10000;
   PacedSenderPadding callback;
   send_bucket_.reset(new PacedSender(&clock_, &callback));
   send_bucket_->SetProbingEnabled(false);
   send_bucket_->SetEstimatedBitrate(kTargetBitrateBps);
-  send_bucket_->SetAllocatedSendBitrate(kTargetBitrateBps, kTargetBitrateBps);
+
+  send_bucket_->SetSendBitrateLimits(
+      0 /*allocated_bitrate_bps*/,
+      kTargetBitrateBps * 2 /* max_padding_bitrate_bps */);
 
   int64_t start_time = clock_.TimeInMilliseconds();
   size_t media_bytes = 0;
   while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) {
     int rand_value = rand();  // NOLINT (rand_r instead of rand)
     size_t media_payload = rand_value % 100 + 200;  // [200, 300] bytes.
     send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
                                sequence_number++, capture_time_ms,
                                media_payload, false);
     media_bytes += media_payload;
@@ skipping 393 matching lines @@
   }
 }
 
 TEST_F(PacedSenderTest, PaddingOveruse) {
   uint32_t ssrc = 12346;
   uint16_t sequence_number = 1234;
   const size_t kPacketSize = 1200;
 
   send_bucket_->Process();
   send_bucket_->SetEstimatedBitrate(60000);
-  send_bucket_->SetAllocatedSendBitrate(60000, 0);
+  send_bucket_->SetSendBitrateLimits(60000, 0);
 
   SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
                       clock_.TimeInMilliseconds(), kPacketSize, false);
   send_bucket_->Process();
 
   // Add 30kbit padding. When increasing budget, media budget will increase from
   // negative (overuse) while padding budget will increase from 0.
   clock_.AdvanceTimeMilliseconds(5);
-  send_bucket_->SetAllocatedSendBitrate(60000, 30000);
+  send_bucket_->SetSendBitrateLimits(60000, 30000);
 
   SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
                       clock_.TimeInMilliseconds(), kPacketSize, false);
   EXPECT_LT(5u, send_bucket_->ExpectedQueueTimeMs());
   // Don't send padding if queue is non-empty, even if padding budget > 0.
   EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
   send_bucket_->Process();
 }
 
 TEST_F(PacedSenderTest, AverageQueueTime) {
@@ skipping 39 matching lines @@
   }
 
   EXPECT_EQ(0, send_bucket_->AverageQueueTimeMs());
 }
 
 TEST_F(PacedSenderTest, ProbeClusterId) {
   uint32_t ssrc = 12346;
   uint16_t sequence_number = 1234;
   const size_t kPacketSize = 1200;
 
-  send_bucket_->SetAllocatedSendBitrate(kTargetBitrateBps, kTargetBitrateBps);
+  send_bucket_->SetSendBitrateLimits(kTargetBitrateBps, kTargetBitrateBps);
   send_bucket_->SetProbingEnabled(true);
   for (int i = 0; i < 11; ++i) {
     send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
                                sequence_number + i, clock_.TimeInMilliseconds(),
                                kPacketSize, false);
   }
 
   // First probing cluster.
   EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, 0))
       .Times(6)
@@ skipping 14 matching lines @@
 
   // No more probing packets.
   EXPECT_CALL(callback_, TimeToSendPadding(_, PacketInfo::kNotAProbe))
         .Times(1)
         .WillRepeatedly(Return(500));
   send_bucket_->Process();
 }
 
 }  // namespace test
 }  // namespace webrtc