diff options
| author | Danil Chapovalov <danilchap@webrtc.org> | 2020-02-07 14:53:52 +0100 |
|---|---|---|
| committer | Commit Bot <commit-bot@chromium.org> | 2020-02-10 11:49:57 +0000 |
| commit | 5528402ef8656bee17a09a87ea764bd05b58a913 (patch) | |
| tree | dad96eadfebdbcac11bf14a4c207260b046b1b9a /modules/congestion_controller | |
| parent | 2fe31a47b6698491610ac8e0f3969dafe2c6f8c7 (diff) | |
| download | webrtc-5528402ef8656bee17a09a87ea764bd05b58a913.tar.gz | |
Use newer version of TimeDelta and TimeStamp factories in modules/
This change generated with following commands:
find modules -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/TimeDelta::Micros<\(.*\)>()/TimeDelta::Micros(\1)/g"
find modules -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/TimeDelta::Millis<\(.*\)>()/TimeDelta::Millis(\1)/g"
find modules -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/TimeDelta::Seconds<\(.*\)>()/TimeDelta::Seconds(\1)/g"
find modules -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/TimeDelta::us/TimeDelta::Micros/g"
find modules -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/TimeDelta::ms/TimeDelta::Millis/g"
find modules -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/TimeDelta::seconds/TimeDelta::Seconds/g"
find modules -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/Timestamp::Micros<\(.*\)>()/Timestamp::Micros(\1)/g"
find modules -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/Timestamp::Millis<\(.*\)>()/Timestamp::Millis(\1)/g"
find modules -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/Timestamp::Seconds<\(.*\)>()/Timestamp::Seconds(\1)/g"
find modules -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/Timestamp::us/Timestamp::Micros/g"
find modules -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/Timestamp::ms/Timestamp::Millis/g"
find modules -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/Timestamp::seconds/Timestamp::Seconds/g"
git cl format
Bug: None
Change-Id: I117d64a54950be040d996035c54bc0043310943a
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/168340
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30489}
Diffstat (limited to 'modules/congestion_controller')
33 files changed, 335 insertions, 320 deletions
diff --git a/modules/congestion_controller/bbr/bandwidth_sampler_unittest.cc b/modules/congestion_controller/bbr/bandwidth_sampler_unittest.cc index 3bd205a847..3280858d95 100644 --- a/modules/congestion_controller/bbr/bandwidth_sampler_unittest.cc +++ b/modules/congestion_controller/bbr/bandwidth_sampler_unittest.cc @@ -42,7 +42,7 @@ const DataSize kRegularPacketSize = DataSize::bytes(kRegularPacketSizeBytes); class BandwidthSamplerTest : public ::testing::Test { protected: BandwidthSamplerTest() - : clock_(Timestamp::seconds(100)), bytes_in_flight_(DataSize::Zero()) {} + : clock_(Timestamp::Seconds(100)), bytes_in_flight_(DataSize::Zero()) {} Timestamp clock_; BandwidthSampler sampler_; @@ -99,9 +99,9 @@ class BandwidthSamplerTest : public ::testing::Test { // Test the sampler in a simple stop-and-wait sender setting. TEST_F(BandwidthSamplerTest, SendAndWait) { - TimeDelta time_between_packets = TimeDelta::ms(10); + TimeDelta time_between_packets = TimeDelta::Millis(10); DataRate expected_bandwidth = - kRegularPacketSize * 100 / TimeDelta::seconds(1); + kRegularPacketSize * 100 / TimeDelta::Seconds(1); // Send packets at the constant bandwidth. for (int64_t i = 1; i < 20; i++) { @@ -128,7 +128,7 @@ TEST_F(BandwidthSamplerTest, SendAndWait) { // Test the sampler during regular windowed sender scenario with fixed // CWND of 20. TEST_F(BandwidthSamplerTest, SendPaced) { - const TimeDelta time_between_packets = TimeDelta::ms(1); + const TimeDelta time_between_packets = TimeDelta::Millis(1); DataRate expected_bandwidth = kRegularPacketSize / time_between_packets; Send40PacketsAndAckFirst20(time_between_packets); @@ -146,7 +146,7 @@ TEST_F(BandwidthSamplerTest, SendPaced) { // Test the sampler in a scenario where 50% of packets is consistently lost. TEST_F(BandwidthSamplerTest, SendWithLosses) { - const TimeDelta time_between_packets = TimeDelta::ms(1); + const TimeDelta time_between_packets = TimeDelta::Millis(1); DataRate expected_bandwidth = kRegularPacketSize / time_between_packets * 0.5; // Send 20 packets, each 1 ms apart. @@ -185,7 +185,7 @@ TEST_F(BandwidthSamplerTest, SendWithLosses) { // Simulate a situation where ACKs arrive in burst and earlier than usual, thus // producing an ACK rate which is higher than the original send rate. TEST_F(BandwidthSamplerTest, CompressedAck) { - const TimeDelta time_between_packets = TimeDelta::ms(1); + const TimeDelta time_between_packets = TimeDelta::Millis(1); DataRate expected_bandwidth = kRegularPacketSize / time_between_packets; Send40PacketsAndAckFirst20(time_between_packets); @@ -195,7 +195,7 @@ TEST_F(BandwidthSamplerTest, CompressedAck) { // Ack the packets 21 to 40 almost immediately at once. DataRate last_bandwidth = DataRate::Zero(); - TimeDelta ridiculously_small_time_delta = TimeDelta::us(20); + TimeDelta ridiculously_small_time_delta = TimeDelta::Micros(20); for (int64_t i = 21; i <= 40; i++) { last_bandwidth = AckPacket(i); clock_ += ridiculously_small_time_delta; @@ -207,7 +207,7 @@ TEST_F(BandwidthSamplerTest, CompressedAck) { // Tests receiving ACK packets in the reverse order. TEST_F(BandwidthSamplerTest, ReorderedAck) { - const TimeDelta time_between_packets = TimeDelta::ms(1); + const TimeDelta time_between_packets = TimeDelta::Millis(1); DataRate expected_bandwidth = kRegularPacketSize / time_between_packets; Send40PacketsAndAckFirst20(time_between_packets); @@ -234,7 +234,7 @@ TEST_F(BandwidthSamplerTest, ReorderedAck) { // Test the app-limited logic. TEST_F(BandwidthSamplerTest, AppLimited) { - const TimeDelta time_between_packets = TimeDelta::ms(1); + const TimeDelta time_between_packets = TimeDelta::Millis(1); DataRate expected_bandwidth = kRegularPacketSize / time_between_packets; Send40PacketsAndAckFirst20(time_between_packets); @@ -249,7 +249,7 @@ TEST_F(BandwidthSamplerTest, AppLimited) { } // Enter quiescence. - clock_ += TimeDelta::seconds(1); + clock_ += TimeDelta::Seconds(1); // Send packets 41 to 60, all of which would be marked as app-limited. for (int64_t i = 41; i <= 60; i++) { @@ -282,8 +282,8 @@ TEST_F(BandwidthSamplerTest, AppLimited) { // Test the samples taken at the first flight of packets sent. TEST_F(BandwidthSamplerTest, FirstRoundTrip) { - const TimeDelta time_between_packets = TimeDelta::ms(1); - const TimeDelta rtt = TimeDelta::ms(800); + const TimeDelta time_between_packets = TimeDelta::Millis(1); + const TimeDelta rtt = TimeDelta::Millis(800); const int num_packets = 10; const DataSize num_bytes = kRegularPacketSize * num_packets; const DataRate real_bandwidth = num_bytes / rtt; @@ -321,7 +321,7 @@ TEST_F(BandwidthSamplerTest, RemoveObsoletePackets) { SendPacket(4); SendPacket(5); - clock_ += TimeDelta::ms(100); + clock_ += TimeDelta::Millis(100); EXPECT_EQ(5u, BandwidthSamplerPeer::GetNumberOfTrackedPackets(sampler_)); sampler_.RemoveObsoletePackets(4); diff --git a/modules/congestion_controller/bbr/bbr_network_controller.cc b/modules/congestion_controller/bbr/bbr_network_controller.cc index ad08541308..e707f7a346 100644 --- a/modules/congestion_controller/bbr/bbr_network_controller.cc +++ b/modules/congestion_controller/bbr/bbr_network_controller.cc @@ -509,7 +509,7 @@ NetworkControlUpdate BbrNetworkController::OnNetworkStateEstimate( TimeDelta BbrNetworkController::GetMinRtt() const { return !min_rtt_.IsZero() ? min_rtt_ - : TimeDelta::us(rtt_stats_.initial_rtt_us()); + : TimeDelta::Micros(rtt_stats_.initial_rtt_us()); } DataSize BbrNetworkController::GetTargetCongestionWindow(double gain) const { @@ -597,7 +597,7 @@ bool BbrNetworkController::UpdateBandwidthAndMinRtt( min_rtt_since_last_probe_rtt_ = std::min(min_rtt_since_last_probe_rtt_, sample_rtt); - const TimeDelta kMinRttExpiry = TimeDelta::seconds(kMinRttExpirySeconds); + const TimeDelta kMinRttExpiry = TimeDelta::Seconds(kMinRttExpirySeconds); // Do not expire min_rtt if none was ever available. bool min_rtt_expired = !min_rtt_.IsZero() && (now > (min_rtt_timestamp_ + kMinRttExpiry)); @@ -733,7 +733,8 @@ void BbrNetworkController::MaybeEnterOrExitProbeRtt( // we allow an extra packet since QUIC checks CWND before sending a // packet. if (msg.data_in_flight < ProbeRttCongestionWindow() + kMaxPacketSize) { - exit_probe_rtt_at_ = msg.feedback_time + TimeDelta::ms(kProbeRttTimeMs); + exit_probe_rtt_at_ = + msg.feedback_time + TimeDelta::Millis(kProbeRttTimeMs); probe_rtt_round_passed_ = false; } } else { diff --git a/modules/congestion_controller/bbr/bbr_network_controller_unittest.cc b/modules/congestion_controller/bbr/bbr_network_controller_unittest.cc index 3e5403a313..92fb5ec577 100644 --- a/modules/congestion_controller/bbr/bbr_network_controller_unittest.cc +++ b/modules/congestion_controller/bbr/bbr_network_controller_unittest.cc @@ -33,7 +33,7 @@ namespace test { namespace { const DataRate kInitialBitrate = DataRate::kbps(60); -const Timestamp kDefaultStartTime = Timestamp::ms(10000000); +const Timestamp kDefaultStartTime = Timestamp::Millis(10000000); constexpr double kDataRateMargin = 0.3; constexpr double kMinDataRateFactor = 1 - kDataRateMargin; @@ -126,11 +126,11 @@ TEST_F(BbrNetworkControllerTest, UpdatesTargetSendRate) { config.transport.rates.start_rate = DataRate::kbps(300); auto send_net = s.CreateMutableSimulationNode([](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(500); - c->delay = TimeDelta::ms(100); + c->delay = TimeDelta::Millis(100); c->loss_rate = 0.0; }); auto ret_net = s.CreateMutableSimulationNode( - [](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(100); }); + [](NetworkSimulationConfig* c) { c->delay = TimeDelta::Millis(100); }); auto* client = s.CreateClient("send", config); const DataSize kOverhead = DataSize::bytes(38); // IPV4 + UDP + SRTP auto routes = s.CreateRoutes(client, {send_net->node()}, kOverhead, @@ -138,25 +138,25 @@ TEST_F(BbrNetworkControllerTest, UpdatesTargetSendRate) { {ret_net->node()}, kOverhead); s.CreateVideoStream(routes->forward(), VideoStreamConfig()); - s.RunFor(TimeDelta::seconds(25)); + s.RunFor(TimeDelta::Seconds(25)); EXPECT_NEAR(client->send_bandwidth().kbps(), 450, 100); send_net->UpdateConfig([](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(800); - c->delay = TimeDelta::ms(100); + c->delay = TimeDelta::Millis(100); }); - s.RunFor(TimeDelta::seconds(20)); + s.RunFor(TimeDelta::Seconds(20)); EXPECT_NEAR(client->send_bandwidth().kbps(), 750, 150); send_net->UpdateConfig([](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(200); - c->delay = TimeDelta::ms(200); + c->delay = TimeDelta::Millis(200); }); ret_net->UpdateConfig( - [](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(200); }); + [](NetworkSimulationConfig* c) { c->delay = TimeDelta::Millis(200); }); - s.RunFor(TimeDelta::seconds(35)); + s.RunFor(TimeDelta::Seconds(35)); EXPECT_NEAR(client->send_bandwidth().kbps(), 170, 50); } diff --git a/modules/congestion_controller/bbr/data_transfer_tracker_unittest.cc b/modules/congestion_controller/bbr/data_transfer_tracker_unittest.cc index a60343dba0..de0a2b4cfd 100644 --- a/modules/congestion_controller/bbr/data_transfer_tracker_unittest.cc +++ b/modules/congestion_controller/bbr/data_transfer_tracker_unittest.cc @@ -27,16 +27,17 @@ class DataTransferTrackerForTest : public DataTransferTracker { public: void AddSample(int bytes, int send_time_ms, int ack_time_ms) { DataTransferTracker::AddSample(DataSize::bytes(bytes), - Timestamp::ms(send_time_ms), - Timestamp::ms(ack_time_ms)); + Timestamp::Millis(send_time_ms), + Timestamp::Millis(ack_time_ms)); } void ClearOldSamples(int excluding_end_ms) { - DataTransferTracker::ClearOldSamples(Timestamp::ms(excluding_end_ms)); + DataTransferTracker::ClearOldSamples(Timestamp::Millis(excluding_end_ms)); } ResultForTest GetRatesByAckTime(int covered_start_ms, int including_end_ms) { auto result = DataTransferTracker::GetRatesByAckTime( - Timestamp::ms(covered_start_ms), Timestamp::ms(including_end_ms)); + Timestamp::Millis(covered_start_ms), + Timestamp::Millis(including_end_ms)); return ResultForTest{result.ack_timespan.ms(), result.send_timespan.ms(), result.acked_data.bytes()}; } diff --git a/modules/congestion_controller/bbr/loss_rate_filter_unittest.cc b/modules/congestion_controller/bbr/loss_rate_filter_unittest.cc index f553177b08..24603d8c7d 100644 --- a/modules/congestion_controller/bbr/loss_rate_filter_unittest.cc +++ b/modules/congestion_controller/bbr/loss_rate_filter_unittest.cc @@ -17,7 +17,7 @@ namespace webrtc { namespace bbr { namespace { -const Timestamp kTestStartTime = Timestamp::seconds(100000); +const Timestamp kTestStartTime = Timestamp::Seconds(100000); } // namespace TEST(LossRateFilterTest, AccumulatesToOne) { @@ -25,7 +25,7 @@ TEST(LossRateFilterTest, AccumulatesToOne) { Timestamp current_time = kTestStartTime; for (int i = 0; i < 10; i++) { filter.UpdateWithLossStatus(current_time.ms(), 10, 10); - current_time += TimeDelta::seconds(1); + current_time += TimeDelta::Seconds(1); } EXPECT_NEAR(filter.GetLossRate(), 1.0, 0.01); } @@ -35,7 +35,7 @@ TEST(LossRateFilterTest, StaysAtZero) { Timestamp current_time = kTestStartTime; for (int i = 0; i < 10; i++) { filter.UpdateWithLossStatus(current_time.ms(), 10, 0); - current_time += TimeDelta::seconds(1); + current_time += TimeDelta::Seconds(1); } EXPECT_NEAR(filter.GetLossRate(), 0.0, 0.01); } @@ -46,12 +46,12 @@ TEST(LossRateFilterTest, VariesWithInput) { for (int j = 0; j < 10; j++) { for (int i = 0; i < 5; i++) { filter.UpdateWithLossStatus(current_time.ms(), 10, 10); - current_time += TimeDelta::seconds(1); + current_time += TimeDelta::Seconds(1); } EXPECT_NEAR(filter.GetLossRate(), 1.0, 0.1); for (int i = 0; i < 5; i++) { filter.UpdateWithLossStatus(current_time.ms(), 10, 0); - current_time += TimeDelta::seconds(1); + current_time += TimeDelta::Seconds(1); } EXPECT_NEAR(filter.GetLossRate(), 0.0, 0.1); } @@ -63,7 +63,7 @@ TEST(LossRateFilterTest, DetectsChangingRate) { for (int per_decile = 0; per_decile < 10; per_decile += 1) { // Update every 200 ms for 2 seconds for (int i = 0; i < 10; i++) { - current_time += TimeDelta::ms(200); + current_time += TimeDelta::Millis(200); filter.UpdateWithLossStatus(current_time.ms(), 10, per_decile); } EXPECT_NEAR(filter.GetLossRate(), per_decile / 10.0, 0.05); diff --git a/modules/congestion_controller/bbr/rtt_stats_unittest.cc b/modules/congestion_controller/bbr/rtt_stats_unittest.cc index 54b142575c..133292e5ec 100644 --- a/modules/congestion_controller/bbr/rtt_stats_unittest.cc +++ b/modules/congestion_controller/bbr/rtt_stats_unittest.cc @@ -34,20 +34,20 @@ TEST_F(RttStatsTest, DefaultsBeforeUpdate) { TEST_F(RttStatsTest, SmoothedRtt) { // Verify that ack_delay is corrected for in Smoothed RTT. - rtt_stats_.UpdateRtt(TimeDelta::ms(300), TimeDelta::ms(100), - Timestamp::ms(0)); - EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.latest_rtt()); - EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.smoothed_rtt()); + rtt_stats_.UpdateRtt(TimeDelta::Millis(300), TimeDelta::Millis(100), + Timestamp::Millis(0)); + EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.latest_rtt()); + EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.smoothed_rtt()); // Verify that effective RTT of zero does not change Smoothed RTT. - rtt_stats_.UpdateRtt(TimeDelta::ms(200), TimeDelta::ms(200), - Timestamp::ms(0)); - EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.latest_rtt()); - EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.smoothed_rtt()); + rtt_stats_.UpdateRtt(TimeDelta::Millis(200), TimeDelta::Millis(200), + Timestamp::Millis(0)); + EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.latest_rtt()); + EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.smoothed_rtt()); // Verify that large erroneous ack_delay does not change Smoothed RTT. - rtt_stats_.UpdateRtt(TimeDelta::ms(200), TimeDelta::ms(300), - Timestamp::ms(0)); - EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.latest_rtt()); - EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.smoothed_rtt()); + rtt_stats_.UpdateRtt(TimeDelta::Millis(200), TimeDelta::Millis(300), + Timestamp::Millis(0)); + EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.latest_rtt()); + EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.smoothed_rtt()); } // Ensure that the potential rounding artifacts in EWMA calculation do not cause @@ -56,7 +56,8 @@ TEST_F(RttStatsTest, SmoothedRttStability) { for (int64_t time = 3; time < 20000; time++) { RttStats stats; for (int64_t i = 0; i < 100; i++) { - stats.UpdateRtt(TimeDelta::us(time), TimeDelta::ms(0), Timestamp::ms(0)); + stats.UpdateRtt(TimeDelta::Micros(time), TimeDelta::Millis(0), + Timestamp::Millis(0)); int64_t time_delta_us = stats.smoothed_rtt().us() - time; ASSERT_LE(std::abs(time_delta_us), 1); } @@ -65,42 +66,44 @@ TEST_F(RttStatsTest, SmoothedRttStability) { TEST_F(RttStatsTest, PreviousSmoothedRtt) { // Verify that ack_delay is corrected for in Smoothed RTT. - rtt_stats_.UpdateRtt(TimeDelta::ms(300), TimeDelta::ms(100), - Timestamp::ms(0)); - EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.latest_rtt()); - EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.smoothed_rtt()); + rtt_stats_.UpdateRtt(TimeDelta::Millis(300), TimeDelta::Millis(100), + Timestamp::Millis(0)); + EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.latest_rtt()); + EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.smoothed_rtt()); EXPECT_EQ(TimeDelta::Zero(), rtt_stats_.previous_srtt()); // Ensure the previous SRTT is 200ms after a 100ms sample. - rtt_stats_.UpdateRtt(TimeDelta::ms(100), TimeDelta::Zero(), Timestamp::ms(0)); - EXPECT_EQ(TimeDelta::ms(100), rtt_stats_.latest_rtt()); - EXPECT_EQ(TimeDelta::us(187500).us(), rtt_stats_.smoothed_rtt().us()); - EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.previous_srtt()); + rtt_stats_.UpdateRtt(TimeDelta::Millis(100), TimeDelta::Zero(), + Timestamp::Millis(0)); + EXPECT_EQ(TimeDelta::Millis(100), rtt_stats_.latest_rtt()); + EXPECT_EQ(TimeDelta::Micros(187500).us(), rtt_stats_.smoothed_rtt().us()); + EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.previous_srtt()); } TEST_F(RttStatsTest, MinRtt) { - rtt_stats_.UpdateRtt(TimeDelta::ms(200), TimeDelta::Zero(), Timestamp::ms(0)); - EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.min_rtt()); - rtt_stats_.UpdateRtt(TimeDelta::ms(10), TimeDelta::Zero(), - Timestamp::ms(0) + TimeDelta::ms(10)); - EXPECT_EQ(TimeDelta::ms(10), rtt_stats_.min_rtt()); - rtt_stats_.UpdateRtt(TimeDelta::ms(50), TimeDelta::Zero(), - Timestamp::ms(0) + TimeDelta::ms(20)); - EXPECT_EQ(TimeDelta::ms(10), rtt_stats_.min_rtt()); - rtt_stats_.UpdateRtt(TimeDelta::ms(50), TimeDelta::Zero(), - Timestamp::ms(0) + TimeDelta::ms(30)); - EXPECT_EQ(TimeDelta::ms(10), rtt_stats_.min_rtt()); - rtt_stats_.UpdateRtt(TimeDelta::ms(50), TimeDelta::Zero(), - Timestamp::ms(0) + TimeDelta::ms(40)); - EXPECT_EQ(TimeDelta::ms(10), rtt_stats_.min_rtt()); + rtt_stats_.UpdateRtt(TimeDelta::Millis(200), TimeDelta::Zero(), + Timestamp::Millis(0)); + EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.min_rtt()); + rtt_stats_.UpdateRtt(TimeDelta::Millis(10), TimeDelta::Zero(), + Timestamp::Millis(0) + TimeDelta::Millis(10)); + EXPECT_EQ(TimeDelta::Millis(10), rtt_stats_.min_rtt()); + rtt_stats_.UpdateRtt(TimeDelta::Millis(50), TimeDelta::Zero(), + Timestamp::Millis(0) + TimeDelta::Millis(20)); + EXPECT_EQ(TimeDelta::Millis(10), rtt_stats_.min_rtt()); + rtt_stats_.UpdateRtt(TimeDelta::Millis(50), TimeDelta::Zero(), + Timestamp::Millis(0) + TimeDelta::Millis(30)); + EXPECT_EQ(TimeDelta::Millis(10), rtt_stats_.min_rtt()); + rtt_stats_.UpdateRtt(TimeDelta::Millis(50), TimeDelta::Zero(), + Timestamp::Millis(0) + TimeDelta::Millis(40)); + EXPECT_EQ(TimeDelta::Millis(10), rtt_stats_.min_rtt()); // Verify that ack_delay does not go into recording of min_rtt_. - rtt_stats_.UpdateRtt(TimeDelta::ms(7), TimeDelta::ms(2), - Timestamp::ms(0) + TimeDelta::ms(50)); - EXPECT_EQ(TimeDelta::ms(7), rtt_stats_.min_rtt()); + rtt_stats_.UpdateRtt(TimeDelta::Millis(7), TimeDelta::Millis(2), + Timestamp::Millis(0) + TimeDelta::Millis(50)); + EXPECT_EQ(TimeDelta::Millis(7), rtt_stats_.min_rtt()); } TEST_F(RttStatsTest, ExpireSmoothedMetrics) { - TimeDelta initial_rtt = TimeDelta::ms(10); - rtt_stats_.UpdateRtt(initial_rtt, TimeDelta::Zero(), Timestamp::ms(0)); + TimeDelta initial_rtt = TimeDelta::Millis(10); + rtt_stats_.UpdateRtt(initial_rtt, TimeDelta::Zero(), Timestamp::Millis(0)); EXPECT_EQ(initial_rtt, rtt_stats_.min_rtt()); EXPECT_EQ(initial_rtt, rtt_stats_.smoothed_rtt()); @@ -108,7 +111,7 @@ TEST_F(RttStatsTest, ExpireSmoothedMetrics) { // Update once with a 20ms RTT. TimeDelta doubled_rtt = 2 * initial_rtt; - rtt_stats_.UpdateRtt(doubled_rtt, TimeDelta::Zero(), Timestamp::ms(0)); + rtt_stats_.UpdateRtt(doubled_rtt, TimeDelta::Zero(), Timestamp::Millis(0)); EXPECT_EQ(1.125 * initial_rtt, rtt_stats_.smoothed_rtt()); // Expire the smoothed metrics, increasing smoothed rtt and mean deviation. @@ -119,7 +122,7 @@ TEST_F(RttStatsTest, ExpireSmoothedMetrics) { // Now go back down to 5ms and expire the smoothed metrics, and ensure the // mean deviation increases to 15ms. TimeDelta half_rtt = 0.5 * initial_rtt; - rtt_stats_.UpdateRtt(half_rtt, TimeDelta::Zero(), Timestamp::ms(0)); + rtt_stats_.UpdateRtt(half_rtt, TimeDelta::Zero(), Timestamp::Millis(0)); EXPECT_GT(doubled_rtt, rtt_stats_.smoothed_rtt()); EXPECT_LT(initial_rtt, rtt_stats_.mean_deviation()); } @@ -127,29 +130,30 @@ TEST_F(RttStatsTest, ExpireSmoothedMetrics) { TEST_F(RttStatsTest, UpdateRttWithBadSendDeltas) { // Make sure we ignore bad RTTs. - TimeDelta initial_rtt = TimeDelta::ms(10); - rtt_stats_.UpdateRtt(initial_rtt, TimeDelta::Zero(), Timestamp::ms(0)); + TimeDelta initial_rtt = TimeDelta::Millis(10); + rtt_stats_.UpdateRtt(initial_rtt, TimeDelta::Zero(), Timestamp::Millis(0)); EXPECT_EQ(initial_rtt, rtt_stats_.min_rtt()); EXPECT_EQ(initial_rtt, rtt_stats_.smoothed_rtt()); std::vector<TimeDelta> bad_send_deltas; bad_send_deltas.push_back(TimeDelta::Zero()); bad_send_deltas.push_back(TimeDelta::PlusInfinity()); - bad_send_deltas.push_back(TimeDelta::us(-1000)); + bad_send_deltas.push_back(TimeDelta::Micros(-1000)); for (TimeDelta bad_send_delta : bad_send_deltas) { - rtt_stats_.UpdateRtt(bad_send_delta, TimeDelta::Zero(), Timestamp::ms(0)); + rtt_stats_.UpdateRtt(bad_send_delta, TimeDelta::Zero(), + Timestamp::Millis(0)); EXPECT_EQ(initial_rtt, rtt_stats_.min_rtt()); EXPECT_EQ(initial_rtt, rtt_stats_.smoothed_rtt()); } } TEST_F(RttStatsTest, ResetAfterConnectionMigrations) { - rtt_stats_.UpdateRtt(TimeDelta::ms(300), TimeDelta::ms(100), - Timestamp::ms(0)); - EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.latest_rtt()); - EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.smoothed_rtt()); - EXPECT_EQ(TimeDelta::ms(300), rtt_stats_.min_rtt()); + rtt_stats_.UpdateRtt(TimeDelta::Millis(300), TimeDelta::Millis(100), + Timestamp::Millis(0)); + EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.latest_rtt()); + EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.smoothed_rtt()); + EXPECT_EQ(TimeDelta::Millis(300), rtt_stats_.min_rtt()); // Reset rtt stats on connection migrations. rtt_stats_.OnConnectionMigration(); diff --git a/modules/congestion_controller/bbr/windowed_filter_unittest.cc b/modules/congestion_controller/bbr/windowed_filter_unittest.cc index 7ab4588b65..5b36e86634 100644 --- a/modules/congestion_controller/bbr/windowed_filter_unittest.cc +++ b/modules/congestion_controller/bbr/windowed_filter_unittest.cc @@ -36,7 +36,7 @@ class WindowedFilterTest : public ::testing::Test { // Third best = 50ms, recorded at 100ms void InitializeMinFilter() { int64_t now_ms = 0; - TimeDelta rtt_sample = TimeDelta::ms(10); + TimeDelta rtt_sample = TimeDelta::Millis(10); for (int i = 0; i < 5; ++i) { windowed_min_rtt_.Update(rtt_sample, now_ms); RTC_LOG(LS_VERBOSE) << "i: " << i << " sample: " << ToString(rtt_sample) @@ -46,11 +46,11 @@ class WindowedFilterTest : public ::testing::Test { << ToString(windowed_min_rtt_.GetSecondBest()) << " " << ToString(windowed_min_rtt_.GetThirdBest()); now_ms += 25; - rtt_sample = rtt_sample + TimeDelta::ms(10); + rtt_sample = rtt_sample + TimeDelta::Millis(10); } - EXPECT_EQ(TimeDelta::ms(20), windowed_min_rtt_.GetBest()); - EXPECT_EQ(TimeDelta::ms(40), windowed_min_rtt_.GetSecondBest()); - EXPECT_EQ(TimeDelta::ms(50), windowed_min_rtt_.GetThirdBest()); + EXPECT_EQ(TimeDelta::Millis(20), windowed_min_rtt_.GetBest()); + EXPECT_EQ(TimeDelta::Millis(40), windowed_min_rtt_.GetSecondBest()); + EXPECT_EQ(TimeDelta::Millis(50), windowed_min_rtt_.GetThirdBest()); } // Sets up windowed_max_bw_ to have the following values: @@ -107,15 +107,15 @@ TEST_F(WindowedFilterTest, UninitializedEstimates) { TEST_F(WindowedFilterTest, MonotonicallyIncreasingMin) { int64_t now_ms = 0; - TimeDelta rtt_sample = TimeDelta::ms(10); + TimeDelta rtt_sample = TimeDelta::Millis(10); windowed_min_rtt_.Update(rtt_sample, now_ms); - EXPECT_EQ(TimeDelta::ms(10), windowed_min_rtt_.GetBest()); + EXPECT_EQ(TimeDelta::Millis(10), windowed_min_rtt_.GetBest()); // Gradually increase the rtt samples and ensure the windowed min rtt starts // rising. for (int i = 0; i < 6; ++i) { now_ms += 25; - rtt_sample = rtt_sample + TimeDelta::ms(10); + rtt_sample = rtt_sample + TimeDelta::Millis(10); windowed_min_rtt_.Update(rtt_sample, now_ms); RTC_LOG(LS_VERBOSE) << "i: " << i << " sample: " << rtt_sample.ms() << " mins: " @@ -124,11 +124,11 @@ TEST_F(WindowedFilterTest, MonotonicallyIncreasingMin) { << windowed_min_rtt_.GetSecondBest().ms() << " " << windowed_min_rtt_.GetThirdBest().ms(); if (i < 3) { - EXPECT_EQ(TimeDelta::ms(10), windowed_min_rtt_.GetBest()); + EXPECT_EQ(TimeDelta::Millis(10), windowed_min_rtt_.GetBest()); } else if (i == 3) { - EXPECT_EQ(TimeDelta::ms(20), windowed_min_rtt_.GetBest()); + EXPECT_EQ(TimeDelta::Millis(20), windowed_min_rtt_.GetBest()); } else if (i < 6) { - EXPECT_EQ(TimeDelta::ms(40), windowed_min_rtt_.GetBest()); + EXPECT_EQ(TimeDelta::Millis(40), windowed_min_rtt_.GetBest()); } } } @@ -164,16 +164,17 @@ TEST_F(WindowedFilterTest, MonotonicallyDecreasingMax) { TEST_F(WindowedFilterTest, SampleChangesThirdBestMin) { InitializeMinFilter(); // RTT sample lower than the third-choice min-rtt sets that, but nothing else. - TimeDelta rtt_sample = windowed_min_rtt_.GetThirdBest() - TimeDelta::ms(5); + TimeDelta rtt_sample = + windowed_min_rtt_.GetThirdBest() - TimeDelta::Millis(5); // This assert is necessary to avoid triggering -Wstrict-overflow // See crbug/616957 - ASSERT_GT(windowed_min_rtt_.GetThirdBest(), TimeDelta::ms(5)); + ASSERT_GT(windowed_min_rtt_.GetThirdBest(), TimeDelta::Millis(5)); // Latest sample was recorded at 100ms. int64_t now_ms = 101; windowed_min_rtt_.Update(rtt_sample, now_ms); EXPECT_EQ(rtt_sample, windowed_min_rtt_.GetThirdBest()); - EXPECT_EQ(TimeDelta::ms(40), windowed_min_rtt_.GetSecondBest()); - EXPECT_EQ(TimeDelta::ms(20), windowed_min_rtt_.GetBest()); + EXPECT_EQ(TimeDelta::Millis(40), windowed_min_rtt_.GetSecondBest()); + EXPECT_EQ(TimeDelta::Millis(20), windowed_min_rtt_.GetBest()); } TEST_F(WindowedFilterTest, SampleChangesThirdBestMax) { @@ -193,16 +194,17 @@ TEST_F(WindowedFilterTest, SampleChangesSecondBestMin) { InitializeMinFilter(); // RTT sample lower than the second-choice min sets that and also // the third-choice min. - TimeDelta rtt_sample = windowed_min_rtt_.GetSecondBest() - TimeDelta::ms(5); + TimeDelta rtt_sample = + windowed_min_rtt_.GetSecondBest() - TimeDelta::Millis(5); // This assert is necessary to avoid triggering -Wstrict-overflow // See crbug/616957 - ASSERT_GT(windowed_min_rtt_.GetSecondBest(), TimeDelta::ms(5)); + ASSERT_GT(windowed_min_rtt_.GetSecondBest(), TimeDelta::Millis(5)); // Latest sample was recorded at 100ms. int64_t now_ms = 101; windowed_min_rtt_.Update(rtt_sample, now_ms); EXPECT_EQ(rtt_sample, windowed_min_rtt_.GetThirdBest()); EXPECT_EQ(rtt_sample, windowed_min_rtt_.GetSecondBest()); - EXPECT_EQ(TimeDelta::ms(20), windowed_min_rtt_.GetBest()); + EXPECT_EQ(TimeDelta::Millis(20), windowed_min_rtt_.GetBest()); } TEST_F(WindowedFilterTest, SampleChangesSecondBestMax) { @@ -224,10 +226,10 @@ TEST_F(WindowedFilterTest, SampleChangesAllMins) { InitializeMinFilter(); // RTT sample lower than the first-choice min-rtt sets that and also // the second and third-choice mins. - TimeDelta rtt_sample = windowed_min_rtt_.GetBest() - TimeDelta::ms(5); + TimeDelta rtt_sample = windowed_min_rtt_.GetBest() - TimeDelta::Millis(5); // This assert is necessary to avoid triggering -Wstrict-overflow // See crbug/616957 - ASSERT_GT(windowed_min_rtt_.GetBest(), TimeDelta::ms(5)); + ASSERT_GT(windowed_min_rtt_.GetBest(), TimeDelta::Millis(5)); // Latest sample was recorded at 100ms. int64_t now_ms = 101; windowed_min_rtt_.Update(rtt_sample, now_ms); @@ -253,7 +255,7 @@ TEST_F(WindowedFilterTest, ExpireBestMin) { InitializeMinFilter(); TimeDelta old_third_best = windowed_min_rtt_.GetThirdBest(); TimeDelta old_second_best = windowed_min_rtt_.GetSecondBest(); - TimeDelta rtt_sample = old_third_best + TimeDelta::ms(5); + TimeDelta rtt_sample = old_third_best + TimeDelta::Millis(5); // Best min sample was recorded at 25ms, so expiry time is 124ms. int64_t now_ms = 125; windowed_min_rtt_.Update(rtt_sample, now_ms); @@ -278,7 +280,7 @@ TEST_F(WindowedFilterTest, ExpireBestMax) { TEST_F(WindowedFilterTest, ExpireSecondBestMin) { InitializeMinFilter(); TimeDelta old_third_best = windowed_min_rtt_.GetThirdBest(); - TimeDelta rtt_sample = old_third_best + TimeDelta::ms(5); + TimeDelta rtt_sample = old_third_best + TimeDelta::Millis(5); // Second best min sample was recorded at 75ms, so expiry time is 174ms. int64_t now_ms = 175; windowed_min_rtt_.Update(rtt_sample, now_ms); @@ -301,7 +303,8 @@ TEST_F(WindowedFilterTest, ExpireSecondBestMax) { TEST_F(WindowedFilterTest, ExpireAllMins) { InitializeMinFilter(); - TimeDelta rtt_sample = windowed_min_rtt_.GetThirdBest() + TimeDelta::ms(5); + TimeDelta rtt_sample = + windowed_min_rtt_.GetThirdBest() + TimeDelta::Millis(5); // This assert is necessary to avoid triggering -Wstrict-overflow // See crbug/616957 ASSERT_LT(windowed_min_rtt_.GetThirdBest(), TimeDelta::PlusInfinity()); diff --git a/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_interface.cc b/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_interface.cc index 8abe6d6884..d5b1a13fcc 100644 --- a/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_interface.cc +++ b/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_interface.cc @@ -35,10 +35,10 @@ RobustThroughputEstimatorSettings::RobustThroughputEstimatorSettings( initial_packets = 20; } initial_packets = std::min(initial_packets, min_packets); - if (window_duration < TimeDelta::ms(100) || - TimeDelta::ms(2000) < window_duration) { + if (window_duration < TimeDelta::Millis(100) || + TimeDelta::Millis(2000) < window_duration) { RTC_LOG(LS_WARNING) << "Window duration must be between 100 and 2000 ms"; - window_duration = TimeDelta::ms(500); + window_duration = TimeDelta::Millis(500); } if (unacked_weight < 0.0 || 1.0 < unacked_weight) { RTC_LOG(LS_WARNING) diff --git a/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_interface.h b/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_interface.h index fb257cf3f4..f802191a2c 100644 --- a/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_interface.h +++ b/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_interface.h @@ -47,7 +47,7 @@ struct RobustThroughputEstimatorSettings { // The estimator window keeps at least |min_packets| packets and up to // kMaxPackets received during the last |window_duration|. unsigned min_packets = 20; - TimeDelta window_duration = TimeDelta::ms(500); + TimeDelta window_duration = TimeDelta::Millis(500); // The estimator window requires at least |initial_packets| packets received // over at least |initial_duration|. diff --git a/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_unittest.cc b/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_unittest.cc index 83ead59e18..2e98debd9d 100644 --- a/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_unittest.cc +++ b/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_unittest.cc @@ -60,15 +60,16 @@ AcknowledgedBitrateEstimatorTestStates CreateTestStates() { std::vector<PacketResult> CreateFeedbackVector() { std::vector<PacketResult> packet_feedback_vector(2); - packet_feedback_vector[0].receive_time = Timestamp::ms(kFirstArrivalTimeMs); + packet_feedback_vector[0].receive_time = + Timestamp::Millis(kFirstArrivalTimeMs); packet_feedback_vector[0].sent_packet.send_time = - Timestamp::ms(kFirstSendTimeMs); + Timestamp::Millis(kFirstSendTimeMs); packet_feedback_vector[0].sent_packet.sequence_number = kSequenceNumber; packet_feedback_vector[0].sent_packet.size = DataSize::bytes(kPayloadSize); packet_feedback_vector[1].receive_time = - Timestamp::ms(kFirstArrivalTimeMs + 10); + Timestamp::Millis(kFirstArrivalTimeMs + 10); packet_feedback_vector[1].sent_packet.send_time = - Timestamp::ms(kFirstSendTimeMs + 10); + Timestamp::Millis(kFirstSendTimeMs + 10); packet_feedback_vector[1].sent_packet.sequence_number = kSequenceNumber; packet_feedback_vector[1].sent_packet.size = DataSize::bytes(kPayloadSize + 10); @@ -116,7 +117,7 @@ TEST(TestAcknowledgedBitrateEstimator, ExpectFastRateChangeWhenLeftAlr) { .Times(1); } states.acknowledged_bitrate_estimator->SetAlrEndedTime( - Timestamp::ms(kFirstArrivalTimeMs + 1)); + Timestamp::Millis(kFirstArrivalTimeMs + 1)); states.acknowledged_bitrate_estimator->IncomingPacketFeedbackVector( packet_feedback_vector); } diff --git a/modules/congestion_controller/goog_cc/bitrate_estimator.cc b/modules/congestion_controller/goog_cc/bitrate_estimator.cc index a68f33ec87..2be08d5cbc 100644 --- a/modules/congestion_controller/goog_cc/bitrate_estimator.cc +++ b/modules/congestion_controller/goog_cc/bitrate_estimator.cc @@ -153,7 +153,7 @@ absl::optional<DataRate> BitrateEstimator::bitrate() const { absl::optional<DataRate> BitrateEstimator::PeekRate() const { if (current_window_ms_ > 0) - return DataSize::bytes(sum_) / TimeDelta::ms(current_window_ms_); + return DataSize::bytes(sum_) / TimeDelta::Millis(current_window_ms_); return absl::nullopt; } diff --git a/modules/congestion_controller/goog_cc/delay_based_bwe.cc b/modules/congestion_controller/goog_cc/delay_based_bwe.cc index 0a84284572..b39da880a0 100644 --- a/modules/congestion_controller/goog_cc/delay_based_bwe.cc +++ b/modules/congestion_controller/goog_cc/delay_based_bwe.cc @@ -28,7 +28,7 @@ namespace webrtc { namespace { -constexpr TimeDelta kStreamTimeOut = TimeDelta::Seconds<2>(); +constexpr TimeDelta kStreamTimeOut = TimeDelta::Seconds(2); constexpr int kTimestampGroupLengthMs = 5; constexpr int kAbsSendTimeFraction = 18; constexpr int kAbsSendTimeInterArrivalUpshift = 8; diff --git a/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc b/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc index 92e6f02f52..5d3c30b9ad 100644 --- a/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc +++ b/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc @@ -53,7 +53,7 @@ int64_t RtpStream::GenerateFrame(int64_t time_now_us, for (size_t i = 0; i < n_packets; ++i) { PacketResult packet; packet.sent_packet.send_time = - Timestamp::us(time_now_us + kSendSideOffsetUs); + Timestamp::Micros(time_now_us + kSendSideOffsetUs); packet.sent_packet.size = DataSize::bytes(payload_size); packets->push_back(packet); } @@ -137,7 +137,7 @@ int64_t StreamGenerator::GenerateFrame(std::vector<PacketResult>* packets, prev_arrival_time_us_ = std::max(time_now_us + required_network_time_us, prev_arrival_time_us_ + required_network_time_us); - packet.receive_time = Timestamp::us(prev_arrival_time_us_); + packet.receive_time = Timestamp::Micros(prev_arrival_time_us_); ++i; } it = std::min_element(streams_.begin(), streams_.end(), RtpStream::Compare); @@ -194,8 +194,8 @@ void DelayBasedBweTest::IncomingFeedback(int64_t arrival_time_ms, RTC_CHECK_GE(arrival_time_ms + arrival_time_offset_ms_, 0); PacketResult packet; packet.receive_time = - Timestamp::ms(arrival_time_ms + arrival_time_offset_ms_); - packet.sent_packet.send_time = Timestamp::ms(send_time_ms); + Timestamp::Millis(arrival_time_ms + arrival_time_offset_ms_); + packet.sent_packet.send_time = Timestamp::Millis(send_time_ms); packet.sent_packet.size = DataSize::bytes(payload_size); packet.sent_packet.pacing_info = pacing_info; if (packet.sent_packet.pacing_info.probe_cluster_id != @@ -203,7 +203,7 @@ void DelayBasedBweTest::IncomingFeedback(int64_t arrival_time_ms, probe_bitrate_estimator_->HandleProbeAndEstimateBitrate(packet); TransportPacketsFeedback msg; - msg.feedback_time = Timestamp::ms(clock_.TimeInMilliseconds()); + msg.feedback_time = Timestamp::Millis(clock_.TimeInMilliseconds()); msg.packet_feedbacks.push_back(packet); acknowledged_bitrate_estimator_->IncomingPacketFeedbackVector( msg.SortedByReceiveTime()); @@ -239,7 +239,7 @@ bool DelayBasedBweTest::GenerateAndProcessFrame(uint32_t ssrc, clock_.TimeInMicroseconds()); for (auto& packet : packets) { RTC_CHECK_GE(packet.receive_time.ms() + arrival_time_offset_ms_, 0); - packet.receive_time += TimeDelta::ms(arrival_time_offset_ms_); + packet.receive_time += TimeDelta::Millis(arrival_time_offset_ms_); if (packet.sent_packet.pacing_info.probe_cluster_id != PacedPacketInfo::kNotAProbe) @@ -249,7 +249,7 @@ bool DelayBasedBweTest::GenerateAndProcessFrame(uint32_t ssrc, acknowledged_bitrate_estimator_->IncomingPacketFeedbackVector(packets); TransportPacketsFeedback msg; msg.packet_feedbacks = packets; - msg.feedback_time = Timestamp::ms(clock_.TimeInMilliseconds()); + msg.feedback_time = Timestamp::Millis(clock_.TimeInMilliseconds()); DelayBasedBwe::Result result = bitrate_estimator_->IncomingPacketFeedbackVector( diff --git a/modules/congestion_controller/goog_cc/goog_cc_network_control.cc b/modules/congestion_controller/goog_cc/goog_cc_network_control.cc index fb3305e01d..3fb5dedd87 100644 --- a/modules/congestion_controller/goog_cc/goog_cc_network_control.cc +++ b/modules/congestion_controller/goog_cc/goog_cc_network_control.cc @@ -34,7 +34,7 @@ namespace webrtc { namespace { // From RTCPSender video report interval. -constexpr TimeDelta kLossUpdateInterval = TimeDelta::Millis<1000>(); +constexpr TimeDelta kLossUpdateInterval = TimeDelta::Millis(1000); // Pacing-rate relative to our target send rate. // Multiplicative factor that is applied to the target bitrate to calculate @@ -372,13 +372,13 @@ NetworkControlUpdate GoogCcNetworkController::OnTransportLossReport( } void GoogCcNetworkController::UpdateCongestionWindowSize() { - TimeDelta min_feedback_max_rtt = TimeDelta::ms( + TimeDelta min_feedback_max_rtt = TimeDelta::Millis( *std::min_element(feedback_max_rtts_.begin(), feedback_max_rtts_.end())); const DataSize kMinCwnd = DataSize::bytes(2 * 1500); TimeDelta time_window = min_feedback_max_rtt + - TimeDelta::ms( + TimeDelta::Millis( rate_control_settings_.GetCongestionWindowAdditionalTimeMs()); DataSize data_window = last_loss_based_target_rate_ * time_window; @@ -435,7 +435,7 @@ NetworkControlUpdate GoogCcNetworkController::OnTransportPacketsFeedback( feedback_max_rtts_.end(), 0); int64_t mean_rtt_ms = sum_rtt_ms / feedback_max_rtts_.size(); if (delay_based_bwe_) - delay_based_bwe_->OnRttUpdate(TimeDelta::ms(mean_rtt_ms)); + delay_based_bwe_->OnRttUpdate(TimeDelta::Millis(mean_rtt_ms)); } TimeDelta feedback_min_rtt = TimeDelta::PlusInfinity(); @@ -674,7 +674,7 @@ PacerConfig GoogCcNetworkController::GetPacingRates(Timestamp at_time) const { std::min(max_padding_rate_, last_pushback_target_rate_); PacerConfig msg; msg.at_time = at_time; - msg.time_window = TimeDelta::seconds(1); + msg.time_window = TimeDelta::Seconds(1); msg.data_window = pacing_rate * msg.time_window; msg.pad_window = padding_rate * msg.time_window; return msg; diff --git a/modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc b/modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc index 3ce9a77841..2a35de7426 100644 --- a/modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc +++ b/modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc @@ -83,11 +83,11 @@ void UpdatesTargetRateBasedOnLinkCapacity(std::string test_name = "") { config.transport.rates.start_rate = DataRate::kbps(300); auto send_net = s.CreateMutableSimulationNode([](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(500); - c->delay = TimeDelta::ms(100); + c->delay = TimeDelta::Millis(100); c->loss_rate = 0.0; }); auto ret_net = s.CreateMutableSimulationNode( - [](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(100); }); + [](NetworkSimulationConfig* c) { c->delay = TimeDelta::Millis(100); }); StatesPrinter* truth = s.CreatePrinter( "send.truth.txt", TimeDelta::PlusInfinity(), {send_net->ConfigPrinter()}); @@ -95,29 +95,29 @@ void UpdatesTargetRateBasedOnLinkCapacity(std::string test_name = "") { {ret_net->node()}); truth->PrintRow(); - s.RunFor(TimeDelta::seconds(25)); + s.RunFor(TimeDelta::Seconds(25)); truth->PrintRow(); EXPECT_NEAR(client->target_rate().kbps(), 450, 100); send_net->UpdateConfig([](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(800); - c->delay = TimeDelta::ms(100); + c->delay = TimeDelta::Millis(100); }); truth->PrintRow(); - s.RunFor(TimeDelta::seconds(20)); + s.RunFor(TimeDelta::Seconds(20)); truth->PrintRow(); EXPECT_NEAR(client->target_rate().kbps(), 750, 150); send_net->UpdateConfig([](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(100); - c->delay = TimeDelta::ms(200); + c->delay = TimeDelta::Millis(200); }); ret_net->UpdateConfig( - [](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(200); }); + [](NetworkSimulationConfig* c) { c->delay = TimeDelta::Millis(200); }); truth->PrintRow(); - s.RunFor(TimeDelta::seconds(50)); + s.RunFor(TimeDelta::Seconds(50)); truth->PrintRow(); EXPECT_NEAR(client->target_rate().kbps(), 90, 25); } @@ -126,7 +126,7 @@ void UpdatesTargetRateBasedOnLinkCapacity(std::string test_name = "") { class GoogCcNetworkControllerTest : public ::testing::Test { protected: GoogCcNetworkControllerTest() - : current_time_(Timestamp::ms(123456)), factory_() {} + : current_time_(Timestamp::Millis(123456)), factory_() {} ~GoogCcNetworkControllerTest() override {} void SetUp() override { @@ -178,10 +178,10 @@ class GoogCcNetworkControllerTest : public ::testing::Test { PacedPacketInfo pacing_info) { PacketResult packet_result; packet_result.sent_packet = SentPacket(); - packet_result.sent_packet.send_time = Timestamp::ms(send_time_ms); + packet_result.sent_packet.send_time = Timestamp::Millis(send_time_ms); packet_result.sent_packet.size = DataSize::bytes(payload_size); packet_result.sent_packet.pacing_info = pacing_info; - packet_result.receive_time = Timestamp::ms(arrival_time_ms); + packet_result.receive_time = Timestamp::Millis(arrival_time_ms); return packet_result; } @@ -199,7 +199,7 @@ class GoogCcNetworkControllerTest : public ::testing::Test { } void AdvanceTimeMilliseconds(int timedelta_ms) { - current_time_ += TimeDelta::ms(timedelta_ms); + current_time_ += TimeDelta::Millis(timedelta_ms); } void OnUpdate(NetworkControlUpdate update) { @@ -264,10 +264,10 @@ TEST_F(GoogCcNetworkControllerTest, CongestionWindowPushbackOnNetworkDelay) { auto send_net = s.CreateMutableSimulationNode([=](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(1000); - c->delay = TimeDelta::ms(100); + c->delay = TimeDelta::Millis(100); }); auto ret_net = s.CreateSimulationNode( - [](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(100); }); + [](NetworkSimulationConfig* c) { c->delay = TimeDelta::Millis(100); }); CallClientConfig config; config.transport.cc_factory = &factory; // Start high so bandwidth drop has max effect. @@ -278,9 +278,9 @@ TEST_F(GoogCcNetworkControllerTest, CongestionWindowPushbackOnNetworkDelay) { auto* client = CreateVideoSendingClient(&s, std::move(config), {send_net->node()}, {ret_net}); - s.RunFor(TimeDelta::seconds(10)); - send_net->PauseTransmissionUntil(s.Now() + TimeDelta::seconds(10)); - s.RunFor(TimeDelta::seconds(3)); + s.RunFor(TimeDelta::Seconds(10)); + send_net->PauseTransmissionUntil(s.Now() + TimeDelta::Seconds(10)); + s.RunFor(TimeDelta::Seconds(3)); // After 3 seconds without feedback from any sent packets, we expect that the // target rate is reduced to the minimum pushback threshold @@ -385,10 +385,10 @@ TEST_F(GoogCcNetworkControllerTest, auto send_net = s.CreateMutableSimulationNode([=](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(1000); - c->delay = TimeDelta::ms(100); + c->delay = TimeDelta::Millis(100); }); auto ret_net = s.CreateSimulationNode( - [](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(100); }); + [](NetworkSimulationConfig* c) { c->delay = TimeDelta::Millis(100); }); CallClientConfig config; // Start high so bandwidth drop has max effect. config.transport.rates.start_rate = DataRate::kbps(1000); @@ -402,13 +402,13 @@ TEST_F(GoogCcNetworkControllerTest, s.CreateVideoStream(route->forward(), video); // Run for a few seconds to allow the controller to stabilize. - s.RunFor(TimeDelta::seconds(10)); + s.RunFor(TimeDelta::Seconds(10)); // Check that padding rate matches target rate. EXPECT_NEAR(client->padding_rate().kbps(), client->target_rate().kbps(), 1); // Check this is also the case when congestion window pushback kicks in. - send_net->PauseTransmissionUntil(s.Now() + TimeDelta::seconds(1)); + send_net->PauseTransmissionUntil(s.Now() + TimeDelta::Seconds(1)); EXPECT_NEAR(client->padding_rate().kbps(), client->target_rate().kbps(), 1); } @@ -424,27 +424,27 @@ TEST_F(GoogCcNetworkControllerTest, LimitsToFloorIfRttIsHighInTrial) { // burst that blocks media from being sent. This causes the RTT to quickly // increase above the threshold in the trial. const DataRate kLinkCapacity = DataRate::kbps(100); - const TimeDelta kBufferBloatDuration = TimeDelta::seconds(10); + const TimeDelta kBufferBloatDuration = TimeDelta::Seconds(10); Scenario s("googcc_unit/limit_trial", false); auto send_net = s.CreateSimulationNode([=](NetworkSimulationConfig* c) { c->bandwidth = kLinkCapacity; - c->delay = TimeDelta::ms(100); + c->delay = TimeDelta::Millis(100); }); auto ret_net = s.CreateSimulationNode( - [](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(100); }); + [](NetworkSimulationConfig* c) { c->delay = TimeDelta::Millis(100); }); CallClientConfig config; config.transport.rates.start_rate = kLinkCapacity; auto* client = CreateVideoSendingClient(&s, config, {send_net}, {ret_net}); // Run for a few seconds to allow the controller to stabilize. - s.RunFor(TimeDelta::seconds(10)); + s.RunFor(TimeDelta::Seconds(10)); const DataSize kBloatPacketSize = DataSize::bytes(1000); const int kBloatPacketCount = static_cast<int>(kBufferBloatDuration * kLinkCapacity / kBloatPacketSize); // This will cause the RTT to be large for a while. s.TriggerPacketBurst({send_net}, kBloatPacketCount, kBloatPacketSize.bytes()); // Wait to allow the high RTT to be detected and acted upon. - s.RunFor(TimeDelta::seconds(6)); + s.RunFor(TimeDelta::Seconds(6)); // By now the target rate should have dropped to the minimum configured rate. EXPECT_NEAR(client->target_rate().kbps(), kBandwidthFloor.kbps(), 5); } @@ -460,13 +460,13 @@ TEST_F(GoogCcNetworkControllerTest, StableEstimateDoesNotVaryInSteadyState) { config.transport.cc_factory = &factory; NetworkSimulationConfig net_conf; net_conf.bandwidth = DataRate::kbps(500); - net_conf.delay = TimeDelta::ms(100); + net_conf.delay = TimeDelta::Millis(100); auto send_net = s.CreateSimulationNode(net_conf); auto ret_net = s.CreateSimulationNode(net_conf); auto* client = CreateVideoSendingClient(&s, config, {send_net}, {ret_net}); // Run for a while to allow the estimate to stabilize. - s.RunFor(TimeDelta::seconds(30)); + s.RunFor(TimeDelta::Seconds(30)); DataRate min_stable_target = DataRate::PlusInfinity(); DataRate max_stable_target = DataRate::MinusInfinity(); DataRate min_target = DataRate::PlusInfinity(); @@ -482,7 +482,7 @@ TEST_F(GoogCcNetworkControllerTest, StableEstimateDoesNotVaryInSteadyState) { max_stable_target = std::max(max_stable_target, stable_target_rate); min_target = std::min(min_target, target_rate); max_target = std::max(max_target, target_rate); - s.RunFor(TimeDelta::seconds(1)); + s.RunFor(TimeDelta::Seconds(1)); } // We should expect drops by at least 15% (default backoff.) EXPECT_LT(min_target / max_target, 0.85); @@ -507,15 +507,15 @@ TEST_F(GoogCcNetworkControllerTest, config.transport.rates.start_rate = DataRate::kbps(300); auto send_net = s.CreateSimulationNode([](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(2000); - c->delay = TimeDelta::ms(200); + c->delay = TimeDelta::Millis(200); c->loss_rate = 0.1; }); auto ret_net = s.CreateSimulationNode( - [](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(200); }); + [](NetworkSimulationConfig* c) { c->delay = TimeDelta::Millis(200); }); auto* client = CreateVideoSendingClient(&s, config, {send_net}, {ret_net}); - s.RunFor(TimeDelta::seconds(120)); + s.RunFor(TimeDelta::Seconds(120)); // Without LossBasedControl trial, bandwidth drops to ~10 kbps. EXPECT_GT(client->target_rate().kbps(), 100); } @@ -524,7 +524,7 @@ DataRate AverageBitrateAfterCrossInducedLoss(std::string name) { Scenario s(name, false); NetworkSimulationConfig net_conf; net_conf.bandwidth = DataRate::kbps(1000); - net_conf.delay = TimeDelta::ms(100); + net_conf.delay = TimeDelta::Millis(100); // Short queue length means that we'll induce loss when sudden TCP traffic // spikes are induced. This corresponds to ca 200 ms for a packet size of 1000 // bytes. Such limited buffers are common on for instance wifi routers. @@ -540,15 +540,15 @@ DataRate AverageBitrateAfterCrossInducedLoss(std::string name) { auto* video = s.CreateVideoStream(route->forward(), [](VideoStreamConfig* c) { c->stream.use_rtx = false; }); - s.RunFor(TimeDelta::seconds(10)); + s.RunFor(TimeDelta::Seconds(10)); for (int i = 0; i < 4; ++i) { // Sends TCP cross traffic inducing loss. auto* tcp_traffic = s.net()->StartFakeTcpCrossTraffic(send_net, ret_net, FakeTcpConfig()); - s.RunFor(TimeDelta::seconds(2)); + s.RunFor(TimeDelta::Seconds(2)); // Allow the ccongestion controller to recover. s.net()->StopCrossTraffic(tcp_traffic); - s.RunFor(TimeDelta::seconds(20)); + s.RunFor(TimeDelta::Seconds(20)); } return DataSize::bytes(video->receive() ->GetStats() @@ -585,7 +585,7 @@ TEST_F(GoogCcNetworkControllerTest, LossBasedEstimatorCapsRateAtModerateLoss) { NetworkSimulationConfig network; network.bandwidth = DataRate::kbps(2000); - network.delay = TimeDelta::ms(100); + network.delay = TimeDelta::Millis(100); // 3% loss rate is in the moderate loss rate region at 2000 kbps, limiting the // bitrate increase. network.loss_rate = 0.03; @@ -596,12 +596,12 @@ TEST_F(GoogCcNetworkControllerTest, LossBasedEstimatorCapsRateAtModerateLoss) { {s.CreateSimulationNode(network)}); s.CreateVideoStream(route->forward(), VideoStreamConfig()); // Allow the controller to stabilize at the lower bitrate. - s.RunFor(TimeDelta::seconds(1)); + s.RunFor(TimeDelta::Seconds(1)); // This increase in capacity would cause the target bitrate to increase to // over 4000 kbps without LossBasedControl. send_net->UpdateConfig( [](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(5000); }); - s.RunFor(TimeDelta::seconds(20)); + s.RunFor(TimeDelta::Seconds(20)); // Using LossBasedControl, the bitrate will not increase over 2500 kbps since // we have detected moderate loss. EXPECT_LT(client->target_rate().kbps(), 2500); @@ -615,7 +615,7 @@ TEST_F(GoogCcNetworkControllerTest, MaintainsLowRateInSafeResetTrial) { Scenario s("googcc_unit/safe_reset_low"); auto* send_net = s.CreateSimulationNode([&](NetworkSimulationConfig* c) { c->bandwidth = kLinkCapacity; - c->delay = TimeDelta::ms(10); + c->delay = TimeDelta::Millis(10); }); auto* client = s.CreateClient("send", [&](CallClientConfig* c) { c->transport.rates.start_rate = kStartRate; @@ -625,11 +625,11 @@ TEST_F(GoogCcNetworkControllerTest, MaintainsLowRateInSafeResetTrial) { {s.CreateSimulationNode(NetworkSimulationConfig())}); s.CreateVideoStream(route->forward(), VideoStreamConfig()); // Allow the controller to stabilize. - s.RunFor(TimeDelta::ms(500)); + s.RunFor(TimeDelta::Millis(500)); EXPECT_NEAR(client->send_bandwidth().kbps(), kLinkCapacity.kbps(), 50); s.ChangeRoute(route->forward(), {send_net}); // Allow new settings to propagate. - s.RunFor(TimeDelta::ms(100)); + s.RunFor(TimeDelta::Millis(100)); // Under the trial, the target should be unchanged for low rates. EXPECT_NEAR(client->send_bandwidth().kbps(), kLinkCapacity.kbps(), 50); } @@ -642,7 +642,7 @@ TEST_F(GoogCcNetworkControllerTest, CutsHighRateInSafeResetTrial) { Scenario s("googcc_unit/safe_reset_high_cut"); auto send_net = s.CreateSimulationNode([&](NetworkSimulationConfig* c) { c->bandwidth = kLinkCapacity; - c->delay = TimeDelta::ms(50); + c->delay = TimeDelta::Millis(50); }); auto* client = s.CreateClient("send", [&](CallClientConfig* c) { c->transport.rates.start_rate = kStartRate; @@ -652,11 +652,11 @@ TEST_F(GoogCcNetworkControllerTest, CutsHighRateInSafeResetTrial) { {s.CreateSimulationNode(NetworkSimulationConfig())}); s.CreateVideoStream(route->forward(), VideoStreamConfig()); // Allow the controller to stabilize. - s.RunFor(TimeDelta::ms(500)); + s.RunFor(TimeDelta::Millis(500)); EXPECT_NEAR(client->send_bandwidth().kbps(), kLinkCapacity.kbps(), 300); s.ChangeRoute(route->forward(), {send_net}); // Allow new settings to propagate. - s.RunFor(TimeDelta::ms(50)); + s.RunFor(TimeDelta::Millis(50)); // Under the trial, the target should be reset from high values. EXPECT_NEAR(client->send_bandwidth().kbps(), kStartRate.kbps(), 30); } @@ -672,11 +672,11 @@ TEST_F(GoogCcNetworkControllerTest, DetectsHighRateInSafeResetTrial) { Scenario s("googcc_unit/safe_reset_high_detect"); auto* initial_net = s.CreateSimulationNode([&](NetworkSimulationConfig* c) { c->bandwidth = kInitialLinkCapacity; - c->delay = TimeDelta::ms(50); + c->delay = TimeDelta::Millis(50); }); auto* new_net = s.CreateSimulationNode([&](NetworkSimulationConfig* c) { c->bandwidth = kNewLinkCapacity; - c->delay = TimeDelta::ms(50); + c->delay = TimeDelta::Millis(50); }); auto* client = s.CreateClient("send", [&](CallClientConfig* c) { c->transport.rates.start_rate = kStartRate; @@ -686,18 +686,18 @@ TEST_F(GoogCcNetworkControllerTest, DetectsHighRateInSafeResetTrial) { {s.CreateSimulationNode(NetworkSimulationConfig())}); s.CreateVideoStream(route->forward(), VideoStreamConfig()); // Allow the controller to stabilize. - s.RunFor(TimeDelta::ms(1000)); + s.RunFor(TimeDelta::Millis(1000)); EXPECT_NEAR(client->send_bandwidth().kbps(), kInitialLinkCapacity.kbps(), 50); s.ChangeRoute(route->forward(), {new_net}); // Allow new settings to propagate, but not probes to be received. - s.RunFor(TimeDelta::ms(50)); + s.RunFor(TimeDelta::Millis(50)); // Under the field trial, the target rate should be unchanged since it's lower // than the starting rate. EXPECT_NEAR(client->send_bandwidth().kbps(), kInitialLinkCapacity.kbps(), 50); // However, probing should have made us detect the higher rate. // NOTE: This test causes high loss rate, and the loss-based estimator reduces // the bitrate, making the test fail if we wait longer than one second here. - s.RunFor(TimeDelta::ms(1000)); + s.RunFor(TimeDelta::Millis(1000)); EXPECT_GT(client->send_bandwidth().kbps(), kNewLinkCapacity.kbps() - 300); } @@ -715,7 +715,7 @@ TEST_F(GoogCcNetworkControllerTest, Scenario s("googcc_unit/pacing_buffer_buildup"); auto* net = s.CreateSimulationNode([&](NetworkSimulationConfig* c) { c->bandwidth = kLinkCapacity; - c->delay = TimeDelta::ms(50); + c->delay = TimeDelta::Millis(50); }); auto* client = s.CreateClient("send", [&](CallClientConfig* c) { c->transport.rates.start_rate = kStartRate; @@ -725,7 +725,7 @@ TEST_F(GoogCcNetworkControllerTest, {s.CreateSimulationNode(NetworkSimulationConfig())}); s.CreateVideoStream(route->forward(), VideoStreamConfig()); // Allow some time for the buffer to build up. - s.RunFor(TimeDelta::seconds(5)); + s.RunFor(TimeDelta::Seconds(5)); // Without trial, pacer delay reaches ~250 ms. EXPECT_LT(client->GetStats().pacer_delay_ms, 150); @@ -737,7 +737,7 @@ TEST_F(GoogCcNetworkControllerTest, NoBandwidthTogglingInLossControlTrial) { auto* send_net = s.CreateSimulationNode([&](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(2000); c->loss_rate = 0.2; - c->delay = TimeDelta::ms(10); + c->delay = TimeDelta::Millis(10); }); auto* client = s.CreateClient("send", [&](CallClientConfig* c) { @@ -748,14 +748,14 @@ TEST_F(GoogCcNetworkControllerTest, NoBandwidthTogglingInLossControlTrial) { {s.CreateSimulationNode(NetworkSimulationConfig())}); s.CreateVideoStream(route->forward(), VideoStreamConfig()); // Allow the controller to initialize. - s.RunFor(TimeDelta::ms(250)); + s.RunFor(TimeDelta::Millis(250)); std::queue<DataRate> bandwidth_history; - const TimeDelta step = TimeDelta::ms(50); - for (TimeDelta time = TimeDelta::Zero(); time < TimeDelta::ms(2000); + const TimeDelta step = TimeDelta::Millis(50); + for (TimeDelta time = TimeDelta::Zero(); time < TimeDelta::Millis(2000); time += step) { s.RunFor(step); - const TimeDelta window = TimeDelta::ms(500); + const TimeDelta window = TimeDelta::Millis(500); if (bandwidth_history.size() >= window / step) bandwidth_history.pop(); bandwidth_history.push(client->send_bandwidth()); @@ -768,7 +768,7 @@ TEST_F(GoogCcNetworkControllerTest, NoRttBackoffCollapseWhenVideoStops) { Scenario s("googcc_unit/rttbackoff_video_stop"); auto* send_net = s.CreateSimulationNode([&](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(2000); - c->delay = TimeDelta::ms(100); + c->delay = TimeDelta::Millis(100); }); auto* client = s.CreateClient("send", [&](CallClientConfig* c) { @@ -779,9 +779,9 @@ TEST_F(GoogCcNetworkControllerTest, NoRttBackoffCollapseWhenVideoStops) { {s.CreateSimulationNode(NetworkSimulationConfig())}); auto* video = s.CreateVideoStream(route->forward(), VideoStreamConfig()); // Allow the controller to initialize, then stop video. - s.RunFor(TimeDelta::seconds(1)); + s.RunFor(TimeDelta::Seconds(1)); video->send()->Stop(); - s.RunFor(TimeDelta::seconds(4)); + s.RunFor(TimeDelta::Seconds(4)); EXPECT_GT(client->send_bandwidth().kbps(), 1000); } @@ -793,27 +793,27 @@ TEST_F(GoogCcNetworkControllerTest, NoCrashOnVeryLateFeedback) { {s.CreateSimulationNode(NetworkSimulationConfig())}, s.CreateClient("return", CallClientConfig()), {ret_net->node()}); auto* video = s.CreateVideoStream(route->forward(), VideoStreamConfig()); - s.RunFor(TimeDelta::seconds(5)); + s.RunFor(TimeDelta::Seconds(5)); // Delay feedback by several minutes. This will cause removal of the send time // history for the packets as long as kSendTimeHistoryWindow is configured for // a shorter time span. - ret_net->PauseTransmissionUntil(s.Now() + TimeDelta::seconds(300)); + ret_net->PauseTransmissionUntil(s.Now() + TimeDelta::Seconds(300)); // Stopping video stream while waiting to save test execution time. video->send()->Stop(); - s.RunFor(TimeDelta::seconds(299)); + s.RunFor(TimeDelta::Seconds(299)); // Starting to cause addition of new packet to history, which cause old // packets to be removed. video->send()->Start(); // Runs until the lost packets are received. We expect that this will run // without causing any runtime failures. - s.RunFor(TimeDelta::seconds(2)); + s.RunFor(TimeDelta::Seconds(2)); } TEST_F(GoogCcNetworkControllerTest, IsFairToTCP) { Scenario s("googcc_unit/tcp_fairness"); NetworkSimulationConfig net_conf; net_conf.bandwidth = DataRate::kbps(1000); - net_conf.delay = TimeDelta::ms(50); + net_conf.delay = TimeDelta::Millis(50); auto* client = s.CreateClient("send", [&](CallClientConfig* c) { c->transport.rates.start_rate = DataRate::kbps(1000); }); @@ -823,7 +823,7 @@ TEST_F(GoogCcNetworkControllerTest, IsFairToTCP) { client, send_net, s.CreateClient("return", CallClientConfig()), ret_net); s.CreateVideoStream(route->forward(), VideoStreamConfig()); s.net()->StartFakeTcpCrossTraffic(send_net, ret_net, FakeTcpConfig()); - s.RunFor(TimeDelta::seconds(10)); + s.RunFor(TimeDelta::Seconds(10)); // Currently only testing for the upper limit as we in practice back out // quite a lot in this scenario. If this behavior is fixed, we should add a diff --git a/modules/congestion_controller/goog_cc/loss_based_bandwidth_estimation.cc b/modules/congestion_controller/goog_cc/loss_based_bandwidth_estimation.cc index c39ae21ef0..af05a8ff63 100644 --- a/modules/congestion_controller/goog_cc/loss_based_bandwidth_estimation.cc +++ b/modules/congestion_controller/goog_cc/loss_based_bandwidth_estimation.cc @@ -77,19 +77,19 @@ LossBasedControlConfig::LossBasedControlConfig() : enabled(field_trial::IsEnabled(kBweLossBasedControl)), min_increase_factor("min_incr", 1.02), max_increase_factor("max_incr", 1.08), - increase_low_rtt("incr_low_rtt", TimeDelta::ms(200)), - increase_high_rtt("incr_high_rtt", TimeDelta::ms(800)), + increase_low_rtt("incr_low_rtt", TimeDelta::Millis(200)), + increase_high_rtt("incr_high_rtt", TimeDelta::Millis(800)), decrease_factor("decr", 0.99), - loss_window("loss_win", TimeDelta::ms(800)), - loss_max_window("loss_max_win", TimeDelta::ms(800)), - acknowledged_rate_max_window("ackrate_max_win", TimeDelta::ms(800)), + loss_window("loss_win", TimeDelta::Millis(800)), + loss_max_window("loss_max_win", TimeDelta::Millis(800)), + acknowledged_rate_max_window("ackrate_max_win", TimeDelta::Millis(800)), increase_offset("incr_offset", DataRate::bps(1000)), loss_bandwidth_balance_increase("balance_incr", DataRate::kbps(0.5)), loss_bandwidth_balance_decrease("balance_decr", DataRate::kbps(4)), loss_bandwidth_balance_exponent("exponent", 0.5), allow_resets("resets", false), - decrease_interval("decr_intvl", TimeDelta::ms(300)), - loss_report_timeout("timeout", TimeDelta::ms(6000)) { + decrease_interval("decr_intvl", TimeDelta::Millis(300)), + loss_report_timeout("timeout", TimeDelta::Millis(6000)) { std::string trial_string = field_trial::FindFullName(kBweLossBasedControl); ParseFieldTrial( {&min_increase_factor, &max_increase_factor, &increase_low_rtt, @@ -130,7 +130,7 @@ void LossBasedBandwidthEstimation::UpdateLossStatistics( last_loss_ratio_ = static_cast<double>(loss_count) / packet_results.size(); const TimeDelta time_passed = last_loss_packet_report_.IsFinite() ? at_time - last_loss_packet_report_ - : TimeDelta::seconds(1); + : TimeDelta::Seconds(1); last_loss_packet_report_ = at_time; has_decreased_since_last_loss_report_ = false; @@ -151,7 +151,7 @@ void LossBasedBandwidthEstimation::UpdateAcknowledgedBitrate( const TimeDelta time_passed = acknowledged_bitrate_last_update_.IsFinite() ? at_time - acknowledged_bitrate_last_update_ - : TimeDelta::seconds(1); + : TimeDelta::Seconds(1); acknowledged_bitrate_last_update_ = at_time; if (acknowledged_bitrate > acknowledged_bitrate_max_) { acknowledged_bitrate_max_ = acknowledged_bitrate; diff --git a/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc b/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc index b4a33eb2fd..517019527c 100644 --- a/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc +++ b/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc @@ -46,11 +46,11 @@ constexpr float kTargetUtilizationFraction = 0.95f; // The maximum time period over which the cluster history is retained. // This is also the maximum time period beyond which a probing burst is not // expected to last. -constexpr TimeDelta kMaxClusterHistory = TimeDelta::Seconds<1>(); +constexpr TimeDelta kMaxClusterHistory = TimeDelta::Seconds(1); // The maximum time interval between first and the last probe on a cluster // on the sender side as well as the receive side. -constexpr TimeDelta kMaxProbeInterval = TimeDelta::Seconds<1>(); +constexpr TimeDelta kMaxProbeInterval = TimeDelta::Seconds(1); } // namespace diff --git a/modules/congestion_controller/goog_cc/probe_bitrate_estimator_unittest.cc b/modules/congestion_controller/goog_cc/probe_bitrate_estimator_unittest.cc index b886add2d0..0da194aa20 100644 --- a/modules/congestion_controller/goog_cc/probe_bitrate_estimator_unittest.cc +++ b/modules/congestion_controller/goog_cc/probe_bitrate_estimator_unittest.cc @@ -35,14 +35,14 @@ class TestProbeBitrateEstimator : public ::testing::Test { int64_t arrival_time_ms, int min_probes = kDefaultMinProbes, int min_bytes = kDefaultMinBytes) { - const Timestamp kReferenceTime = Timestamp::seconds(1000); + const Timestamp kReferenceTime = Timestamp::Seconds(1000); PacketResult feedback; feedback.sent_packet.send_time = - kReferenceTime + TimeDelta::ms(send_time_ms); + kReferenceTime + TimeDelta::Millis(send_time_ms); feedback.sent_packet.size = DataSize::bytes(size_bytes); feedback.sent_packet.pacing_info = PacedPacketInfo(probe_cluster_id, min_probes, min_bytes); - feedback.receive_time = kReferenceTime + TimeDelta::ms(arrival_time_ms); + feedback.receive_time = kReferenceTime + TimeDelta::Millis(arrival_time_ms); measured_data_rate_ = probe_bitrate_estimator_.HandleProbeAndEstimateBitrate(feedback); } diff --git a/modules/congestion_controller/goog_cc/probe_controller.cc b/modules/congestion_controller/goog_cc/probe_controller.cc index 02b5833705..321eff2b80 100644 --- a/modules/congestion_controller/goog_cc/probe_controller.cc +++ b/modules/congestion_controller/goog_cc/probe_controller.cc @@ -95,7 +95,7 @@ ProbeControllerConfig::ProbeControllerConfig( second_exponential_probe_scale("p2", 6.0), further_exponential_probe_scale("step_size", 2), further_probe_threshold("further_probe_threshold", 0.7), - alr_probing_interval("alr_interval", TimeDelta::seconds(5)), + alr_probing_interval("alr_interval", TimeDelta::Seconds(5)), alr_probe_scale("alr_scale", 2), first_allocation_probe_scale("alloc_p1", 1), second_allocation_probe_scale("alloc_p2", 2), @@ -417,9 +417,9 @@ std::vector<ProbeClusterConfig> ProbeController::InitiateProbing( } ProbeClusterConfig config; - config.at_time = Timestamp::ms(now_ms); + config.at_time = Timestamp::Millis(now_ms); config.target_data_rate = DataRate::bps(rtc::dchecked_cast<int>(bitrate)); - config.target_duration = TimeDelta::ms(kMinProbeDurationMs); + config.target_duration = TimeDelta::Millis(kMinProbeDurationMs); config.target_probe_count = kMinProbePacketsSent; config.id = next_probe_cluster_id_; next_probe_cluster_id_++; diff --git a/modules/congestion_controller/goog_cc/probe_controller_unittest.cc b/modules/congestion_controller/goog_cc/probe_controller_unittest.cc index f82e7d46ca..e27bf71489 100644 --- a/modules/congestion_controller/goog_cc/probe_controller_unittest.cc +++ b/modules/congestion_controller/goog_cc/probe_controller_unittest.cc @@ -55,7 +55,7 @@ class ProbeControllerTest : public ::testing::Test { std::vector<ProbeClusterConfig> SetNetworkAvailable(bool available) { NetworkAvailability msg; - msg.at_time = Timestamp::ms(NowMs()); + msg.at_time = Timestamp::Millis(NowMs()); msg.network_available = available; return probe_controller_->OnNetworkAvailability(msg); } diff --git a/modules/congestion_controller/goog_cc/robust_throughput_estimator.cc b/modules/congestion_controller/goog_cc/robust_throughput_estimator.cc index 8c77e8ff31..a94c70f625 100644 --- a/modules/congestion_controller/goog_cc/robust_throughput_estimator.cc +++ b/modules/congestion_controller/goog_cc/robust_throughput_estimator.cc @@ -56,8 +56,8 @@ absl::optional<DataRate> RobustThroughputEstimator::bitrate() const { if (window_.size() < settings_.initial_packets) return absl::nullopt; - TimeDelta largest_recv_gap(TimeDelta::ms(0)); - TimeDelta second_largest_recv_gap(TimeDelta::ms(0)); + TimeDelta largest_recv_gap(TimeDelta::Millis(0)); + TimeDelta second_largest_recv_gap(TimeDelta::Millis(0)); for (size_t i = 1; i < window_.size(); i++) { // Find receive time gaps TimeDelta gap = window_[i].receive_time - window_[i - 1].receive_time; @@ -125,8 +125,8 @@ absl::optional<DataRate> RobustThroughputEstimator::bitrate() const { recv_duration += recv_duration / (window_.size() - 2); } - send_duration = std::max(send_duration, TimeDelta::ms(1)); - recv_duration = std::max(recv_duration, TimeDelta::ms(1)); + send_duration = std::max(send_duration, TimeDelta::Millis(1)); + recv_duration = std::max(recv_duration, TimeDelta::Millis(1)); return std::min(send_size / send_duration, recv_size / recv_duration); } diff --git a/modules/congestion_controller/goog_cc/robust_throughput_estimator_unittest.cc b/modules/congestion_controller/goog_cc/robust_throughput_estimator_unittest.cc index 83773422c1..45a3f25c98 100644 --- a/modules/congestion_controller/goog_cc/robust_throughput_estimator_unittest.cc +++ b/modules/congestion_controller/goog_cc/robust_throughput_estimator_unittest.cc @@ -46,10 +46,10 @@ TEST(RobustThroughputEstimatorTest, SteadyRate) { RobustThroughputEstimatorSettings settings(&field_trial_config); RobustThroughputEstimator throughput_estimator(settings); DataSize packet_size(DataSize::bytes(1000)); - Timestamp send_clock(Timestamp::ms(100000)); - Timestamp recv_clock(Timestamp::ms(10000)); - TimeDelta send_increment(TimeDelta::ms(10)); - TimeDelta recv_increment(TimeDelta::ms(10)); + Timestamp send_clock(Timestamp::Millis(100000)); + Timestamp recv_clock(Timestamp::Millis(10000)); + TimeDelta send_increment(TimeDelta::Millis(10)); + TimeDelta recv_increment(TimeDelta::Millis(10)); uint16_t sequence_number = 100; std::vector<PacketResult> packet_feedback = CreateFeedbackVector(9, packet_size, send_increment, recv_increment, @@ -76,10 +76,10 @@ TEST(RobustThroughputEstimatorTest, DelaySpike) { RobustThroughputEstimatorSettings settings(&field_trial_config); RobustThroughputEstimator throughput_estimator(settings); DataSize packet_size(DataSize::bytes(1000)); - Timestamp send_clock(Timestamp::ms(100000)); - Timestamp recv_clock(Timestamp::ms(10000)); - TimeDelta send_increment(TimeDelta::ms(10)); - TimeDelta recv_increment(TimeDelta::ms(10)); + Timestamp send_clock(Timestamp::Millis(100000)); + Timestamp recv_clock(Timestamp::Millis(10000)); + TimeDelta send_increment(TimeDelta::Millis(10)); + TimeDelta recv_increment(TimeDelta::Millis(10)); uint16_t sequence_number = 100; std::vector<PacketResult> packet_feedback = CreateFeedbackVector(20, packet_size, send_increment, recv_increment, @@ -91,10 +91,10 @@ TEST(RobustThroughputEstimatorTest, DelaySpike) { 0.05 * 100 * 1000.0); // Allow 5% error // Delay spike - recv_clock += TimeDelta::ms(40); + recv_clock += TimeDelta::Millis(40); // Faster delivery after the gap - recv_increment = TimeDelta::ms(2); + recv_increment = TimeDelta::Millis(2); packet_feedback = CreateFeedbackVector(5, packet_size, send_increment, recv_increment, &send_clock, &recv_clock, &sequence_number); @@ -105,7 +105,7 @@ TEST(RobustThroughputEstimatorTest, DelaySpike) { 0.05 * 100 * 1000.0); // Allow 5% error // Delivery at normal rate. This will be capped by the send rate. - recv_increment = TimeDelta::ms(10); + recv_increment = TimeDelta::Millis(10); packet_feedback = CreateFeedbackVector(5, packet_size, send_increment, recv_increment, &send_clock, &recv_clock, &sequence_number); @@ -125,10 +125,10 @@ TEST(RobustThroughputEstimatorTest, CappedByReceiveRate) { RobustThroughputEstimatorSettings settings(&field_trial_config); RobustThroughputEstimator throughput_estimator(settings); DataSize packet_size(DataSize::bytes(1000)); - Timestamp send_clock(Timestamp::ms(100000)); - Timestamp recv_clock(Timestamp::ms(10000)); - TimeDelta send_increment(TimeDelta::ms(10)); - TimeDelta recv_increment(TimeDelta::ms(40)); + Timestamp send_clock(Timestamp::Millis(100000)); + Timestamp recv_clock(Timestamp::Millis(10000)); + TimeDelta send_increment(TimeDelta::Millis(10)); + TimeDelta recv_increment(TimeDelta::Millis(40)); uint16_t sequence_number = 100; std::vector<PacketResult> packet_feedback = CreateFeedbackVector(20, packet_size, send_increment, recv_increment, @@ -149,10 +149,10 @@ TEST(RobustThroughputEstimatorTest, CappedBySendRate) { RobustThroughputEstimatorSettings settings(&field_trial_config); RobustThroughputEstimator throughput_estimator(settings); DataSize packet_size(DataSize::bytes(1000)); - Timestamp send_clock(Timestamp::ms(100000)); - Timestamp recv_clock(Timestamp::ms(10000)); - TimeDelta send_increment(TimeDelta::ms(20)); - TimeDelta recv_increment(TimeDelta::ms(10)); + Timestamp send_clock(Timestamp::Millis(100000)); + Timestamp recv_clock(Timestamp::Millis(10000)); + TimeDelta send_increment(TimeDelta::Millis(20)); + TimeDelta recv_increment(TimeDelta::Millis(10)); uint16_t sequence_number = 100; std::vector<PacketResult> packet_feedback = CreateFeedbackVector(20, packet_size, send_increment, recv_increment, diff --git a/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation.cc b/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation.cc index c16c83eabb..86e6208c92 100644 --- a/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation.cc +++ b/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation.cc @@ -27,16 +27,16 @@ namespace webrtc { namespace { -constexpr TimeDelta kBweIncreaseInterval = TimeDelta::Millis<1000>(); -constexpr TimeDelta kBweDecreaseInterval = TimeDelta::Millis<300>(); -constexpr TimeDelta kStartPhase = TimeDelta::Millis<2000>(); -constexpr TimeDelta kBweConverganceTime = TimeDelta::Millis<20000>(); +constexpr TimeDelta kBweIncreaseInterval = TimeDelta::Millis(1000); +constexpr TimeDelta kBweDecreaseInterval = TimeDelta::Millis(300); +constexpr TimeDelta kStartPhase = TimeDelta::Millis(2000); +constexpr TimeDelta kBweConverganceTime = TimeDelta::Millis(20000); constexpr int kLimitNumPackets = 20; constexpr DataRate kDefaultMaxBitrate = DataRate::BitsPerSec<1000000000>(); -constexpr TimeDelta kLowBitrateLogPeriod = TimeDelta::Millis<10000>(); -constexpr TimeDelta kRtcEventLogPeriod = TimeDelta::Millis<5000>(); +constexpr TimeDelta kLowBitrateLogPeriod = TimeDelta::Millis(10000); +constexpr TimeDelta kRtcEventLogPeriod = TimeDelta::Millis(5000); // Expecting that RTCP feedback is sent uniformly within [0.5, 1.5]s intervals. -constexpr TimeDelta kMaxRtcpFeedbackInterval = TimeDelta::Millis<5000>(); +constexpr TimeDelta kMaxRtcpFeedbackInterval = TimeDelta::Millis(5000); constexpr float kDefaultLowLossThreshold = 0.02f; constexpr float kDefaultHighLossThreshold = 0.1f; @@ -103,7 +103,7 @@ bool ReadBweLossExperimentParameters(float* low_loss_threshold, } // namespace LinkCapacityTracker::LinkCapacityTracker() - : tracking_rate("rate", TimeDelta::seconds(10)) { + : tracking_rate("rate", TimeDelta::Seconds(10)) { ParseFieldTrial({&tracking_rate}, field_trial::FindFullName("WebRTC-Bwe-LinkCapacity")); } @@ -153,9 +153,9 @@ DataRate LinkCapacityTracker::estimate() const { } RttBasedBackoff::RttBasedBackoff() - : rtt_limit_("limit", TimeDelta::seconds(3)), + : rtt_limit_("limit", TimeDelta::Seconds(3)), drop_fraction_("fraction", 0.8), - drop_interval_("interval", TimeDelta::seconds(1)), + drop_interval_("interval", TimeDelta::Seconds(1)), bandwidth_floor_("floor", DataRate::kbps(5)), // By initializing this to plus infinity, we make sure that we never // trigger rtt backoff unless packet feedback is enabled. @@ -549,7 +549,7 @@ void SendSideBandwidthEstimation::UpdateMinHistory(Timestamp at_time) { // Since history precision is in ms, add one so it is able to increase // bitrate if it is off by as little as 0.5ms. while (!min_bitrate_history_.empty() && - at_time - min_bitrate_history_.front().first + TimeDelta::ms(1) > + at_time - min_bitrate_history_.front().first + TimeDelta::Millis(1) > kBweIncreaseInterval) { min_bitrate_history_.pop_front(); } diff --git a/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation_unittest.cc b/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation_unittest.cc index 710c71f9cd..3b75ed12e5 100644 --- a/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation_unittest.cc +++ b/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation_unittest.cc @@ -39,35 +39,36 @@ void TestProbing(bool use_delay_based) { SendSideBandwidthEstimation bwe(&event_log); int64_t now_ms = 0; bwe.SetMinMaxBitrate(DataRate::bps(100000), DataRate::bps(1500000)); - bwe.SetSendBitrate(DataRate::bps(200000), Timestamp::ms(now_ms)); + bwe.SetSendBitrate(DataRate::bps(200000), Timestamp::Millis(now_ms)); const int kRembBps = 1000000; const int kSecondRembBps = kRembBps + 500000; bwe.UpdatePacketsLost(/*packets_lost=*/0, /*number_of_packets=*/1, - Timestamp::ms(now_ms)); - bwe.UpdateRtt(TimeDelta::ms(50), Timestamp::ms(now_ms)); + Timestamp::Millis(now_ms)); + bwe.UpdateRtt(TimeDelta::Millis(50), Timestamp::Millis(now_ms)); // Initial REMB applies immediately. if (use_delay_based) { - bwe.UpdateDelayBasedEstimate(Timestamp::ms(now_ms), + bwe.UpdateDelayBasedEstimate(Timestamp::Millis(now_ms), DataRate::bps(kRembBps)); } else { - bwe.UpdateReceiverEstimate(Timestamp::ms(now_ms), DataRate::bps(kRembBps)); + bwe.UpdateReceiverEstimate(Timestamp::Millis(now_ms), + DataRate::bps(kRembBps)); } - bwe.UpdateEstimate(Timestamp::ms(now_ms)); + bwe.UpdateEstimate(Timestamp::Millis(now_ms)); EXPECT_EQ(kRembBps, bwe.target_rate().bps()); // Second REMB doesn't apply immediately. now_ms += 2001; if (use_delay_based) { - bwe.UpdateDelayBasedEstimate(Timestamp::ms(now_ms), + bwe.UpdateDelayBasedEstimate(Timestamp::Millis(now_ms), DataRate::bps(kSecondRembBps)); } else { - bwe.UpdateReceiverEstimate(Timestamp::ms(now_ms), + bwe.UpdateReceiverEstimate(Timestamp::Millis(now_ms), DataRate::bps(kSecondRembBps)); } - bwe.UpdateEstimate(Timestamp::ms(now_ms)); + bwe.UpdateEstimate(Timestamp::Millis(now_ms)); EXPECT_EQ(kRembBps, bwe.target_rate().bps()); } @@ -91,7 +92,8 @@ TEST(SendSideBweTest, DoesntReapplyBitrateDecreaseWithoutFollowingRemb) { static const int kInitialBitrateBps = 1000000; int64_t now_ms = 1000; bwe.SetMinMaxBitrate(DataRate::bps(kMinBitrateBps), DataRate::bps(1500000)); - bwe.SetSendBitrate(DataRate::bps(kInitialBitrateBps), Timestamp::ms(now_ms)); + bwe.SetSendBitrate(DataRate::bps(kInitialBitrateBps), + Timestamp::Millis(now_ms)); static const uint8_t kFractionLoss = 128; static const int64_t kRttMs = 50; @@ -103,12 +105,12 @@ TEST(SendSideBweTest, DoesntReapplyBitrateDecreaseWithoutFollowingRemb) { // Signal heavy loss to go down in bitrate. bwe.UpdatePacketsLost(/*packets_lost=*/50, /*number_of_packets=*/100, - Timestamp::ms(now_ms)); - bwe.UpdateRtt(TimeDelta::ms(kRttMs), Timestamp::ms(now_ms)); + Timestamp::Millis(now_ms)); + bwe.UpdateRtt(TimeDelta::Millis(kRttMs), Timestamp::Millis(now_ms)); // Trigger an update 2 seconds later to not be rate limited. now_ms += 1000; - bwe.UpdateEstimate(Timestamp::ms(now_ms)); + bwe.UpdateEstimate(Timestamp::Millis(now_ms)); EXPECT_LT(bwe.target_rate().bps(), kInitialBitrateBps); // Verify that the obtained bitrate isn't hitting the min bitrate, or this // test doesn't make sense. If this ever happens, update the thresholds or @@ -124,7 +126,7 @@ TEST(SendSideBweTest, DoesntReapplyBitrateDecreaseWithoutFollowingRemb) { // Trigger an update 2 seconds later to not be rate limited (but it still // shouldn't update). now_ms += 1000; - bwe.UpdateEstimate(Timestamp::ms(now_ms)); + bwe.UpdateEstimate(Timestamp::Millis(now_ms)); EXPECT_EQ(last_bitrate_bps, bwe.target_rate().bps()); // The old loss rate should still be applied though. @@ -145,15 +147,17 @@ TEST(SendSideBweTest, SettingSendBitrateOverridesDelayBasedEstimate) { bwe.SetMinMaxBitrate(DataRate::bps(kMinBitrateBps), DataRate::bps(kMaxBitrateBps)); - bwe.SetSendBitrate(DataRate::bps(kInitialBitrateBps), Timestamp::ms(now_ms)); + bwe.SetSendBitrate(DataRate::bps(kInitialBitrateBps), + Timestamp::Millis(now_ms)); - bwe.UpdateDelayBasedEstimate(Timestamp::ms(now_ms), + bwe.UpdateDelayBasedEstimate(Timestamp::Millis(now_ms), DataRate::bps(kDelayBasedBitrateBps)); - bwe.UpdateEstimate(Timestamp::ms(now_ms)); + bwe.UpdateEstimate(Timestamp::Millis(now_ms)); EXPECT_GE(bwe.target_rate().bps(), kInitialBitrateBps); EXPECT_LE(bwe.target_rate().bps(), kDelayBasedBitrateBps); - bwe.SetSendBitrate(DataRate::bps(kForcedHighBitrate), Timestamp::ms(now_ms)); + bwe.SetSendBitrate(DataRate::bps(kForcedHighBitrate), + Timestamp::Millis(now_ms)); EXPECT_EQ(bwe.target_rate().bps(), kForcedHighBitrate); } diff --git a/modules/congestion_controller/pcc/bitrate_controller_unittest.cc b/modules/congestion_controller/pcc/bitrate_controller_unittest.cc index 7188ea33f4..0d3c441b1e 100644 --- a/modules/congestion_controller/pcc/bitrate_controller_unittest.cc +++ b/modules/congestion_controller/pcc/bitrate_controller_unittest.cc @@ -34,10 +34,10 @@ constexpr double kDelayGradientNegativeBound = 10; const DataRate kTargetSendingRate = DataRate::kbps(300); const double kEpsilon = 0.05; -const Timestamp kStartTime = Timestamp::us(0); -const TimeDelta kPacketsDelta = TimeDelta::ms(1); -const TimeDelta kIntervalDuration = TimeDelta::ms(1000); -const TimeDelta kDefaultRtt = TimeDelta::ms(1000); +const Timestamp kStartTime = Timestamp::Micros(0); +const TimeDelta kPacketsDelta = TimeDelta::Millis(1); +const TimeDelta kIntervalDuration = TimeDelta::Millis(1000); +const TimeDelta kDefaultRtt = TimeDelta::Millis(1000); const DataSize kDefaultDataSize = DataSize::bytes(100); std::vector<PacketResult> CreatePacketResults( diff --git a/modules/congestion_controller/pcc/monitor_interval_unittest.cc b/modules/congestion_controller/pcc/monitor_interval_unittest.cc index 65bd8611d6..92cebd1d9d 100644 --- a/modules/congestion_controller/pcc/monitor_interval_unittest.cc +++ b/modules/congestion_controller/pcc/monitor_interval_unittest.cc @@ -19,10 +19,10 @@ namespace pcc { namespace test { namespace { const DataRate kTargetSendingRate = DataRate::kbps(300); -const Timestamp kStartTime = Timestamp::us(0); -const TimeDelta kPacketsDelta = TimeDelta::ms(1); -const TimeDelta kIntervalDuration = TimeDelta::ms(100); -const TimeDelta kDefaultDelay = TimeDelta::ms(100); +const Timestamp kStartTime = Timestamp::Micros(0); +const TimeDelta kPacketsDelta = TimeDelta::Millis(1); +const TimeDelta kIntervalDuration = TimeDelta::Millis(100); +const TimeDelta kDefaultDelay = TimeDelta::Millis(100); const DataSize kDefaultPacketSize = DataSize::bytes(100); constexpr double kDelayGradientThreshold = 0.01; diff --git a/modules/congestion_controller/pcc/pcc_network_controller.cc b/modules/congestion_controller/pcc/pcc_network_controller.cc index 9f074afa62..b38dce0c05 100644 --- a/modules/congestion_controller/pcc/pcc_network_controller.cc +++ b/modules/congestion_controller/pcc/pcc_network_controller.cc @@ -29,8 +29,8 @@ constexpr double kSlowStartModeIncrease = 1.5; constexpr double kAlphaForPacketInterval = 0.9; constexpr int64_t kMinPacketsNumberPerInterval = 20; -const TimeDelta kMinDurationOfMonitorInterval = TimeDelta::Millis<50>(); -const TimeDelta kStartupDuration = TimeDelta::Millis<500>(); +const TimeDelta kMinDurationOfMonitorInterval = TimeDelta::Millis(50); +const TimeDelta kStartupDuration = TimeDelta::Millis(500); constexpr double kMinRateChangeBps = 4000; constexpr DataRate kMinRateHaveMultiplicativeRateChange = DataRate::BitsPerSec<static_cast<int64_t>(kMinRateChangeBps / @@ -59,8 +59,9 @@ PccNetworkController::PccNetworkController(NetworkControllerConfig config) mode_(Mode::kStartup), default_bandwidth_(DataRate::kbps(kInitialBandwidthKbps)), bandwidth_estimate_(default_bandwidth_), - rtt_tracker_(TimeDelta::ms(kInitialRttMs), kAlphaForRtt), - monitor_interval_timeout_(TimeDelta::ms(kInitialRttMs) * kTimeoutRatio), + rtt_tracker_(TimeDelta::Millis(kInitialRttMs), kAlphaForRtt), + monitor_interval_timeout_(TimeDelta::Millis(kInitialRttMs) * + kTimeoutRatio), monitor_interval_length_strategy_(MonitorIntervalLengthStrategy::kFixed), monitor_interval_duration_ratio_(kMonitorIntervalDurationRatio), sampling_step_(kDefaultSamplingStep), @@ -115,7 +116,7 @@ NetworkControlUpdate PccNetworkController::CreateRateUpdate( // Set up pacing/padding target rate. PacerConfig pacer_config; pacer_config.at_time = at_time; - pacer_config.time_window = TimeDelta::ms(1); + pacer_config.time_window = TimeDelta::Millis(1); pacer_config.data_window = sending_rate * pacer_config.time_window; pacer_config.pad_window = sending_rate * pacer_config.time_window; diff --git a/modules/congestion_controller/pcc/pcc_network_controller_unittest.cc b/modules/congestion_controller/pcc/pcc_network_controller_unittest.cc index 9910a03322..ad01cadd13 100644 --- a/modules/congestion_controller/pcc/pcc_network_controller_unittest.cc +++ b/modules/congestion_controller/pcc/pcc_network_controller_unittest.cc @@ -29,7 +29,7 @@ namespace test { namespace { const DataRate kInitialBitrate = DataRate::kbps(60); -const Timestamp kDefaultStartTime = Timestamp::ms(10000000); +const Timestamp kDefaultStartTime = Timestamp::Millis(10000000); constexpr double kDataRateMargin = 0.20; constexpr double kMinDataRateFactor = 1 - kDataRateMargin; @@ -82,10 +82,10 @@ TEST(PccNetworkControllerTest, UpdatesTargetSendRate) { config.transport.rates.start_rate = DataRate::kbps(300); auto send_net = s.CreateMutableSimulationNode([](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(500); - c->delay = TimeDelta::ms(100); + c->delay = TimeDelta::Millis(100); }); auto ret_net = s.CreateMutableSimulationNode( - [](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(100); }); + [](NetworkSimulationConfig* c) { c->delay = TimeDelta::Millis(100); }); auto* client = s.CreateClient("send", config); auto* route = s.CreateRoutes(client, {send_net->node()}, @@ -94,21 +94,21 @@ TEST(PccNetworkControllerTest, UpdatesTargetSendRate) { VideoStreamConfig video; video.stream.use_rtx = false; s.CreateVideoStream(route->forward(), video); - s.RunFor(TimeDelta::seconds(30)); + s.RunFor(TimeDelta::Seconds(30)); EXPECT_NEAR(client->target_rate().kbps(), 450, 100); send_net->UpdateConfig([](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(800); - c->delay = TimeDelta::ms(100); + c->delay = TimeDelta::Millis(100); }); - s.RunFor(TimeDelta::seconds(20)); + s.RunFor(TimeDelta::Seconds(20)); EXPECT_NEAR(client->target_rate().kbps(), 750, 150); send_net->UpdateConfig([](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(200); - c->delay = TimeDelta::ms(200); + c->delay = TimeDelta::Millis(200); }); ret_net->UpdateConfig( - [](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(200); }); - s.RunFor(TimeDelta::seconds(35)); + [](NetworkSimulationConfig* c) { c->delay = TimeDelta::Millis(200); }); + s.RunFor(TimeDelta::Seconds(35)); EXPECT_NEAR(client->target_rate().kbps(), 170, 50); } diff --git a/modules/congestion_controller/pcc/rtt_tracker_unittest.cc b/modules/congestion_controller/pcc/rtt_tracker_unittest.cc index dd667b81b6..7d90e86822 100644 --- a/modules/congestion_controller/pcc/rtt_tracker_unittest.cc +++ b/modules/congestion_controller/pcc/rtt_tracker_unittest.cc @@ -16,9 +16,9 @@ namespace webrtc { namespace pcc { namespace test { namespace { -const TimeDelta kInitialRtt = TimeDelta::us(10); +const TimeDelta kInitialRtt = TimeDelta::Micros(10); constexpr double kAlpha = 0.9; -const Timestamp kStartTime = Timestamp::seconds(0); +const Timestamp kStartTime = Timestamp::Seconds(0); PacketResult GetPacketWithRtt(TimeDelta rtt) { SentPacket packet; @@ -53,7 +53,7 @@ TEST(PccRttTrackerTest, DoNothingWhenPacketIsLost) { TEST(PccRttTrackerTest, ChangeInRtt) { RttTracker tracker{kInitialRtt, kAlpha}; - const TimeDelta kNewRtt = TimeDelta::us(100); + const TimeDelta kNewRtt = TimeDelta::Micros(100); tracker.OnPacketsFeedback({GetPacketWithRtt(kNewRtt)}, kStartTime + kNewRtt); EXPECT_GT(tracker.GetRtt(), kInitialRtt); EXPECT_LE(tracker.GetRtt(), kNewRtt); @@ -61,7 +61,7 @@ TEST(PccRttTrackerTest, ChangeInRtt) { tracker.OnPacketsFeedback({GetPacketWithRtt(kNewRtt)}, kStartTime + kNewRtt); } - const TimeDelta absolute_error = TimeDelta::us(1); + const TimeDelta absolute_error = TimeDelta::Micros(1); EXPECT_NEAR(tracker.GetRtt().us(), kNewRtt.us(), absolute_error.us()); EXPECT_LE(tracker.GetRtt(), kNewRtt); } diff --git a/modules/congestion_controller/pcc/utility_function_unittest.cc b/modules/congestion_controller/pcc/utility_function_unittest.cc index 0459fb847b..6f2bc8165c 100644 --- a/modules/congestion_controller/pcc/utility_function_unittest.cc +++ b/modules/congestion_controller/pcc/utility_function_unittest.cc @@ -32,13 +32,13 @@ constexpr double kThroughputPower = 0.9; constexpr double kThroughputCoefficient = 1; constexpr double kDelayGradientNegativeBound = 10; -const Timestamp kStartTime = Timestamp::us(0); -const TimeDelta kPacketsDelta = TimeDelta::ms(1); -const TimeDelta kIntervalDuration = TimeDelta::ms(100); +const Timestamp kStartTime = Timestamp::Micros(0); +const TimeDelta kPacketsDelta = TimeDelta::Millis(1); +const TimeDelta kIntervalDuration = TimeDelta::Millis(100); const DataRate kSendingBitrate = DataRate::bps(1000); const DataSize kDefaultDataSize = DataSize::bytes(100); -const TimeDelta kDefaultDelay = TimeDelta::ms(100); +const TimeDelta kDefaultDelay = TimeDelta::Millis(100); std::vector<PacketResult> CreatePacketResults( const std::vector<Timestamp>& packets_send_times, diff --git a/modules/congestion_controller/receive_side_congestion_controller_unittest.cc b/modules/congestion_controller/receive_side_congestion_controller_unittest.cc index 5473497633..5c344ad8cb 100644 --- a/modules/congestion_controller/receive_side_congestion_controller_unittest.cc +++ b/modules/congestion_controller/receive_side_congestion_controller_unittest.cc @@ -77,7 +77,7 @@ TEST(ReceiveSideCongestionControllerTest, ConvergesToCapacity) { Scenario s("recieve_cc_unit/converge"); NetworkSimulationConfig net_conf; net_conf.bandwidth = DataRate::kbps(1000); - net_conf.delay = TimeDelta::ms(50); + net_conf.delay = TimeDelta::Millis(50); auto* client = s.CreateClient("send", [&](CallClientConfig* c) { c->transport.rates.start_rate = DataRate::kbps(300); }); @@ -88,7 +88,7 @@ TEST(ReceiveSideCongestionControllerTest, ConvergesToCapacity) { VideoStreamConfig video; video.stream.packet_feedback = false; s.CreateVideoStream(route->forward(), video); - s.RunFor(TimeDelta::seconds(30)); + s.RunFor(TimeDelta::Seconds(30)); EXPECT_NEAR(client->send_bandwidth().kbps(), 900, 150); } @@ -96,7 +96,7 @@ TEST(ReceiveSideCongestionControllerTest, IsFairToTCP) { Scenario s("recieve_cc_unit/tcp_fairness"); NetworkSimulationConfig net_conf; net_conf.bandwidth = DataRate::kbps(1000); - net_conf.delay = TimeDelta::ms(50); + net_conf.delay = TimeDelta::Millis(50); auto* client = s.CreateClient("send", [&](CallClientConfig* c) { c->transport.rates.start_rate = DataRate::kbps(1000); }); @@ -108,7 +108,7 @@ TEST(ReceiveSideCongestionControllerTest, IsFairToTCP) { video.stream.packet_feedback = false; s.CreateVideoStream(route->forward(), video); s.net()->StartFakeTcpCrossTraffic(send_net, ret_net, FakeTcpConfig()); - s.RunFor(TimeDelta::seconds(30)); + s.RunFor(TimeDelta::Seconds(30)); // For some reason we get outcompeted by TCP here, this should probably be // fixed and a lower bound should be added to the test. EXPECT_LT(client->send_bandwidth().kbps(), 750); diff --git a/modules/congestion_controller/rtp/transport_feedback_adapter.cc b/modules/congestion_controller/rtp/transport_feedback_adapter.cc index b1de93559c..301c157544 100644 --- a/modules/congestion_controller/rtp/transport_feedback_adapter.cc +++ b/modules/congestion_controller/rtp/transport_feedback_adapter.cc @@ -26,7 +26,7 @@ namespace webrtc { -constexpr TimeDelta kSendTimeHistoryWindow = TimeDelta::Seconds<60>(); +constexpr TimeDelta kSendTimeHistoryWindow = TimeDelta::Seconds(60); void InFlightBytesTracker::AddInFlightPacketBytes( const PacketFeedback& packet) { @@ -91,7 +91,7 @@ void TransportFeedbackAdapter::AddPacket(const RtpPacketSendInfo& packet_info, } absl::optional<SentPacket> TransportFeedbackAdapter::ProcessSentPacket( const rtc::SentPacket& sent_packet) { - auto send_time = Timestamp::ms(sent_packet.send_time_ms); + auto send_time = Timestamp::Millis(sent_packet.send_time_ms); // TODO(srte): Only use one way to indicate that packet feedback is used. if (sent_packet.info.included_in_feedback || sent_packet.packet_id != -1) { int64_t unwrapped_seq_num = @@ -179,7 +179,7 @@ TransportFeedbackAdapter::ProcessTransportFeedbackInner( } else { // TODO(srte): We shouldn't need to do rounding here. const TimeDelta delta = feedback.GetBaseDelta(last_timestamp_) - .RoundDownTo(TimeDelta::Millis<1>()); + .RoundDownTo(TimeDelta::Millis(1)); // Protect against assigning current_offset_ negative value. if (delta < Timestamp::Zero() - current_offset_) { RTC_LOG(LS_WARNING) << "Unexpected feedback timestamp received."; @@ -227,7 +227,7 @@ TransportFeedbackAdapter::ProcessTransportFeedbackInner( if (packet.received()) { packet_offset += packet.delta(); packet_feedback.receive_time = - current_offset_ + packet_offset.RoundDownTo(TimeDelta::Millis<1>()); + current_offset_ + packet_offset.RoundDownTo(TimeDelta::Millis(1)); // Note: Lost packets are not removed from history because they might be // reported as received by a later feedback. history_.erase(it); diff --git a/modules/congestion_controller/rtp/transport_feedback_adapter_unittest.cc b/modules/congestion_controller/rtp/transport_feedback_adapter_unittest.cc index 4631dc29ef..d14a33423d 100644 --- a/modules/congestion_controller/rtp/transport_feedback_adapter_unittest.cc +++ b/modules/congestion_controller/rtp/transport_feedback_adapter_unittest.cc @@ -69,8 +69,8 @@ PacketResult CreatePacket(int64_t receive_time_ms, size_t payload_size, const PacedPacketInfo& pacing_info) { PacketResult res; - res.receive_time = Timestamp::ms(receive_time_ms); - res.sent_packet.send_time = Timestamp::ms(send_time_ms); + res.receive_time = Timestamp::Millis(receive_time_ms); + res.sent_packet.send_time = Timestamp::Millis(send_time_ms); res.sent_packet.sequence_number = sequence_number; res.sent_packet.size = DataSize::bytes(payload_size); res.sent_packet.pacing_info = pacing_info; @@ -294,21 +294,21 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) { std::vector<PacketResult> sent_packets; // TODO(srte): Consider using us resolution in the constants. const TimeDelta kSmallDelta = - TimeDelta::us(rtcp::TransportFeedback::kDeltaScaleFactor * 0xFF) - .RoundDownTo(TimeDelta::ms(1)); + TimeDelta::Micros(rtcp::TransportFeedback::kDeltaScaleFactor * 0xFF) + .RoundDownTo(TimeDelta::Millis(1)); const TimeDelta kLargePositiveDelta = - TimeDelta::us(rtcp::TransportFeedback::kDeltaScaleFactor * - std::numeric_limits<int16_t>::max()) - .RoundDownTo(TimeDelta::ms(1)); + TimeDelta::Micros(rtcp::TransportFeedback::kDeltaScaleFactor * + std::numeric_limits<int16_t>::max()) + .RoundDownTo(TimeDelta::Millis(1)); const TimeDelta kLargeNegativeDelta = - TimeDelta::us(rtcp::TransportFeedback::kDeltaScaleFactor * - std::numeric_limits<int16_t>::min()) - .RoundDownTo(TimeDelta::ms(1)); + TimeDelta::Micros(rtcp::TransportFeedback::kDeltaScaleFactor * + std::numeric_limits<int16_t>::min()) + .RoundDownTo(TimeDelta::Millis(1)); PacketResult packet_feedback; packet_feedback.sent_packet.sequence_number = 1; - packet_feedback.sent_packet.send_time = Timestamp::ms(100); - packet_feedback.receive_time = Timestamp::ms(200); + packet_feedback.sent_packet.send_time = Timestamp::Millis(100); + packet_feedback.receive_time = Timestamp::Millis(200); packet_feedback.sent_packet.size = DataSize::bytes(1500); sent_packets.push_back(packet_feedback); @@ -331,8 +331,8 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) { // Too large, delta - will need two feedback messages. packet_feedback.sent_packet.send_time += - kLargePositiveDelta + TimeDelta::ms(1); - packet_feedback.receive_time += kLargePositiveDelta + TimeDelta::ms(1); + kLargePositiveDelta + TimeDelta::Millis(1); + packet_feedback.receive_time += kLargePositiveDelta + TimeDelta::Millis(1); ++packet_feedback.sent_packet.sequence_number; // Packets will be added to send history. |