Add functionality which limits the number of bytes on the network.

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 633 matching lines @@
                                false);
     send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc_high_priority,
                                sequence_number++, second_capture_time_ms, 250,
                                false);
   }
 
   // Expect everything to be queued.
   EXPECT_EQ(second_capture_time_ms - capture_time_ms,
             send_bucket_->QueueInMs());
 
-  for (int i = 0; i < 10; ++i) {
-    clock_.AdvanceTimeMilliseconds(5);
+  EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
+  EXPECT_CALL(callback_, TimeToSendPadding(1, _)).Times(1);
+  send_bucket_->Process();
+
+  int64_t expected_time_until_send = 500;
+  EXPECT_CALL(callback_, TimeToSendPadding(1, _)).Times(1);
+  while (expected_time_until_send >= 0) {
     // TimeUntilNextProcess must not return 0 when paused.  If it does,
     // we risk running a busy loop, so ideally it should return a large value.
-    EXPECT_GE(send_bucket_->TimeUntilNextProcess(), 1000);
-    send_bucket_->Process();
+    EXPECT_EQ(expected_time_until_send, send_bucket_->TimeUntilNextProcess());
+    if (expected_time_until_send == 0)
+      send_bucket_->Process();
+    clock_.AdvanceTimeMilliseconds(5);
+    expected_time_until_send -= 5;
   }
 
   // Expect high prio packets to come out first followed by normal
   // prio packets and low prio packets (all in capture order).
   {
     ::testing::InSequence sequence;
     EXPECT_CALL(callback_,
                 TimeToSendPacket(ssrc_high_priority, _, capture_time_ms, _, _))
         .Times(packets_to_send_per_interval)
         .WillRepeatedly(Return(true));
@@ skipping 22 matching lines @@
     for (size_t i = 0; i < packets_to_send_per_interval; ++i) {
       EXPECT_CALL(callback_, TimeToSendPacket(ssrc_low_priority, _,
                                               second_capture_time_ms, _, _))
           .Times(1)
           .WillRepeatedly(Return(true));
     }
   }
   send_bucket_->Resume();
 
   for (size_t i = 0; i < 4; i++) {
+    EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
+    send_bucket_->Process();
     EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
     clock_.AdvanceTimeMilliseconds(5);
-    EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
-    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());
@@ skipping 373 matching lines @@
       .WillRepeatedly(Return(0));
   send_bucket_->Process();
   EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess());
   clock_.AdvanceTimeMilliseconds(1);
   send_bucket_->Process();
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
 }
 
 }  // namespace test
 }  // namespace webrtc