Disable pacer disabling.

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 106 matching lines @@
     // by calling SetProbingEnabled(true).
     send_bucket_->SetProbingEnabled(false);
   }
 
   void SendAndExpectPacket(PacedSender::Priority priority,
                            uint32_t ssrc,
                            uint16_t sequence_number,
                            int64_t capture_time_ms,
                            size_t size,
                            bool retransmission) {
-    EXPECT_FALSE(send_bucket_->SendPacket(priority, ssrc,
-        sequence_number, capture_time_ms, size, retransmission));
+    send_bucket_->InsertPacket(priority, ssrc, sequence_number, capture_time_ms,
+                               size, retransmission);
     EXPECT_CALL(callback_,
                 TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
         .Times(1)
         .WillRepeatedly(Return(true));
   }
 
   SimulatedClock clock_;
   MockPacedSenderCallback callback_;
   rtc::scoped_ptr<PacedSender> send_bucket_;
 };
@@ skipping 14 matching lines @@
                       clock_.TimeInMilliseconds(),
                       250,
                       false);
   SendAndExpectPacket(PacedSender::kNormalPriority,
                       ssrc,
                       sequence_number++,
                       clock_.TimeInMilliseconds(),
                       250,
                       false);
   int64_t queued_packet_timestamp = clock_.TimeInMilliseconds();
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-      sequence_number, queued_packet_timestamp, 250, false));
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number, queued_packet_timestamp, 250,
+                             false);
   send_bucket_->Process();
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
   clock_.AdvanceTimeMilliseconds(4);
   EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess());
   clock_.AdvanceTimeMilliseconds(1);
   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
   EXPECT_CALL(
       callback_,
       TimeToSendPacket(ssrc, sequence_number++, queued_packet_timestamp, false))
       .Times(1)
       .WillRepeatedly(Return(true));
   send_bucket_->Process();
   sequence_number++;
   SendAndExpectPacket(PacedSender::kNormalPriority,
                       ssrc,
                       sequence_number++,
                       clock_.TimeInMilliseconds(),
                       250,
                       false);
   SendAndExpectPacket(PacedSender::kNormalPriority,
                       ssrc,
                       sequence_number++,
                       clock_.TimeInMilliseconds(),
                       250,
                       false);
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-      sequence_number++, clock_.TimeInMilliseconds(), 250, false));
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number++, clock_.TimeInMilliseconds(),
+                             250, false);
   send_bucket_->Process();
 }
 
 TEST_F(PacedSenderTest, PaceQueuedPackets) {
   uint32_t ssrc = 12345;
   uint16_t sequence_number = 1234;
 
   // Due to the multiplicative factor we can send 3 packets not 2 packets.
   for (int i = 0; i < 3; ++i) {
     SendAndExpectPacket(PacedSender::kNormalPriority,
                         ssrc,
                         sequence_number++,
                         clock_.TimeInMilliseconds(),
                         250,
                         false);
   }
   for (int j = 0; j < 30; ++j) {
-    EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-        sequence_number++, clock_.TimeInMilliseconds(), 250, false));
+    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                               sequence_number++, clock_.TimeInMilliseconds(),
+                               250, false);
   }
   send_bucket_->Process();
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
   for (int k = 0; k < 10; ++k) {
     EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
     clock_.AdvanceTimeMilliseconds(5);
     EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, _, false))
         .Times(3)
         .WillRepeatedly(Return(true));
     EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
@@ skipping 14 matching lines @@
                       sequence_number++,
                       clock_.TimeInMilliseconds(),
                       250,
                       false);
   SendAndExpectPacket(PacedSender::kNormalPriority,
                       ssrc,
                       sequence_number++,
                       clock_.TimeInMilliseconds(),
                       250,
                       false);
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-      sequence_number, clock_.TimeInMilliseconds(), 250, false));
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number, clock_.TimeInMilliseconds(), 250,
+                             false);
   send_bucket_->Process();
 }
 
 TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) {
   uint32_t ssrc = 12345;
   uint16_t sequence_number = 1234;
   uint16_t queued_sequence_number;
 
   // Due to the multiplicative factor we can send 3 packets not 2 packets.
   for (int i = 0; i < 3; ++i) {
     SendAndExpectPacket(PacedSender::kNormalPriority,
                         ssrc,
                         sequence_number++,
                         clock_.TimeInMilliseconds(),
                         250,
                         false);
   }
   queued_sequence_number = sequence_number;
 
   for (int j = 0; j < 30; ++j) {
     // Send in duplicate packets.
-    EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-        sequence_number, clock_.TimeInMilliseconds(), 250, false));
-    EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-        sequence_number++, clock_.TimeInMilliseconds(), 250, false));
+    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                               sequence_number, clock_.TimeInMilliseconds(),
+                               250, false);
+    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                               sequence_number++, clock_.TimeInMilliseconds(),
+                               250, false);
   }
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
   send_bucket_->Process();
   for (int k = 0; k < 10; ++k) {
     EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
     clock_.AdvanceTimeMilliseconds(5);
 
     for (int i = 0; i < 3; ++i) {
       EXPECT_CALL(callback_,
                   TimeToSendPacket(ssrc, queued_sequence_number++, _, false))
@@ skipping 18 matching lines @@
                       sequence_number++,
                       clock_.TimeInMilliseconds(),
                       250,
                       false);
   SendAndExpectPacket(PacedSender::kNormalPriority,
                       ssrc,
                       sequence_number++,
                       clock_.TimeInMilliseconds(),
                       250,
                       false);
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-      sequence_number++, clock_.TimeInMilliseconds(), 250, false));
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number++, clock_.TimeInMilliseconds(),
+                             250, false);
   send_bucket_->Process();
 }
 
 TEST_F(PacedSenderTest, CanQueuePacketsWithSameSequenceNumberOnDifferentSsrcs) {
   uint32_t ssrc = 12345;
   uint16_t sequence_number = 1234;
 
   SendAndExpectPacket(PacedSender::kNormalPriority,
                       ssrc,
                       sequence_number,
@@ skipping 47 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());
   EXPECT_EQ(0, send_bucket_->Process());
 }
 
-TEST_F(PacedSenderTest, NoPaddingWhenDisabled) {
-  send_bucket_->SetStatus(false);
-  send_bucket_->UpdateBitrate(
-      kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate);
-  // No padding is expected since the pacer is disabled.
-  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
-  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
-  clock_.AdvanceTimeMilliseconds(5);
-  EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
-  EXPECT_EQ(0, send_bucket_->Process());
-  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
-  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
-  clock_.AdvanceTimeMilliseconds(5);
-  EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
-  EXPECT_EQ(0, 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_->UpdateBitrate(
       kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate);
   int64_t start_time = clock_.TimeInMilliseconds();
   while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) {
@@ skipping 19 matching lines @@
   PacedSenderPadding callback;
   send_bucket_.reset(new PacedSender(
       &clock_, &callback, kTargetBitrate, kPaceMultiplier * kTargetBitrate, 0));
   send_bucket_->SetProbingEnabled(false);
   send_bucket_->UpdateBitrate(
       kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate);
   int64_t start_time = clock_.TimeInMilliseconds();
   size_t media_bytes = 0;
   while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) {
     size_t media_payload = rand() % 100 + 200;  // [200, 300] bytes.
-    EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-                                          sequence_number++, capture_time_ms,
-                                          media_payload, false));
+    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                               sequence_number++, capture_time_ms,
+                               media_payload, false);
     media_bytes += media_payload;
     clock_.AdvanceTimeMilliseconds(kTimeStep);
     send_bucket_->Process();
   }
   EXPECT_NEAR(kTargetBitrate,
               static_cast<int>(8 * (media_bytes + callback.padding_sent()) /
                   kBitrateWindow), 1);
 }
 
 TEST_F(PacedSenderTest, Priority) {
@@ skipping 18 matching lines @@
                       false);
   SendAndExpectPacket(PacedSender::kNormalPriority,
                       ssrc,
                       sequence_number++,
                       capture_time_ms,
                       250,
                       false);
   send_bucket_->Process();
 
   // Expect normal and low priority to be queued and high to pass through.
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kLowPriority,
-      ssrc_low_priority, sequence_number++, capture_time_ms_low_priority, 250,
-      false));
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
-      ssrc, sequence_number++, capture_time_ms, 250, false));
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
-      ssrc, sequence_number++, capture_time_ms, 250, false));
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kHighPriority,
-      ssrc, sequence_number++, capture_time_ms, 250, false));
+  send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc_low_priority,
+                             sequence_number++, capture_time_ms_low_priority,
+                             250, false);
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number++, capture_time_ms, 250, false);
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number++, capture_time_ms, 250, false);
+  send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc,
+                             sequence_number++, capture_time_ms, 250, false);
 
   // Expect all high and normal priority to be sent out first.
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
   EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false))
       .Times(3)
       .WillRepeatedly(Return(true));
 
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
   clock_.AdvanceTimeMilliseconds(5);
   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
@@ skipping 35 matching lines @@
   SendAndExpectPacket(PacedSender::kNormalPriority,
                       ssrc,
                       sequence_number++,
                       capture_time_ms,
                       250,
                       false);
   send_bucket_->Process();
 
   send_bucket_->Pause();
 
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
-      ssrc, sequence_number++, capture_time_ms, 250, false));
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
-      ssrc, sequence_number++, capture_time_ms, 250, false));
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kHighPriority,
-      ssrc, sequence_number++, capture_time_ms, 250, false));
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number++, capture_time_ms, 250, false);
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number++, capture_time_ms, 250, false);
+  send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc,
+                             sequence_number++, capture_time_ms, 250, false);
 
   clock_.AdvanceTimeMilliseconds(10000);
   int64_t second_capture_time_ms = clock_.TimeInMilliseconds();
 
   // Expect everything to be queued.
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kLowPriority,
-      ssrc_low_priority, sequence_number++, second_capture_time_ms, 250,
-      false));
+  send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc_low_priority,
+                             sequence_number++, second_capture_time_ms, 250,
+                             false);
 
   EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
             send_bucket_->QueueInMs());
 
   // Expect no packet to come out while paused.
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
   EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _)).Times(0);
 
   for (int i = 0; i < 10; ++i) {
     clock_.AdvanceTimeMilliseconds(5);
@@ skipping 21 matching lines @@
   EXPECT_EQ(0, send_bucket_->Process());
   EXPECT_EQ(0, send_bucket_->QueueInMs());
 }
 
 TEST_F(PacedSenderTest, ResendPacket) {
   uint32_t ssrc = 12346;
   uint16_t sequence_number = 1234;
   int64_t capture_time_ms = clock_.TimeInMilliseconds();
   EXPECT_EQ(0, send_bucket_->QueueInMs());
 
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
-                                        ssrc,
-                                        sequence_number,
-                                        capture_time_ms,
-                                        250,
-                                        false));
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number, capture_time_ms, 250, false);
   clock_.AdvanceTimeMilliseconds(1);
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
-                                        ssrc,
-                                        sequence_number + 1,
-                                        capture_time_ms + 1,
-                                        250,
-                                        false));
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number + 1, capture_time_ms + 1, 250,
+                             false);
   clock_.AdvanceTimeMilliseconds(9999);
   EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
             send_bucket_->QueueInMs());
   // Fails to send first packet so only one call.
   EXPECT_CALL(callback_,
               TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
       .Times(1)
       .WillOnce(Return(false));
   clock_.AdvanceTimeMilliseconds(10000);
   send_bucket_->Process();
@@ skipping 100 matching lines @@
                                       expected_deltas + kNumPackets - 1);
   PacedSenderProbing callback(expected_deltas_list, &clock_);
   send_bucket_.reset(
       new PacedSender(&clock_,
                       &callback,
                       kInitialBitrateKbps,
                       kPaceMultiplier * kInitialBitrateKbps,
                       0));
 
   for (int i = 0; i < kNumPackets; ++i) {
-    EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
-                                          ssrc,
-                                          sequence_number++,
-                                          clock_.TimeInMilliseconds(),
-                                          kPacketSize,
-                                          false));
+    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                               sequence_number++, clock_.TimeInMilliseconds(),
+                               kPacketSize, false);
   }
   while (callback.packets_sent() < kNumPackets) {
     int time_until_process = send_bucket_->TimeUntilNextProcess();
     if (time_until_process <= 0) {
       send_bucket_->Process();
     } else {
       clock_.AdvanceTimeMilliseconds(time_until_process);
     }
   }
 }
 
 TEST_F(PacedSenderTest, ProbingWithTooSmallInitialFrame) {
   const int kNumPackets = 11;
   const int kNumDeltas = kNumPackets - 1;
   const size_t kPacketSize = 1200;
   const int kInitialBitrateKbps = 300;
   uint32_t ssrc = 12346;
   uint16_t sequence_number = 1234;
   const int expected_deltas[kNumDeltas] = {10, 10, 10, 10, 10, 5, 5, 5, 5, 5};
   std::list<int> expected_deltas_list(expected_deltas,
                                       expected_deltas + kNumPackets - 1);
   PacedSenderProbing callback(expected_deltas_list, &clock_);
   send_bucket_.reset(new PacedSender(&clock_, &callback, kInitialBitrateKbps,
                                      kPaceMultiplier * kInitialBitrateKbps, 0));
 
   for (int i = 0; i < kNumPackets - 5; ++i) {
-    EXPECT_FALSE(send_bucket_->SendPacket(
-        PacedSender::kNormalPriority, ssrc, sequence_number++,
-        clock_.TimeInMilliseconds(), kPacketSize, false));
+    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                               sequence_number++, clock_.TimeInMilliseconds(),
+                               kPacketSize, false);
   }
   while (callback.packets_sent() < kNumPackets) {
     int time_until_process = send_bucket_->TimeUntilNextProcess();
     if (time_until_process <= 0) {
       send_bucket_->Process();
     } else {
       clock_.AdvanceTimeMilliseconds(time_until_process);
     }
   }
 
   // Process one more time and make sure we don't send any more probes.
   int time_until_process = send_bucket_->TimeUntilNextProcess();
   clock_.AdvanceTimeMilliseconds(time_until_process);
   send_bucket_->Process();
   EXPECT_EQ(kNumPackets, callback.packets_sent());
 }
 
 TEST_F(PacedSenderTest, PriorityInversion) {
   uint32_t ssrc = 12346;
   uint16_t sequence_number = 1234;
   const size_t kPacketSize = 1200;
 
-  EXPECT_FALSE(send_bucket_->SendPacket(
+  send_bucket_->InsertPacket(
       PacedSender::kHighPriority, ssrc, sequence_number + 3,
-      clock_.TimeInMilliseconds() + 33, kPacketSize, true));
+      clock_.TimeInMilliseconds() + 33, kPacketSize, true);
 
-  EXPECT_FALSE(send_bucket_->SendPacket(
+  send_bucket_->InsertPacket(
       PacedSender::kHighPriority, ssrc, sequence_number + 2,
-      clock_.TimeInMilliseconds() + 33, kPacketSize, true));
+      clock_.TimeInMilliseconds() + 33, kPacketSize, true);
 
-  EXPECT_FALSE(send_bucket_->SendPacket(
-      PacedSender::kHighPriority, ssrc, sequence_number,
-      clock_.TimeInMilliseconds(), kPacketSize, true));
+  send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc, sequence_number,
+                             clock_.TimeInMilliseconds(), kPacketSize, true);
 
-  EXPECT_FALSE(send_bucket_->SendPacket(
-      PacedSender::kHighPriority, ssrc, sequence_number + 1,
-      clock_.TimeInMilliseconds(), kPacketSize, true));
+  send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc,
+                             sequence_number + 1, clock_.TimeInMilliseconds(),
+                             kPacketSize, true);
 
   // Packets from earlier frames should be sent first.
   {
     ::testing::InSequence sequence;
     EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number,
                                             clock_.TimeInMilliseconds(), true))
         .WillOnce(Return(true));
     EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 1,
                                             clock_.TimeInMilliseconds(), true))
         .WillOnce(Return(true));
@@ skipping 24 matching lines @@
   send_bucket_->UpdateBitrate(60, 90, 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 form 0.
   clock_.AdvanceTimeMilliseconds(5);
   send_bucket_->UpdateBitrate(60, 90, 30);
 
-  EXPECT_FALSE(send_bucket_->SendPacket(
-      PacedSender::kHighPriority, ssrc, sequence_number++,
-      clock_.TimeInMilliseconds(), kPacketSize, false));
+  send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc,
+                             sequence_number++, clock_.TimeInMilliseconds(),
+                             kPacketSize, false);
 
   // Don't send padding if queue is non-empty, even if padding budget > 0.
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
   send_bucket_->Process();
 }
 
 }  // namespace test
 }  // namespace webrtc