Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(359)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: webrtc/modules/pacing/paced_sender_unittest.cc

Issue 1392513002: Disable pacer disabling. (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master
Patch Set: Remove RTP FIR + test refactoring Created 5 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « webrtc/modules/pacing/paced_sender.cc ('k') | webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: webrtc/modules/pacing/paced_sender_unittest.cc
diff --git a/webrtc/modules/pacing/paced_sender_unittest.cc b/webrtc/modules/pacing/paced_sender_unittest.cc
index a00b5fa58deb0bd79db174b4748457b0ff33dc8f..1e701ff8ea4cf1e9c9756873cfa504676f8080f8 100644
--- a/webrtc/modules/pacing/paced_sender_unittest.cc
+++ b/webrtc/modules/pacing/paced_sender_unittest.cc
@@ -124,8 +124,8 @@ class PacedSenderTest : public ::testing::Test {
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)
@@ -160,8 +160,9 @@ TEST_F(PacedSenderTest, QueuePacket) {
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);
@@ -188,8 +189,9 @@ TEST_F(PacedSenderTest, QueuePacket) {
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();
}
@@ -207,8 +209,9 @@ TEST_F(PacedSenderTest, PaceQueuedPackets) {
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);
@@ -243,8 +246,9 @@ TEST_F(PacedSenderTest, PaceQueuedPackets) {
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();
}
@@ -266,10 +270,12 @@ TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) {
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();
@@ -308,8 +314,9 @@ TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) {
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();
}
@@ -377,23 +384,6 @@ TEST_F(PacedSenderTest, Padding) {
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;
@@ -433,9 +423,9 @@ TEST_F(PacedSenderTest, VerifyAverageBitrateVaryingMediaPayload) {
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();
@@ -474,15 +464,15 @@ TEST_F(PacedSenderTest, Priority) {
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);
@@ -538,20 +528,20 @@ TEST_F(PacedSenderTest, Pause) {
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());
@@ -593,19 +583,12 @@ TEST_F(PacedSenderTest, ResendPacket) {
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());
@@ -726,12 +709,9 @@ TEST_F(PacedSenderTest, ProbingWithInitialFrame) {
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();
@@ -758,9 +738,9 @@ TEST_F(PacedSenderTest, ProbingWithTooSmallInitialFrame) {
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();
@@ -783,21 +763,20 @@ TEST_F(PacedSenderTest, PriorityInversion) {
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.
{
@@ -842,9 +821,9 @@ TEST_F(PacedSenderTest, PaddingOveruse) {
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);
« no previous file with comments | « webrtc/modules/pacing/paced_sender.cc ('k') | webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698