From fd58b6106840c77538e864a22db68f6a8e28d848 Mon Sep 17 00:00:00 2001 From: philipel Date: Wed, 4 Jan 2017 07:05:25 -0800 Subject: [PATCH] BitrateProber::CreateProbeCluster now only accept one parameter (bitrate_bps). Instead of having to specify a bitrate and how many packets to use, the BitrateProber will now use the bitrate to calculate how many bytes it will use to probe that bitrate instead. For now, |kMinProbeDurationMs| is set to 15 ms which means that probing at 1900 kbps will result in 1900/8*0.015 = 3.5 kB used. Since we can expect packets to be smaller at the beginning of a stream (500 to 700 bytes) this will result in 7 to 5 packets sent for that bitrate, and should work very similar to how the current initial probing works. A minimum of 5 packets are always sent. BUG=webrtc:6822 Review-Url: https://codereview.webrtc.org/2609113003 Cr-Commit-Position: refs/heads/master@{#15899} --- .../congestion_controller/probe_controller.cc | 16 +------ .../probe_controller_unittest.cc | 32 ++++++------- webrtc/modules/pacing/bitrate_prober.cc | 39 ++++++++++------ webrtc/modules/pacing/bitrate_prober.h | 8 ++-- .../modules/pacing/bitrate_prober_unittest.cc | 45 ++++++++++++++++--- .../modules/pacing/mock/mock_paced_sender.h | 2 +- webrtc/modules/pacing/paced_sender.cc | 4 +- webrtc/modules/pacing/paced_sender.h | 6 +-- .../modules/pacing/paced_sender_unittest.cc | 29 ++++++------ 9 files changed, 106 insertions(+), 75 deletions(-) diff --git a/webrtc/modules/congestion_controller/probe_controller.cc b/webrtc/modules/congestion_controller/probe_controller.cc index 6ce7d6b5df..bf81517b70 100644 --- a/webrtc/modules/congestion_controller/probe_controller.cc +++ b/webrtc/modules/congestion_controller/probe_controller.cc @@ -20,12 +20,6 @@ namespace webrtc { namespace { - -// Number of deltas between probes per cluster. On the very first cluster, -// we will need kProbeDeltasPerCluster + 1 probes, but on a cluster following -// another, we need kProbeDeltasPerCluster probes. -constexpr int kProbeDeltasPerCluster = 5; - // Maximum waiting time from the time of initiating probing to getting // the measured results back. constexpr int64_t kMaxWaitingTimeForProbingResultMs = 1000; @@ -200,7 +194,6 @@ void ProbeController::InitiateProbing( int64_t now_ms, std::initializer_list bitrates_to_probe, bool probe_further) { - bool first_cluster = true; for (int64_t bitrate : bitrates_to_probe) { int64_t max_probe_bitrate_bps = max_bitrate_bps_ > 0 ? max_bitrate_bps_ : kDefaultMaxProbingBitrateBps; @@ -208,14 +201,7 @@ void ProbeController::InitiateProbing( bitrate = max_probe_bitrate_bps; probe_further = false; } - if (first_cluster) { - pacer_->CreateProbeCluster(rtc::checked_cast(bitrate), - kProbeDeltasPerCluster + 1); - first_cluster = false; - } else { - pacer_->CreateProbeCluster(rtc::checked_cast(bitrate), - kProbeDeltasPerCluster); - } + pacer_->CreateProbeCluster(rtc::checked_cast(bitrate)); } time_last_probing_initiated_ms_ = now_ms; if (probe_further) { diff --git a/webrtc/modules/congestion_controller/probe_controller_unittest.cc b/webrtc/modules/congestion_controller/probe_controller_unittest.cc index 02d83905fd..fd6ecc137f 100644 --- a/webrtc/modules/congestion_controller/probe_controller_unittest.cc +++ b/webrtc/modules/congestion_controller/probe_controller_unittest.cc @@ -49,24 +49,24 @@ class ProbeControllerTest : public ::testing::Test { }; TEST_F(ProbeControllerTest, InitiatesProbingAtStart) { - EXPECT_CALL(pacer_, CreateProbeCluster(_, _)).Times(AtLeast(2)); + EXPECT_CALL(pacer_, CreateProbeCluster(_)).Times(AtLeast(2)); probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps, kMaxBitrateBps); } TEST_F(ProbeControllerTest, ProbeOnlyWhenNetworkIsUp) { probe_controller_->OnNetworkStateChanged(kNetworkDown); - EXPECT_CALL(pacer_, CreateProbeCluster(_, _)).Times(0); + EXPECT_CALL(pacer_, CreateProbeCluster(_)).Times(0); probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps, kMaxBitrateBps); testing::Mock::VerifyAndClearExpectations(&pacer_); - EXPECT_CALL(pacer_, CreateProbeCluster(_, _)).Times(AtLeast(2)); + EXPECT_CALL(pacer_, CreateProbeCluster(_)).Times(AtLeast(2)); probe_controller_->OnNetworkStateChanged(kNetworkUp); } TEST_F(ProbeControllerTest, InitiatesProbingOnMaxBitrateIncrease) { - EXPECT_CALL(pacer_, CreateProbeCluster(_, _)).Times(AtLeast(2)); + EXPECT_CALL(pacer_, CreateProbeCluster(_)).Times(AtLeast(2)); probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps, kMaxBitrateBps); // Long enough to time out exponential probing. @@ -74,7 +74,7 @@ TEST_F(ProbeControllerTest, InitiatesProbingOnMaxBitrateIncrease) { probe_controller_->SetEstimatedBitrate(kStartBitrateBps); probe_controller_->Process(); - EXPECT_CALL(pacer_, CreateProbeCluster(kMaxBitrateBps + 100, _)); + EXPECT_CALL(pacer_, CreateProbeCluster(kMaxBitrateBps + 100)); probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps, kMaxBitrateBps + 100); } @@ -85,11 +85,11 @@ TEST_F(ProbeControllerTest, TestExponentialProbing) { // Repeated probe should only be sent when estimated bitrate climbs above // 0.7 * 6 * kStartBitrateBps = 1260. - EXPECT_CALL(pacer_, CreateProbeCluster(_, _)).Times(0); + EXPECT_CALL(pacer_, CreateProbeCluster(_)).Times(0); probe_controller_->SetEstimatedBitrate(1000); testing::Mock::VerifyAndClearExpectations(&pacer_); - EXPECT_CALL(pacer_, CreateProbeCluster(2 * 1800, _)); + EXPECT_CALL(pacer_, CreateProbeCluster(2 * 1800)); probe_controller_->SetEstimatedBitrate(1800); } @@ -101,12 +101,12 @@ TEST_F(ProbeControllerTest, TestExponentialProbingTimeout) { clock_.AdvanceTimeMilliseconds(kExponentialProbingTimeoutMs); probe_controller_->Process(); - EXPECT_CALL(pacer_, CreateProbeCluster(_, _)).Times(0); + EXPECT_CALL(pacer_, CreateProbeCluster(_)).Times(0); probe_controller_->SetEstimatedBitrate(1800); } TEST_F(ProbeControllerTest, ProbeAfterEstimateDropInAlr) { - EXPECT_CALL(pacer_, CreateProbeCluster(_, _)).Times(2); + EXPECT_CALL(pacer_, CreateProbeCluster(_)).Times(2); probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps, kMaxBitrateBps); probe_controller_->SetEstimatedBitrate(500); @@ -114,7 +114,7 @@ TEST_F(ProbeControllerTest, ProbeAfterEstimateDropInAlr) { // When bandwidth estimate drops the controller should send a probe at the // previous bitrate. - EXPECT_CALL(pacer_, CreateProbeCluster(500, _)).Times(1); + EXPECT_CALL(pacer_, CreateProbeCluster(500)).Times(1); EXPECT_CALL(pacer_, GetApplicationLimitedRegionStartTime()) .WillRepeatedly( Return(rtc::Optional(clock_.TimeInMilliseconds()))); @@ -124,7 +124,7 @@ TEST_F(ProbeControllerTest, ProbeAfterEstimateDropInAlr) { } TEST_F(ProbeControllerTest, PeriodicProbing) { - EXPECT_CALL(pacer_, CreateProbeCluster(_, _)).Times(2); + EXPECT_CALL(pacer_, CreateProbeCluster(_)).Times(2); probe_controller_->EnablePeriodicAlrProbing(true); probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps, kMaxBitrateBps); @@ -134,7 +134,7 @@ TEST_F(ProbeControllerTest, PeriodicProbing) { int64_t start_time = clock_.TimeInMilliseconds(); // Expect the controller to send a new probe after 5s has passed. - EXPECT_CALL(pacer_, CreateProbeCluster(1000, _)).Times(1); + EXPECT_CALL(pacer_, CreateProbeCluster(1000)).Times(1); EXPECT_CALL(pacer_, GetApplicationLimitedRegionStartTime()) .WillRepeatedly(Return(rtc::Optional(start_time))); clock_.AdvanceTimeMilliseconds(5000); @@ -143,7 +143,7 @@ TEST_F(ProbeControllerTest, PeriodicProbing) { testing::Mock::VerifyAndClearExpectations(&pacer_); // The following probe should be sent at 10s into ALR. - EXPECT_CALL(pacer_, CreateProbeCluster(_, _)).Times(0); + EXPECT_CALL(pacer_, CreateProbeCluster(_)).Times(0); EXPECT_CALL(pacer_, GetApplicationLimitedRegionStartTime()) .WillRepeatedly(Return(rtc::Optional(start_time))); clock_.AdvanceTimeMilliseconds(4000); @@ -151,7 +151,7 @@ TEST_F(ProbeControllerTest, PeriodicProbing) { probe_controller_->SetEstimatedBitrate(500); testing::Mock::VerifyAndClearExpectations(&pacer_); - EXPECT_CALL(pacer_, CreateProbeCluster(_, _)).Times(1); + EXPECT_CALL(pacer_, CreateProbeCluster(_)).Times(1); EXPECT_CALL(pacer_, GetApplicationLimitedRegionStartTime()) .WillRepeatedly(Return(rtc::Optional(start_time))); clock_.AdvanceTimeMilliseconds(1000); @@ -166,12 +166,12 @@ TEST_F(ProbeControllerTest, TestExponentialProbingOverflow) { 100 * kMbpsMultiplier); // Verify that probe bitrate is capped at the specified max bitrate - EXPECT_CALL(pacer_, CreateProbeCluster(100 * kMbpsMultiplier, _)); + EXPECT_CALL(pacer_, CreateProbeCluster(100 * kMbpsMultiplier)); probe_controller_->SetEstimatedBitrate(60 * kMbpsMultiplier); testing::Mock::VerifyAndClearExpectations(&pacer_); // Verify that repeated probes aren't sent. - EXPECT_CALL(pacer_, CreateProbeCluster(_, _)).Times(0); + EXPECT_CALL(pacer_, CreateProbeCluster(_)).Times(0); probe_controller_->SetEstimatedBitrate(100 * kMbpsMultiplier); } diff --git a/webrtc/modules/pacing/bitrate_prober.cc b/webrtc/modules/pacing/bitrate_prober.cc index 431aa21881..8e3c5e3547 100644 --- a/webrtc/modules/pacing/bitrate_prober.cc +++ b/webrtc/modules/pacing/bitrate_prober.cc @@ -26,6 +26,12 @@ constexpr int kInactivityThresholdMs = 5000; // A minimum interval between probes to allow scheduling to be feasible. constexpr int kMinProbeDeltaMs = 1; +// The minimum number probing packets used. +constexpr int kMinProbePacketsSent = 5; + +// The minimum probing duration in ms. +constexpr int kMinProbeDurationMs = 15; + int ComputeDeltaFromBitrate(size_t probe_size, uint32_t bitrate_bps) { RTC_CHECK_GT(bitrate_bps, 0); // Compute the time delta needed to send probe_size bytes at bitrate_bps @@ -68,16 +74,20 @@ void BitrateProber::OnIncomingPacket(size_t packet_size) { } } -void BitrateProber::CreateProbeCluster(int bitrate_bps, int num_probes) { +void BitrateProber::CreateProbeCluster(int bitrate_bps) { RTC_DCHECK(probing_state_ != ProbingState::kDisabled); ProbeCluster cluster; - cluster.max_probes = num_probes; - cluster.probe_bitrate_bps = bitrate_bps; + cluster.min_probes = kMinProbePacketsSent; + cluster.min_bytes = bitrate_bps * kMinProbeDurationMs / 8000; + cluster.bitrate_bps = bitrate_bps; cluster.id = next_cluster_id_++; clusters_.push(cluster); - LOG(LS_INFO) << "Probe cluster (bitrate:probes): (" - << cluster.probe_bitrate_bps << ":" << cluster.max_probes - << ") "; + + LOG(LS_INFO) << "Probe cluster (bitrate:min bytes:min packets): (" + << cluster.bitrate_bps << ":" << cluster.min_bytes << ":" + << cluster.min_probes << ")"; + // If we are already probing, continue to do so. Otherwise set it to + // kInactive and wait for OnIncomingPacket to start the probing. if (probing_state_ != ProbingState::kActive) probing_state_ = ProbingState::kInactive; } @@ -90,8 +100,7 @@ void BitrateProber::ResetState() { std::queue clusters; clusters.swap(clusters_); while (!clusters.empty()) { - CreateProbeCluster(clusters.front().probe_bitrate_bps, - clusters.front().max_probes); + CreateProbeCluster(clusters.front().bitrate_bps); clusters.pop(); } // If its enabled, reset to inactive. @@ -120,8 +129,8 @@ int BitrateProber::TimeUntilNextProbe(int64_t now_ms) { // sent before. int time_until_probe_ms = 0; if (probe_size_last_sent_ != 0 && probing_state_ == ProbingState::kActive) { - int next_delta_ms = ComputeDeltaFromBitrate( - probe_size_last_sent_, clusters_.front().probe_bitrate_bps); + int next_delta_ms = ComputeDeltaFromBitrate(probe_size_last_sent_, + clusters_.front().bitrate_bps); time_until_probe_ms = next_delta_ms - elapsed_time_ms; // If we have waited more than 3 ms for a new packet to probe with we will // consider this probing session over. @@ -147,8 +156,7 @@ int BitrateProber::CurrentClusterId() const { // feasible. size_t BitrateProber::RecommendedMinProbeSize() const { RTC_DCHECK(!clusters_.empty()); - return clusters_.front().probe_bitrate_bps * 2 * kMinProbeDeltaMs / - (8 * 1000); + return clusters_.front().bitrate_bps * 2 * kMinProbeDeltaMs / (8 * 1000); } void BitrateProber::ProbeSent(int64_t now_ms, size_t bytes) { @@ -158,9 +166,12 @@ void BitrateProber::ProbeSent(int64_t now_ms, size_t bytes) { time_last_probe_sent_ms_ = now_ms; if (!clusters_.empty()) { ProbeCluster* cluster = &clusters_.front(); - ++cluster->sent_probes; - if (cluster->sent_probes == cluster->max_probes) + cluster->sent_bytes += static_cast(bytes); + cluster->sent_probes += 1; + if (cluster->sent_bytes >= cluster->min_bytes && + cluster->sent_probes >= cluster->min_probes) { clusters_.pop(); + } if (clusters_.empty()) probing_state_ = ProbingState::kSuspended; } diff --git a/webrtc/modules/pacing/bitrate_prober.h b/webrtc/modules/pacing/bitrate_prober.h index 81eea64512..e1a0a84f10 100644 --- a/webrtc/modules/pacing/bitrate_prober.h +++ b/webrtc/modules/pacing/bitrate_prober.h @@ -38,7 +38,7 @@ class BitrateProber { // Create a cluster used to probe for |bitrate_bps| with |num_probes| number // of probes. - void CreateProbeCluster(int bitrate_bps, int num_probes); + void CreateProbeCluster(int bitrate_bps); // Returns the number of milliseconds until the next probe should be sent to // get accurate probing. @@ -74,9 +74,11 @@ class BitrateProber { // A probe cluster consists of a set of probes. Each probe in turn can be // divided into a number of packets to accomodate the MTU on the network. struct ProbeCluster { - int max_probes = 0; + int min_probes = 0; int sent_probes = 0; - int probe_bitrate_bps = 0; + int min_bytes = 0; + int sent_bytes = 0; + int bitrate_bps = 0; int id = -1; }; diff --git a/webrtc/modules/pacing/bitrate_prober_unittest.cc b/webrtc/modules/pacing/bitrate_prober_unittest.cc index fb353aaeab..8ac352de0e 100644 --- a/webrtc/modules/pacing/bitrate_prober_unittest.cc +++ b/webrtc/modules/pacing/bitrate_prober_unittest.cc @@ -21,8 +21,8 @@ TEST(BitrateProberTest, VerifyStatesAndTimeBetweenProbes) { int64_t now_ms = 0; EXPECT_EQ(-1, prober.TimeUntilNextProbe(now_ms)); - prober.CreateProbeCluster(900000, 6); - prober.CreateProbeCluster(1800000, 5); + prober.CreateProbeCluster(900000); + prober.CreateProbeCluster(1800000); EXPECT_FALSE(prober.IsProbing()); prober.OnIncomingPacket(1000); @@ -33,7 +33,7 @@ TEST(BitrateProberTest, VerifyStatesAndTimeBetweenProbes) { EXPECT_EQ(0, prober.TimeUntilNextProbe(now_ms)); prober.ProbeSent(now_ms, 1000); - for (int i = 0; i < 5; ++i) { + for (int i = 0; i < 4; ++i) { EXPECT_EQ(8, prober.TimeUntilNextProbe(now_ms)); now_ms += 4; EXPECT_EQ(4, prober.TimeUntilNextProbe(now_ms)); @@ -60,7 +60,7 @@ TEST(BitrateProberTest, DoesntProbeWithoutRecentPackets) { int64_t now_ms = 0; EXPECT_EQ(-1, prober.TimeUntilNextProbe(now_ms)); - prober.CreateProbeCluster(900000, 6); + prober.CreateProbeCluster(900000); EXPECT_FALSE(prober.IsProbing()); prober.OnIncomingPacket(1000); @@ -97,9 +97,44 @@ TEST(BitrateProberTest, VerifyProbeSizeOnHighBitrate) { BitrateProber prober; constexpr unsigned kHighBitrateBps = 10000000; // 10 Mbps - prober.CreateProbeCluster(kHighBitrateBps, 6); + prober.CreateProbeCluster(kHighBitrateBps); // Probe size should ensure a minimum of 1 ms interval. EXPECT_GT(prober.RecommendedMinProbeSize(), kHighBitrateBps / 8000); } +TEST(BitrateProberTest, MinumumNumberOfProbingPackets) { + BitrateProber prober; + // Even when probing at a low bitrate we expect a minimum number + // of packets to be sent. + constexpr int kBitrateBps = 100000; // 100 kbps + constexpr int kPacketSizeBytes = 1000; + + prober.CreateProbeCluster(kBitrateBps); + prober.OnIncomingPacket(kPacketSizeBytes); + for (int i = 0; i < 5; ++i) { + EXPECT_TRUE(prober.IsProbing()); + prober.ProbeSent(0, kPacketSizeBytes); + } + + EXPECT_FALSE(prober.IsProbing()); +} + +TEST(BitrateProberTest, ScaleBytesUsedForProbing) { + BitrateProber prober; + constexpr int kBitrateBps = 10000000; // 10 Mbps + constexpr int kPacketSizeBytes = 1000; + constexpr int kExpectedBytesSent = kBitrateBps * 15 / 8000; + + prober.CreateProbeCluster(kBitrateBps); + prober.OnIncomingPacket(kPacketSizeBytes); + int bytes_sent = 0; + while (bytes_sent < kExpectedBytesSent) { + EXPECT_TRUE(prober.IsProbing()); + prober.ProbeSent(0, kPacketSizeBytes); + bytes_sent += kPacketSizeBytes; + } + + EXPECT_FALSE(prober.IsProbing()); +} + } // namespace webrtc diff --git a/webrtc/modules/pacing/mock/mock_paced_sender.h b/webrtc/modules/pacing/mock/mock_paced_sender.h index eacc334e0a..1eee3f9f75 100644 --- a/webrtc/modules/pacing/mock/mock_paced_sender.h +++ b/webrtc/modules/pacing/mock/mock_paced_sender.h @@ -28,7 +28,7 @@ class MockPacedSender : public PacedSender { int64_t capture_time_ms, size_t bytes, bool retransmission)); - MOCK_METHOD2(CreateProbeCluster, void(int, int)); + MOCK_METHOD1(CreateProbeCluster, void(int)); MOCK_METHOD1(SetEstimatedBitrate, void(uint32_t)); MOCK_CONST_METHOD0(QueueInMs, int64_t()); MOCK_CONST_METHOD0(QueueInPackets, int()); diff --git a/webrtc/modules/pacing/paced_sender.cc b/webrtc/modules/pacing/paced_sender.cc index b3fc16d769..a0d7eda73f 100644 --- a/webrtc/modules/pacing/paced_sender.cc +++ b/webrtc/modules/pacing/paced_sender.cc @@ -267,9 +267,9 @@ PacedSender::PacedSender(Clock* clock, PacketSender* packet_sender) PacedSender::~PacedSender() {} -void PacedSender::CreateProbeCluster(int bitrate_bps, int num_packets) { +void PacedSender::CreateProbeCluster(int bitrate_bps) { CriticalSectionScoped cs(critsect_.get()); - prober_->CreateProbeCluster(bitrate_bps, num_packets); + prober_->CreateProbeCluster(bitrate_bps); } void PacedSender::Pause() { diff --git a/webrtc/modules/pacing/paced_sender.h b/webrtc/modules/pacing/paced_sender.h index b9bb1c39a4..50ebb14c57 100644 --- a/webrtc/modules/pacing/paced_sender.h +++ b/webrtc/modules/pacing/paced_sender.h @@ -26,6 +26,7 @@ class AlrDetector; class BitrateProber; class Clock; class CriticalSectionWrapper; +class ProbeClusterCreatedObserver; namespace paced_sender { class IntervalBudget; @@ -68,12 +69,11 @@ class PacedSender : public Module, public RtpPacketSender { static const size_t kMinProbePacketSize = 200; - PacedSender(Clock* clock, - PacketSender* packet_sender); + PacedSender(Clock* clock, PacketSender* packet_sender); virtual ~PacedSender(); - virtual void CreateProbeCluster(int bitrate_bps, int num_packets); + virtual void CreateProbeCluster(int bitrate_bps); // Temporarily pause all sending. void Pause(); diff --git a/webrtc/modules/pacing/paced_sender_unittest.cc b/webrtc/modules/pacing/paced_sender_unittest.cc index 183d339013..fc80a98813 100644 --- a/webrtc/modules/pacing/paced_sender_unittest.cc +++ b/webrtc/modules/pacing/paced_sender_unittest.cc @@ -21,9 +21,7 @@ using testing::Return; namespace { constexpr unsigned kFirstClusterBps = 900000; -constexpr int kFirstClusterCount = 6; constexpr unsigned kSecondClusterBps = 1800000; -constexpr int kSecondClusterCount = 5; // The error stems from truncating the time interval of probe packets to integer // values. This results in probing slightly higher than the target bitrate. @@ -105,8 +103,8 @@ class PacedSenderTest : public ::testing::Test { srand(0); // Need to initialize PacedSender after we initialize clock. send_bucket_.reset(new PacedSender(&clock_, &callback_)); - send_bucket_->CreateProbeCluster(kFirstClusterBps, kFirstClusterCount); - send_bucket_->CreateProbeCluster(kSecondClusterBps, kSecondClusterCount); + send_bucket_->CreateProbeCluster(kFirstClusterBps); + send_bucket_->CreateProbeCluster(kSecondClusterBps); // Default to bitrate probing disabled for testing purposes. Probing tests // have to enable probing, either by creating a new PacedSender instance or // by calling SetProbingEnabled(true). @@ -806,18 +804,18 @@ TEST_F(PacedSenderTest, ProbingWithInsertedPackets) { PacedSenderProbing packet_sender; send_bucket_.reset(new PacedSender(&clock_, &packet_sender)); - send_bucket_->CreateProbeCluster(kFirstClusterBps, kFirstClusterCount); - send_bucket_->CreateProbeCluster(kSecondClusterBps, kSecondClusterCount); + send_bucket_->CreateProbeCluster(kFirstClusterBps); + send_bucket_->CreateProbeCluster(kSecondClusterBps); send_bucket_->SetEstimatedBitrate(kInitialBitrateBps); - for (int i = 0; i < kFirstClusterCount + kSecondClusterCount; ++i) { + for (int i = 0; i < 10; ++i) { send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize, false); } int64_t start = clock_.TimeInMilliseconds(); - while (packet_sender.packets_sent() < kFirstClusterCount) { + while (packet_sender.packets_sent() < 5) { int time_until_process = send_bucket_->TimeUntilNextProcess(); clock_.AdvanceTimeMilliseconds(time_until_process); send_bucket_->Process(); @@ -831,8 +829,7 @@ TEST_F(PacedSenderTest, ProbingWithInsertedPackets) { EXPECT_EQ(0, packet_sender.padding_sent()); start = clock_.TimeInMilliseconds(); - while (packet_sender.packets_sent() < - kFirstClusterCount + kSecondClusterCount) { + while (packet_sender.packets_sent() < 10) { int time_until_process = send_bucket_->TimeUntilNextProcess(); clock_.AdvanceTimeMilliseconds(time_until_process); send_bucket_->Process(); @@ -852,10 +849,10 @@ TEST_F(PacedSenderTest, ProbingWithPaddingSupport) { PacedSenderProbing packet_sender; send_bucket_.reset(new PacedSender(&clock_, &packet_sender)); - send_bucket_->CreateProbeCluster(kFirstClusterBps, kFirstClusterCount); + send_bucket_->CreateProbeCluster(kFirstClusterBps); send_bucket_->SetEstimatedBitrate(kInitialBitrateBps); - for (int i = 0; i < kFirstClusterCount - 2; ++i) { + for (int i = 0; i < 3; ++i) { send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, sequence_number++, clock_.TimeInMilliseconds(), kPacketSize, false); @@ -863,7 +860,7 @@ TEST_F(PacedSenderTest, ProbingWithPaddingSupport) { int64_t start = clock_.TimeInMilliseconds(); int process_count = 0; - while (process_count < kFirstClusterCount) { + while (process_count < 5) { int time_until_process = send_bucket_->TimeUntilNextProcess(); clock_.AdvanceTimeMilliseconds(time_until_process); send_bucket_->Process(); @@ -1009,7 +1006,7 @@ TEST_F(PacedSenderTest, ProbeClusterId) { send_bucket_->SetSendBitrateLimits(kTargetBitrateBps, kTargetBitrateBps); send_bucket_->SetProbingEnabled(true); - for (int i = 0; i < 11; ++i) { + for (int i = 0; i < 10; ++i) { send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc, sequence_number + i, clock_.TimeInMilliseconds(), kPacketSize, false); @@ -1017,9 +1014,9 @@ TEST_F(PacedSenderTest, ProbeClusterId) { // First probing cluster. EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, 0)) - .Times(6) + .Times(5) .WillRepeatedly(Return(true)); - for (int i = 0; i < 6; ++i) { + for (int i = 0; i < 5; ++i) { clock_.AdvanceTimeMilliseconds(20); send_bucket_->Process(); }