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}

modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc

@@ -178,7 +178,7 @@ TEST(AudioNetworkAdaptorImplTest,
       "WebRTC-Audio-BitrateAdaptation/Enabled/WebRTC-Audio-FecAdaptation/"
       "Enabled/");
   rtc::ScopedFakeClock fake_clock;
-  fake_clock.AdvanceTime(TimeDelta::ms(kClockInitialTimeMs));
+  fake_clock.AdvanceTime(TimeDelta::Millis(kClockInitialTimeMs));
   auto states = CreateAudioNetworkAdaptor();
   AudioEncoderRuntimeConfig config;
   config.bitrate_bps = 32000;
@@ -196,7 +196,7 @@ TEST(AudioNetworkAdaptorImplTest,
 TEST(AudioNetworkAdaptorImplTest,
      DumpNetworkMetricsIsCalledOnSetNetworkMetrics) {
   rtc::ScopedFakeClock fake_clock;
-  fake_clock.AdvanceTime(TimeDelta::ms(kClockInitialTimeMs));
+  fake_clock.AdvanceTime(TimeDelta::Millis(kClockInitialTimeMs));
 
   auto states = CreateAudioNetworkAdaptor();
 
@@ -214,31 +214,31 @@ TEST(AudioNetworkAdaptorImplTest,
               DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
   states.audio_network_adaptor->SetUplinkBandwidth(kBandwidth);
 
-  fake_clock.AdvanceTime(TimeDelta::ms(100));
+  fake_clock.AdvanceTime(TimeDelta::Millis(100));
   timestamp_check += 100;
   check.uplink_packet_loss_fraction = kPacketLoss;
   EXPECT_CALL(*states.mock_debug_dump_writer,
               DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
   states.audio_network_adaptor->SetUplinkPacketLossFraction(kPacketLoss);
 
-  fake_clock.AdvanceTime(TimeDelta::ms(50));
+  fake_clock.AdvanceTime(TimeDelta::Millis(50));
   timestamp_check += 50;
 
-  fake_clock.AdvanceTime(TimeDelta::ms(200));
+  fake_clock.AdvanceTime(TimeDelta::Millis(200));
   timestamp_check += 200;
   check.rtt_ms = kRtt;
   EXPECT_CALL(*states.mock_debug_dump_writer,
               DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
   states.audio_network_adaptor->SetRtt(kRtt);
 
-  fake_clock.AdvanceTime(TimeDelta::ms(150));
+  fake_clock.AdvanceTime(TimeDelta::Millis(150));
   timestamp_check += 150;
   check.target_audio_bitrate_bps = kTargetAudioBitrate;
   EXPECT_CALL(*states.mock_debug_dump_writer,
               DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
   states.audio_network_adaptor->SetTargetAudioBitrate(kTargetAudioBitrate);
 
-  fake_clock.AdvanceTime(TimeDelta::ms(50));
+  fake_clock.AdvanceTime(TimeDelta::Millis(50));
   timestamp_check += 50;
   check.overhead_bytes_per_packet = kOverhead;
   EXPECT_CALL(*states.mock_debug_dump_writer,

modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc

@@ -147,7 +147,7 @@ TEST(ControllerManagerTest, DoNotReorderBeforeMinReordingTime) {
   CheckControllersOrder(&states, kChracteristicBandwithBps[0],
                         kChracteristicPacketLossFraction[0],
                         {kNumControllers - 2, kNumControllers - 1, 0, 1});
-  fake_clock.AdvanceTime(TimeDelta::ms(kMinReorderingTimeMs - 1));
+  fake_clock.AdvanceTime(TimeDelta::Millis(kMinReorderingTimeMs - 1));
   // Move uplink bandwidth and packet loss fraction to the other controller's
   // characteristic point, which would cause controller manager to reorder the
   // controllers if time had reached min reordering time.
@@ -168,7 +168,7 @@ TEST(ControllerManagerTest, ReorderBeyondMinReordingTimeAndMinDistance) {
   // of two controllers.
   CheckControllersOrder(&states, kBandwidthBps, kPacketLossFraction,
                         {kNumControllers - 2, kNumControllers - 1, 0, 1});
-  fake_clock.AdvanceTime(TimeDelta::ms(kMinReorderingTimeMs));
+  fake_clock.AdvanceTime(TimeDelta::Millis(kMinReorderingTimeMs));
   // Then let network metrics move a little towards the other controller.
   CheckControllersOrder(&states, kBandwidthBps - kMinBandwithChangeBps - 1,
                         kPacketLossFraction,
@@ -187,7 +187,7 @@ TEST(ControllerManagerTest, DoNotReorderIfNetworkMetricsChangeTooSmall) {
   // of two controllers.
   CheckControllersOrder(&states, kBandwidthBps, kPacketLossFraction,
                         {kNumControllers - 2, kNumControllers - 1, 0, 1});
-  fake_clock.AdvanceTime(TimeDelta::ms(kMinReorderingTimeMs));
+  fake_clock.AdvanceTime(TimeDelta::Millis(kMinReorderingTimeMs));
   // Then let network metrics move a little towards the other controller.
   CheckControllersOrder(&states, kBandwidthBps - kMinBandwithChangeBps + 1,
                         kPacketLossFraction,
@@ -349,7 +349,7 @@ TEST(ControllerManagerTest, DebugDumpLoggedWhenCreateFromConfigString) {
 
   constexpr int64_t kClockInitialTimeMs = 12345678;
   rtc::ScopedFakeClock fake_clock;
-  fake_clock.AdvanceTime(TimeDelta::ms(kClockInitialTimeMs));
+  fake_clock.AdvanceTime(TimeDelta::Millis(kClockInitialTimeMs));
   auto debug_dump_writer =
       std::unique_ptr<MockDebugDumpWriter>(new NiceMock<MockDebugDumpWriter>());
   EXPECT_CALL(*debug_dump_writer, Die());
@@ -446,7 +446,7 @@ TEST(ControllerManagerTest, CreateFromConfigStringAndCheckReordering) {
 
   metrics.uplink_bandwidth_bps = kChracteristicBandwithBps[1];
   metrics.uplink_packet_loss_fraction = kChracteristicPacketLossFraction[1];
-  fake_clock.AdvanceTime(TimeDelta::ms(kMinReorderingTimeMs - 1));
+  fake_clock.AdvanceTime(TimeDelta::Millis(kMinReorderingTimeMs - 1));
   controllers = states.controller_manager->GetSortedControllers(metrics);
   // Should not reorder since min reordering time is not met.
   CheckControllersOrder(controllers,
@@ -455,7 +455,7 @@ TEST(ControllerManagerTest, CreateFromConfigStringAndCheckReordering) {
                             ControllerType::CHANNEL, ControllerType::DTX,
                             ControllerType::BIT_RATE});
 
-  fake_clock.AdvanceTime(TimeDelta::ms(1));
+  fake_clock.AdvanceTime(TimeDelta::Millis(1));
   controllers = states.controller_manager->GetSortedControllers(metrics);
   // Reorder now.
   CheckControllersOrder(controllers,

modules/audio_coding/codecs/opus/audio_encoder_opus.cc

@@ -924,11 +924,11 @@ AudioEncoderOpusImpl::GetFrameLengthRange() const {
   if (config_.supported_frame_lengths_ms.empty()) {
     return absl::nullopt;
   } else if (audio_network_adaptor_) {
-    return {{TimeDelta::ms(config_.supported_frame_lengths_ms.front()),
+    return {{TimeDelta::Millis(config_.supported_frame_lengths_ms.front()),
-             TimeDelta::ms(config_.supported_frame_lengths_ms.back())}};
+             TimeDelta::Millis(config_.supported_frame_lengths_ms.back())}};
   } else {
-    return {{TimeDelta::ms(config_.frame_size_ms),
+    return {{TimeDelta::Millis(config_.frame_size_ms),
-             TimeDelta::ms(config_.frame_size_ms)}};
+             TimeDelta::Millis(config_.frame_size_ms)}};
   }
 }
 

modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc

@@ -57,7 +57,7 @@ std::unique_ptr<AudioEncoderOpusStates> CreateCodec(int sample_rate_hz,
       std::make_unique<AudioEncoderOpusStates>();
   states->mock_audio_network_adaptor = nullptr;
   states->fake_clock.reset(new rtc::ScopedFakeClock());
-  states->fake_clock->SetTime(Timestamp::us(kInitialTimeUs));
+  states->fake_clock->SetTime(Timestamp::Micros(kInitialTimeUs));
 
   MockAudioNetworkAdaptor** mock_ptr = &states->mock_audio_network_adaptor;
   AudioEncoderOpusImpl::AudioNetworkAdaptorCreator creator =
@@ -249,7 +249,7 @@ void TestSetPacketLossRate(const AudioEncoderOpusStates* states,
   constexpr int64_t kSampleIntervalMs = 184198;
   for (float loss : losses) {
     states->encoder->OnReceivedUplinkPacketLossFraction(loss);
-    states->fake_clock->AdvanceTime(TimeDelta::ms(kSampleIntervalMs));
+    states->fake_clock->AdvanceTime(TimeDelta::Millis(kSampleIntervalMs));
     EXPECT_FLOAT_EQ(expected_return, states->encoder->packet_loss_rate());
   }
 }
@@ -429,7 +429,7 @@ TEST_P(AudioEncoderOpusTest,
   states->encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_1);
   EXPECT_FLOAT_EQ(0.01f, states->encoder->packet_loss_rate());
 
-  states->fake_clock->AdvanceTime(TimeDelta::ms(kSecondSampleTimeMs));
+  states->fake_clock->AdvanceTime(TimeDelta::Millis(kSecondSampleTimeMs));
   states->encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_2);
 
   // Now the output of packet loss fraction smoother should be
@@ -667,8 +667,8 @@ TEST_P(AudioEncoderOpusTest, UpdateUplinkBandwidthInAudioNetworkAdaptor) {
   // Repeat update uplink bandwidth tests.
   for (int i = 0; i < 5; i++) {
     // Don't update till it is time to update again.
-    states->fake_clock->AdvanceTime(
+    states->fake_clock->AdvanceTime(TimeDelta::Millis(
-        TimeDelta::ms(states->config.uplink_bandwidth_update_interval_ms - 1));
+        states->config.uplink_bandwidth_update_interval_ms - 1));
     states->encoder->Encode(
         0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded);
 
@@ -676,7 +676,7 @@ TEST_P(AudioEncoderOpusTest, UpdateUplinkBandwidthInAudioNetworkAdaptor) {
     EXPECT_CALL(*states->mock_bitrate_smoother, GetAverage())
         .WillOnce(Return(40000));
     EXPECT_CALL(*states->mock_audio_network_adaptor, SetUplinkBandwidth(40000));
-    states->fake_clock->AdvanceTime(TimeDelta::ms(1));
+    states->fake_clock->AdvanceTime(TimeDelta::Millis(1));
     states->encoder->Encode(
         0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded);
   }

modules/audio_device/include/test_audio_device.cc

@@ -93,7 +93,7 @@ class TestAudioDeviceModuleImpl
 
     RepeatingTaskHandle::Start(task_queue_->Get(), [this]() {
       ProcessAudio();
-      return TimeDelta::us(process_interval_us_);
+      return TimeDelta::Micros(process_interval_us_);
     });
     return 0;
   }

modules/audio_device/win/core_audio_input_win.cc

@@ -410,8 +410,8 @@ absl::optional<int> CoreAudioInput::EstimateLatencyMillis(
   }
   uint64_t qpc_now_raw = perf_counter_now.QuadPart;
   uint64_t now_time_100ns = qpc_now_raw * (*qpc_to_100ns_);
-  webrtc::TimeDelta delay_us =
+  webrtc::TimeDelta delay_us = webrtc::TimeDelta::Micros(
-      webrtc::TimeDelta::us(0.1 * (now_time_100ns - capture_time_100ns) + 0.5);
+      0.1 * (now_time_100ns - capture_time_100ns) + 0.5);
   return delay_us.ms();
 }
 

modules/audio_device/win/core_audio_output_win.cc

@@ -377,7 +377,7 @@ int CoreAudioOutput::EstimateOutputLatencyMillis(uint64_t device_frequency) {
 
     // Convert latency in number of frames into milliseconds.
     webrtc::TimeDelta delay =
-        webrtc::TimeDelta::us(delay_frames * rtc::kNumMicrosecsPerSec /
+        webrtc::TimeDelta::Micros(delay_frames * rtc::kNumMicrosecsPerSec /
                                   format_.Format.nSamplesPerSec);
     delay_ms = delay.ms();
   }

modules/audio_device/win/core_audio_utility_win.cc

@@ -1505,7 +1505,7 @@ std::string WaveFormatToString(const WaveFormatWrapper format) {
 
 webrtc::TimeDelta ReferenceTimeToTimeDelta(REFERENCE_TIME time) {
   // Each unit of reference time is 100 nanoseconds <=> 0.1 microsecond.
-  return webrtc::TimeDelta::us(0.1 * time + 0.5);
+  return webrtc::TimeDelta::Micros(0.1 * time + 0.5);
 }
 
 double FramesToMilliseconds(uint32_t num_frames, uint16_t sample_rate) {

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 time_between_packets = TimeDelta::Millis(1);
-  const TimeDelta rtt = TimeDelta::ms(800);
+  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);

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 {

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);
 }
 

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::Millis(send_time_ms),
-                                   Timestamp::ms(ack_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()};
   }

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);

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),
+  rtt_stats_.UpdateRtt(TimeDelta::Millis(300), TimeDelta::Millis(100),
-                       Timestamp::ms(0));
+                       Timestamp::Millis(0));
-  EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.latest_rtt());
+  EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.latest_rtt());
-  EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.smoothed_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),
+  rtt_stats_.UpdateRtt(TimeDelta::Millis(200), TimeDelta::Millis(200),
-                       Timestamp::ms(0));
+                       Timestamp::Millis(0));
-  EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.latest_rtt());
+  EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.latest_rtt());
-  EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.smoothed_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),
+  rtt_stats_.UpdateRtt(TimeDelta::Millis(200), TimeDelta::Millis(300),
-                       Timestamp::ms(0));
+                       Timestamp::Millis(0));
-  EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.latest_rtt());
+  EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.latest_rtt());
-  EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.smoothed_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),
+  rtt_stats_.UpdateRtt(TimeDelta::Millis(300), TimeDelta::Millis(100),
-                       Timestamp::ms(0));
+                       Timestamp::Millis(0));
-  EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.latest_rtt());
+  EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.latest_rtt());
-  EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.smoothed_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));
+  rtt_stats_.UpdateRtt(TimeDelta::Millis(100), TimeDelta::Zero(),
-  EXPECT_EQ(TimeDelta::ms(100), rtt_stats_.latest_rtt());
+                       Timestamp::Millis(0));
-  EXPECT_EQ(TimeDelta::us(187500).us(), rtt_stats_.smoothed_rtt().us());
+  EXPECT_EQ(TimeDelta::Millis(100), rtt_stats_.latest_rtt());
-  EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.previous_srtt());
+  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));
+  rtt_stats_.UpdateRtt(TimeDelta::Millis(200), TimeDelta::Zero(),
-  EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.min_rtt());
+                       Timestamp::Millis(0));
-  rtt_stats_.UpdateRtt(TimeDelta::ms(10), TimeDelta::Zero(),
+  EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.min_rtt());
-                       Timestamp::ms(0) + TimeDelta::ms(10));
+  rtt_stats_.UpdateRtt(TimeDelta::Millis(10), TimeDelta::Zero(),
-  EXPECT_EQ(TimeDelta::ms(10), rtt_stats_.min_rtt());
+                       Timestamp::Millis(0) + TimeDelta::Millis(10));
-  rtt_stats_.UpdateRtt(TimeDelta::ms(50), TimeDelta::Zero(),
+  EXPECT_EQ(TimeDelta::Millis(10), rtt_stats_.min_rtt());
-                       Timestamp::ms(0) + TimeDelta::ms(20));
+  rtt_stats_.UpdateRtt(TimeDelta::Millis(50), TimeDelta::Zero(),
-  EXPECT_EQ(TimeDelta::ms(10), rtt_stats_.min_rtt());
+                       Timestamp::Millis(0) + TimeDelta::Millis(20));
-  rtt_stats_.UpdateRtt(TimeDelta::ms(50), TimeDelta::Zero(),
+  EXPECT_EQ(TimeDelta::Millis(10), rtt_stats_.min_rtt());
-                       Timestamp::ms(0) + TimeDelta::ms(30));
+  rtt_stats_.UpdateRtt(TimeDelta::Millis(50), TimeDelta::Zero(),
-  EXPECT_EQ(TimeDelta::ms(10), rtt_stats_.min_rtt());
+                       Timestamp::Millis(0) + TimeDelta::Millis(30));
-  rtt_stats_.UpdateRtt(TimeDelta::ms(50), TimeDelta::Zero(),
+  EXPECT_EQ(TimeDelta::Millis(10), rtt_stats_.min_rtt());
-                       Timestamp::ms(0) + TimeDelta::ms(40));
+  rtt_stats_.UpdateRtt(TimeDelta::Millis(50), TimeDelta::Zero(),
-  EXPECT_EQ(TimeDelta::ms(10), rtt_stats_.min_rtt());
+                       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),
+  rtt_stats_.UpdateRtt(TimeDelta::Millis(7), TimeDelta::Millis(2),
-                       Timestamp::ms(0) + TimeDelta::ms(50));
+                       Timestamp::Millis(0) + TimeDelta::Millis(50));
-  EXPECT_EQ(TimeDelta::ms(7), rtt_stats_.min_rtt());
+  EXPECT_EQ(TimeDelta::Millis(7), rtt_stats_.min_rtt());
 }
 
 TEST_F(RttStatsTest, ExpireSmoothedMetrics) {
-  TimeDelta initial_rtt = TimeDelta::ms(10);
+  TimeDelta initial_rtt = TimeDelta::Millis(10);
-  rtt_stats_.UpdateRtt(initial_rtt, TimeDelta::Zero(), Timestamp::ms(0));
+  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);
+  TimeDelta initial_rtt = TimeDelta::Millis(10);
-  rtt_stats_.UpdateRtt(initial_rtt, TimeDelta::Zero(), Timestamp::ms(0));
+  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),
+  rtt_stats_.UpdateRtt(TimeDelta::Millis(300), TimeDelta::Millis(100),
-                       Timestamp::ms(0));
+                       Timestamp::Millis(0));
-  EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.latest_rtt());
+  EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.latest_rtt());
-  EXPECT_EQ(TimeDelta::ms(200), rtt_stats_.smoothed_rtt());
+  EXPECT_EQ(TimeDelta::Millis(200), rtt_stats_.smoothed_rtt());
-  EXPECT_EQ(TimeDelta::ms(300), rtt_stats_.min_rtt());
+  EXPECT_EQ(TimeDelta::Millis(300), rtt_stats_.min_rtt());
 
   // Reset rtt stats on connection migrations.
   rtt_stats_.OnConnectionMigration();

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::Millis(20), windowed_min_rtt_.GetBest());
-    EXPECT_EQ(TimeDelta::ms(40), windowed_min_rtt_.GetSecondBest());
+    EXPECT_EQ(TimeDelta::Millis(40), windowed_min_rtt_.GetSecondBest());
-    EXPECT_EQ(TimeDelta::ms(50), windowed_min_rtt_.GetThirdBest());
+    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::Millis(40), 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, 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());

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) ||
+  if (window_duration < TimeDelta::Millis(100) ||
-      TimeDelta::ms(2000) < window_duration) {
+      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)

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|.

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);
 }

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;
 }
 

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;

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_);
+      Timestamp::Millis(arrival_time_ms + arrival_time_offset_ms_);
-  packet.sent_packet.send_time = Timestamp::ms(send_time_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(

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;

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));
+  s.RunFor(TimeDelta::Seconds(10));
-  send_net->PauseTransmissionUntil(s.Now() + TimeDelta::seconds(10));
+  send_net->PauseTransmissionUntil(s.Now() + TimeDelta::Seconds(10));
-  s.RunFor(TimeDelta::seconds(3));
+  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);
+  const TimeDelta step = TimeDelta::Millis(50);
-  for (TimeDelta time = TimeDelta::Zero(); time < TimeDelta::ms(2000);
+  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

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_low_rtt("incr_low_rtt", TimeDelta::Millis(200)),
-      increase_high_rtt("incr_high_rtt", TimeDelta::ms(800)),
+      increase_high_rtt("incr_high_rtt", TimeDelta::Millis(800)),
       decrease_factor("decr", 0.99),
-      loss_window("loss_win", TimeDelta::ms(800)),
+      loss_window("loss_win", TimeDelta::Millis(800)),
-      loss_max_window("loss_max_win", TimeDelta::ms(800)),
+      loss_max_window("loss_max_win", TimeDelta::Millis(800)),
-      acknowledged_rate_max_window("ackrate_max_win", TimeDelta::ms(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)),
+      decrease_interval("decr_intvl", TimeDelta::Millis(300)),
-      loss_report_timeout("timeout", TimeDelta::ms(6000)) {
+      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;

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
 

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);
   }

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_++;

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);
   }

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 largest_recv_gap(TimeDelta::Millis(0));
-  TimeDelta second_largest_recv_gap(TimeDelta::ms(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));
+  send_duration = std::max(send_duration, TimeDelta::Millis(1));
-  recv_duration = std::max(recv_duration, TimeDelta::ms(1));
+  recv_duration = std::max(recv_duration, TimeDelta::Millis(1));
   return std::min(send_size / send_duration, recv_size / recv_duration);
 }
 

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 send_clock(Timestamp::Millis(100000));
-  Timestamp recv_clock(Timestamp::ms(10000));
+  Timestamp recv_clock(Timestamp::Millis(10000));
-  TimeDelta send_increment(TimeDelta::ms(10));
+  TimeDelta send_increment(TimeDelta::Millis(10));
-  TimeDelta recv_increment(TimeDelta::ms(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 send_clock(Timestamp::Millis(100000));
-  Timestamp recv_clock(Timestamp::ms(10000));
+  Timestamp recv_clock(Timestamp::Millis(10000));
-  TimeDelta send_increment(TimeDelta::ms(10));
+  TimeDelta send_increment(TimeDelta::Millis(10));
-  TimeDelta recv_increment(TimeDelta::ms(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 send_clock(Timestamp::Millis(100000));
-  Timestamp recv_clock(Timestamp::ms(10000));
+  Timestamp recv_clock(Timestamp::Millis(10000));
-  TimeDelta send_increment(TimeDelta::ms(10));
+  TimeDelta send_increment(TimeDelta::Millis(10));
-  TimeDelta recv_increment(TimeDelta::ms(40));
+  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 send_clock(Timestamp::Millis(100000));
-  Timestamp recv_clock(Timestamp::ms(10000));
+  Timestamp recv_clock(Timestamp::Millis(10000));
-  TimeDelta send_increment(TimeDelta::ms(20));
+  TimeDelta send_increment(TimeDelta::Millis(20));
-  TimeDelta recv_increment(TimeDelta::ms(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,

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 kBweIncreaseInterval = TimeDelta::Millis(1000);
-constexpr TimeDelta kBweDecreaseInterval = TimeDelta::Millis<300>();
+constexpr TimeDelta kBweDecreaseInterval = TimeDelta::Millis(300);
-constexpr TimeDelta kStartPhase = TimeDelta::Millis<2000>();
+constexpr TimeDelta kStartPhase = TimeDelta::Millis(2000);
-constexpr TimeDelta kBweConverganceTime = TimeDelta::Millis<20000>();
+constexpr TimeDelta kBweConverganceTime = TimeDelta::Millis(20000);
 constexpr int kLimitNumPackets = 20;
 constexpr DataRate kDefaultMaxBitrate = DataRate::BitsPerSec<1000000000>();
-constexpr TimeDelta kLowBitrateLogPeriod = TimeDelta::Millis<10000>();
+constexpr TimeDelta kLowBitrateLogPeriod = TimeDelta::Millis(10000);
-constexpr TimeDelta kRtcEventLogPeriod = TimeDelta::Millis<5000>();
+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();
   }

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));
+                        Timestamp::Millis(now_ms));
-  bwe.UpdateRtt(TimeDelta::ms(50), Timestamp::ms(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));
+                        Timestamp::Millis(now_ms));
-  bwe.UpdateRtt(TimeDelta::ms(kRttMs), Timestamp::ms(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);
 }
 

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 Timestamp kStartTime = Timestamp::Micros(0);
-const TimeDelta kPacketsDelta = TimeDelta::ms(1);
+const TimeDelta kPacketsDelta = TimeDelta::Millis(1);
-const TimeDelta kIntervalDuration = TimeDelta::ms(1000);
+const TimeDelta kIntervalDuration = TimeDelta::Millis(1000);
-const TimeDelta kDefaultRtt = TimeDelta::ms(1000);
+const TimeDelta kDefaultRtt = TimeDelta::Millis(1000);
 const DataSize kDefaultDataSize = DataSize::bytes(100);
 
 std::vector<PacketResult> CreatePacketResults(

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 Timestamp kStartTime = Timestamp::Micros(0);
-const TimeDelta kPacketsDelta = TimeDelta::ms(1);
+const TimeDelta kPacketsDelta = TimeDelta::Millis(1);
-const TimeDelta kIntervalDuration = TimeDelta::ms(100);
+const TimeDelta kIntervalDuration = TimeDelta::Millis(100);
-const TimeDelta kDefaultDelay = TimeDelta::ms(100);
+const TimeDelta kDefaultDelay = TimeDelta::Millis(100);
 const DataSize kDefaultPacketSize = DataSize::bytes(100);
 constexpr double kDelayGradientThreshold = 0.01;
 

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 kMinDurationOfMonitorInterval = TimeDelta::Millis(50);
-const TimeDelta kStartupDuration = TimeDelta::Millis<500>();
+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),
+      rtt_tracker_(TimeDelta::Millis(kInitialRttMs), kAlphaForRtt),
-      monitor_interval_timeout_(TimeDelta::ms(kInitialRttMs) * kTimeoutRatio),
+      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;
 

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); });
+      [](NetworkSimulationConfig* c) { c->delay = TimeDelta::Millis(200); });
-  s.RunFor(TimeDelta::seconds(35));
+  s.RunFor(TimeDelta::Seconds(35));
   EXPECT_NEAR(client->target_rate().kbps(), 170, 50);
 }
 

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);
 }

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 Timestamp kStartTime = Timestamp::Micros(0);
-const TimeDelta kPacketsDelta = TimeDelta::ms(1);
+const TimeDelta kPacketsDelta = TimeDelta::Millis(1);
-const TimeDelta kIntervalDuration = TimeDelta::ms(100);
+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,

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);

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);

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.receive_time = Timestamp::Millis(receive_time_ms);
-  res.sent_packet.send_time = Timestamp::ms(send_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)
+      TimeDelta::Micros(rtcp::TransportFeedback::kDeltaScaleFactor * 0xFF)
-          .RoundDownTo(TimeDelta::ms(1));
+          .RoundDownTo(TimeDelta::Millis(1));
   const TimeDelta kLargePositiveDelta =
-      TimeDelta::us(rtcp::TransportFeedback::kDeltaScaleFactor *
+      TimeDelta::Micros(rtcp::TransportFeedback::kDeltaScaleFactor *
                         std::numeric_limits<int16_t>::max())
-          .RoundDownTo(TimeDelta::ms(1));
+          .RoundDownTo(TimeDelta::Millis(1));
   const TimeDelta kLargeNegativeDelta =
-      TimeDelta::us(rtcp::TransportFeedback::kDeltaScaleFactor *
+      TimeDelta::Micros(rtcp::TransportFeedback::kDeltaScaleFactor *
                         std::numeric_limits<int16_t>::min())
-          .RoundDownTo(TimeDelta::ms(1));
+          .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.sent_packet.send_time = Timestamp::Millis(100);
-  packet_feedback.receive_time = Timestamp::ms(200);
+  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);
+      kLargePositiveDelta + TimeDelta::Millis(1);
-  packet_feedback.receive_time += kLargePositiveDelta + TimeDelta::ms(1);
+  packet_feedback.receive_time += kLargePositiveDelta + TimeDelta::Millis(1);
   ++packet_feedback.sent_packet.sequence_number;
 
   // Packets will be added to send history.

modules/pacing/bitrate_prober.cc

@@ -28,16 +28,16 @@ namespace {
 // we have a min probe packet size of 200 bytes.
 constexpr size_t kMinProbePacketSize = 200;
 
-constexpr TimeDelta kProbeClusterTimeout = TimeDelta::Seconds<5>();
+constexpr TimeDelta kProbeClusterTimeout = TimeDelta::Seconds(5);
 
 }  // namespace
 
 BitrateProberConfig::BitrateProberConfig(
     const WebRtcKeyValueConfig* key_value_config)
     : min_probe_packets_sent("min_probe_packets_sent", 5),
-      min_probe_delta("min_probe_delta", TimeDelta::ms(1)),
+      min_probe_delta("min_probe_delta", TimeDelta::Millis(1)),
-      min_probe_duration("min_probe_duration", TimeDelta::ms(15)),
+      min_probe_duration("min_probe_duration", TimeDelta::Millis(15)),
-      max_probe_delay("max_probe_delay", TimeDelta::ms(3)) {
+      max_probe_delay("max_probe_delay", TimeDelta::Millis(3)) {
   ParseFieldTrial({&min_probe_packets_sent, &min_probe_delta,
                    &min_probe_duration, &max_probe_delay},
                   key_value_config->Lookup("WebRTC-Bwe-ProbingConfiguration"));

modules/pacing/bitrate_prober_unittest.cc

@@ -21,7 +21,7 @@ TEST(BitrateProberTest, VerifyStatesAndTimeBetweenProbes) {
   BitrateProber prober(config);
   EXPECT_FALSE(prober.IsProbing());
 
-  Timestamp now = Timestamp::ms(0);
+  Timestamp now = Timestamp::Millis(0);
   const Timestamp start_time = now;
   EXPECT_EQ(prober.NextProbeTime(now), Timestamp::PlusInfinity());
 
@@ -29,7 +29,7 @@ TEST(BitrateProberTest, VerifyStatesAndTimeBetweenProbes) {
   const DataRate kTestBitrate2 = DataRate::kbps(1800);
   const int kClusterSize = 5;
   const int kProbeSize = 1000;
-  const TimeDelta kMinProbeDuration = TimeDelta::ms(15);
+  const TimeDelta kMinProbeDuration = TimeDelta::Millis(15);
 
   prober.CreateProbeCluster(kTestBitrate1, now, 0);
   prober.CreateProbeCluster(kTestBitrate2, now, 1);
@@ -92,7 +92,7 @@ TEST(BitrateProberTest, DoesntProbeWithoutRecentPackets) {
   EXPECT_EQ(now, std::max(now, prober.NextProbeTime(now)));
   prober.ProbeSent(now, 1000);
   // Let time pass, no large enough packets put into prober.
-  now += TimeDelta::seconds(6);
+  now += TimeDelta::Seconds(6);
   EXPECT_EQ(prober.NextProbeTime(now), Timestamp::PlusInfinity());
   // Check that legacy behaviour where prober is reset in TimeUntilNextProbe is
   // no longer there. Probes are no longer retried if they are timed out.
@@ -117,10 +117,11 @@ TEST(BitrateProberTest, VerifyProbeSizeOnHighBitrate) {
 
   const DataRate kHighBitrate = DataRate::kbps(10000);  // 10 Mbps
 
-  prober.CreateProbeCluster(kHighBitrate, Timestamp::ms(0), /*cluster_id=*/0);
+  prober.CreateProbeCluster(kHighBitrate, Timestamp::Millis(0),
+                            /*cluster_id=*/0);
   // Probe size should ensure a minimum of 1 ms interval.
   EXPECT_GT(prober.RecommendedMinProbeSize(),
-            (kHighBitrate * TimeDelta::ms(1)).bytes<size_t>());
+            (kHighBitrate * TimeDelta::Millis(1)).bytes<size_t>());
 }
 
 TEST(BitrateProberTest, MinumumNumberOfProbingPackets) {
@@ -131,7 +132,7 @@ TEST(BitrateProberTest, MinumumNumberOfProbingPackets) {
   const DataRate kBitrate = DataRate::kbps(100);
   const int kPacketSizeBytes = 1000;
 
-  Timestamp now = Timestamp::ms(0);
+  Timestamp now = Timestamp::Millis(0);
   prober.CreateProbeCluster(kBitrate, now, 0);
   prober.OnIncomingPacket(kPacketSizeBytes);
   for (int i = 0; i < 5; ++i) {
@@ -147,9 +148,9 @@ TEST(BitrateProberTest, ScaleBytesUsedForProbing) {
   BitrateProber prober(config);
   const DataRate kBitrate = DataRate::kbps(10000);  // 10 Mbps.
   const int kPacketSizeBytes = 1000;
-  const int kExpectedBytesSent = (kBitrate * TimeDelta::ms(15)).bytes();
+  const int kExpectedBytesSent = (kBitrate * TimeDelta::Millis(15)).bytes();
 
-  Timestamp now = Timestamp::ms(0);
+  Timestamp now = Timestamp::Millis(0);
   prober.CreateProbeCluster(kBitrate, now, /*cluster_id=*/0);
   prober.OnIncomingPacket(kPacketSizeBytes);
   int bytes_sent = 0;
@@ -167,9 +168,9 @@ TEST(BitrateProberTest, HighBitrateProbing) {
   BitrateProber prober(config);
   const DataRate kBitrate = DataRate::kbps(1000000);  // 1 Gbps.
   const int kPacketSizeBytes = 1000;
-  const int kExpectedBytesSent = (kBitrate * TimeDelta::ms(15)).bytes();
+  const int kExpectedBytesSent = (kBitrate * TimeDelta::Millis(15)).bytes();
 
-  Timestamp now = Timestamp::ms(0);
+  Timestamp now = Timestamp::Millis(0);
   prober.CreateProbeCluster(kBitrate, now, 0);
   prober.OnIncomingPacket(kPacketSizeBytes);
   int bytes_sent = 0;
@@ -189,9 +190,9 @@ TEST(BitrateProberTest, ProbeClusterTimeout) {
   const int kSmallPacketSize = 20;
   // Expecting two probe clusters of 5 packets each.
   const int kExpectedBytesSent = 20 * 2 * 5;
-  const TimeDelta kTimeout = TimeDelta::ms(5000);
+  const TimeDelta kTimeout = TimeDelta::Millis(5000);
 
-  Timestamp now = Timestamp::ms(0);
+  Timestamp now = Timestamp::Millis(0);
   prober.CreateProbeCluster(kBitrate, now, /*cluster_id=*/0);
   prober.OnIncomingPacket(kSmallPacketSize);
   EXPECT_FALSE(prober.IsProbing());
@@ -199,7 +200,7 @@ TEST(BitrateProberTest, ProbeClusterTimeout) {
   prober.CreateProbeCluster(kBitrate / 10, now, /*cluster_id=*/1);
   prober.OnIncomingPacket(kSmallPacketSize);
   EXPECT_FALSE(prober.IsProbing());
-  now += TimeDelta::ms(1);
+  now += TimeDelta::Millis(1);
   prober.CreateProbeCluster(kBitrate / 10, now, /*cluster_id=*/2);
   prober.OnIncomingPacket(kSmallPacketSize);
   EXPECT_TRUE(prober.IsProbing());

modules/pacing/paced_sender_unittest.cc

@@ -145,7 +145,7 @@ TEST_P(PacedSenderTest, PacesPackets) {
   // Packets should be sent over a period of close to 1s. Expect a little lower
   // than this since initial probing is a bit quicker.
   TimeDelta duration = clock_.CurrentTime() - start_time;
-  EXPECT_GT(duration, TimeDelta::ms(900));
+  EXPECT_GT(duration, TimeDelta::Millis(900));
 }
 
 INSTANTIATE_TEST_SUITE_P(

modules/pacing/pacing_controller.cc

@@ -26,17 +26,17 @@
 namespace webrtc {
 namespace {
 // Time limit in milliseconds between packet bursts.
-constexpr TimeDelta kDefaultMinPacketLimit = TimeDelta::Millis<5>();
+constexpr TimeDelta kDefaultMinPacketLimit = TimeDelta::Millis(5);
-constexpr TimeDelta kCongestedPacketInterval = TimeDelta::Millis<500>();
+constexpr TimeDelta kCongestedPacketInterval = TimeDelta::Millis(500);
 // TODO(sprang): Consider dropping this limit.
 // The maximum debt level, in terms of time, capped when sending packets.
-constexpr TimeDelta kMaxDebtInTime = TimeDelta::Millis<500>();
+constexpr TimeDelta kMaxDebtInTime = TimeDelta::Millis(500);
-constexpr TimeDelta kMaxElapsedTime = TimeDelta::Seconds<2>();
+constexpr TimeDelta kMaxElapsedTime = TimeDelta::Seconds(2);
 constexpr DataSize kDefaultPaddingTarget = DataSize::Bytes<50>();
 
 // Upper cap on process interval, in case process has not been called in a long
 // time.
-constexpr TimeDelta kMaxProcessingInterval = TimeDelta::Millis<30>();
+constexpr TimeDelta kMaxProcessingInterval = TimeDelta::Millis(30);
 
 constexpr int kFirstPriority = 0;
 
@@ -75,11 +75,11 @@ int GetPriorityForType(RtpPacketMediaType type) {
 }  // namespace
 
 const TimeDelta PacingController::kMaxExpectedQueueLength =
-    TimeDelta::Millis<2000>();
+    TimeDelta::Millis(2000);
 const float PacingController::kDefaultPaceMultiplier = 2.5f;
 const TimeDelta PacingController::kPausedProcessInterval =
     kCongestedPacketInterval;
-const TimeDelta PacingController::kMinSleepTime = TimeDelta::Millis<1>();
+const TimeDelta PacingController::kMinSleepTime = TimeDelta::Millis(1);
 
 PacingController::PacingController(Clock* clock,
                                    PacketSender* packet_sender,
@@ -130,7 +130,7 @@ PacingController::PacingController(Clock* clock,
   FieldTrialParameter<int> min_packet_limit_ms("", min_packet_limit_.ms());
   ParseFieldTrial({&min_packet_limit_ms},
                   field_trials_->Lookup("WebRTC-Pacer-MinPacketLimitMs"));
-  min_packet_limit_ = TimeDelta::ms(min_packet_limit_ms.Get());
+  min_packet_limit_ = TimeDelta::Millis(min_packet_limit_ms.Get());
   UpdateBudgetWithElapsedTime(min_packet_limit_);
 }
 
@@ -242,7 +242,7 @@ void PacingController::SetTransportOverhead(DataSize overhead_per_packet) {
 
 TimeDelta PacingController::ExpectedQueueTime() const {
   RTC_DCHECK_GT(pacing_bitrate_, DataRate::Zero());
-  return TimeDelta::ms(
+  return TimeDelta::Millis(
       (QueueSizeData().bytes() * 8 * rtc::kNumMillisecsPerSec) /
       pacing_bitrate_.bps());
 }
@@ -439,7 +439,7 @@ void PacingController::ProcessPackets() {
       packet_queue_.UpdateQueueTime(now);
       if (drain_large_queues_) {
         TimeDelta avg_time_left =
-            std::max(TimeDelta::ms(1),
+            std::max(TimeDelta::Millis(1),
                      queue_time_limit - packet_queue_.AverageQueueTime());
         DataRate min_rate_needed = queue_size_data / avg_time_left;
         if (min_rate_needed > target_rate) {

modules/pacing/pacing_controller_unittest.cc

@@ -317,7 +317,7 @@ class PacingControllerFieldTrialTest
   }
   void ProcessNext(PacingController* pacer) {
     if (GetParam() == PacingController::ProcessMode::kPeriodic) {
-      TimeDelta process_interval = TimeDelta::ms(5);
+      TimeDelta process_interval = TimeDelta::Millis(5);
       clock_.AdvanceTime(process_interval);
       pacer->ProcessPackets();
       return;
@@ -436,7 +436,7 @@ TEST_P(PacingControllerFieldTrialTest, BudgetAffectsAudioInTrial) {
   // Verify delay is near expectation, within timing margin.
   EXPECT_LT(((wait_end_time - wait_start_time) - expected_wait_time).Abs(),
             GetParam() == PacingController::ProcessMode::kPeriodic
-                ? TimeDelta::ms(5)
+                ? TimeDelta::Millis(5)
                 : PacingController::kMinSleepTime);
 }
 
@@ -540,7 +540,7 @@ TEST_P(PacingControllerTest, QueueAndPacePackets) {
   const uint32_t kSsrc = 12345;
   uint16_t sequence_number = 1234;
   const DataSize kPackeSize = DataSize::bytes(250);
-  const TimeDelta kSendInterval = TimeDelta::ms(5);
+  const TimeDelta kSendInterval = TimeDelta::Millis(5);
 
   // Due to the multiplicative factor we can send 5 packets during a 5ms send
   // interval. (send interval * network capacity * multiplier / packet size)
@@ -621,9 +621,9 @@ TEST_P(PacingControllerTest, PaceQueuedPackets) {
     }
   }
   const TimeDelta actual_pace_time = clock_.CurrentTime() - start_time;
-  EXPECT_LT(
+  EXPECT_LT((actual_pace_time - expected_pace_time).Abs(),
-      (actual_pace_time - expected_pace_time).Abs(),
+            PeriodicProcess() ? TimeDelta::Millis(5)
-      PeriodicProcess() ? TimeDelta::ms(5) : PacingController::kMinSleepTime);
+                              : PacingController::kMinSleepTime);
 
   EXPECT_EQ(0u, pacer_->QueueSizePackets());
   clock_.AdvanceTime(TimeUntilNextProcess());
@@ -838,7 +838,7 @@ TEST_P(PacingControllerTest, VerifyAverageBitrateVaryingMediaPayload) {
   uint16_t sequence_number = 1234;
   int64_t capture_time_ms = 56789;
   const int kTimeStep = 5;
-  const TimeDelta kAveragingWindowLength = TimeDelta::seconds(10);
+  const TimeDelta kAveragingWindowLength = TimeDelta::Seconds(10);
   PacingControllerPadding callback;
   pacer_ = std::make_unique<PacingController>(&clock_, &callback, nullptr,
                                               nullptr, GetParam());
@@ -1195,7 +1195,7 @@ TEST_P(PacingControllerTest, Pause) {
   }
 
   // Expect everything to be queued.
-  EXPECT_EQ(TimeDelta::ms(second_capture_time_ms - capture_time_ms),
+  EXPECT_EQ(TimeDelta::Millis(second_capture_time_ms - capture_time_ms),
             pacer_->OldestPacketWaitTime());
 
   // Process triggers keep-alive packet.
@@ -1206,7 +1206,7 @@ TEST_P(PacingControllerTest, Pause) {
   pacer_->ProcessPackets();
 
   // Verify no packets sent for the rest of the paused process interval.
-  const TimeDelta kProcessInterval = TimeDelta::ms(5);
+  const TimeDelta kProcessInterval = TimeDelta::Millis(5);
   TimeDelta expected_time_until_send = PacingController::kPausedProcessInterval;
   EXPECT_CALL(callback_, SendPadding).Times(0);
   while (expected_time_until_send >= kProcessInterval) {
@@ -1301,7 +1301,7 @@ TEST_P(PacingControllerTest, InactiveFromStart) {
       (GetParam() == PacingController::ProcessMode::kDynamic
            ? PacingController::kMinSleepTime
            : TimeDelta::Zero()) +
-      TimeDelta::us(1);
+      TimeDelta::Micros(1);
 
   EXPECT_EQ(pacer_->NextSendTime() - start_time,
             PacingController::kPausedProcessInterval);
@@ -1333,7 +1333,7 @@ TEST_P(PacingControllerTest, ExpectedQueueTimeMs) {
 
   // Queue in ms = 1000 * (bytes in queue) *8 / (bits per second)
   TimeDelta queue_time =
-      TimeDelta::ms(1000 * kNumPackets * kPacketSize * 8 / kMaxBitrate);
+      TimeDelta::Millis(1000 * kNumPackets * kPacketSize * 8 / kMaxBitrate);
   EXPECT_EQ(queue_time, pacer_->ExpectedQueueTime());
 
   const Timestamp time_start = clock_.CurrentTime();
@@ -1349,7 +1349,7 @@ TEST_P(PacingControllerTest, ExpectedQueueTimeMs) {
   const TimeDelta deviation =
       duration - PacingController::kMaxExpectedQueueLength;
   EXPECT_LT(deviation.Abs(),
-            TimeDelta::ms(1000 * kPacketSize * 8 / kMaxBitrate));
+            TimeDelta::Millis(1000 * kPacketSize * 8 / kMaxBitrate));
 }
 
 TEST_P(PacingControllerTest, QueueTimeGrowsOverTime) {
@@ -1363,7 +1363,7 @@ TEST_P(PacingControllerTest, QueueTimeGrowsOverTime) {
                       clock_.TimeInMilliseconds(), 1200);
 
   clock_.AdvanceTimeMilliseconds(500);
-  EXPECT_EQ(TimeDelta::ms(500), pacer_->OldestPacketWaitTime());
+  EXPECT_EQ(TimeDelta::Millis(500), pacer_->OldestPacketWaitTime());
   pacer_->ProcessPackets();
   EXPECT_EQ(TimeDelta::Zero(), pacer_->OldestPacketWaitTime());
 }
@@ -1472,7 +1472,7 @@ TEST_P(PacingControllerTest, SkipsProbesWhenProcessIntervalTooLarge) {
   EXPECT_EQ(pacer_->NextSendTime(), probe_time);
 
   // Too high probe delay, drop it!
-  clock_.AdvanceTime(TimeDelta::us(1));
+  clock_.AdvanceTime(TimeDelta::Micros(1));
   EXPECT_GT(pacer_->NextSendTime(), probe_time);
 }
 
@@ -1535,7 +1535,7 @@ TEST_P(PacingControllerTest, PaddingOveruse) {
 
   SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++,
                       clock_.TimeInMilliseconds(), kPacketSize);
-  EXPECT_LT(TimeDelta::ms(5), pacer_->ExpectedQueueTime());
+  EXPECT_LT(TimeDelta::Millis(5), pacer_->ExpectedQueueTime());
   // Don't send padding if queue is non-empty, even if padding budget > 0.
   EXPECT_CALL(callback_, SendPadding).Times(0);
   if (PeriodicProcess()) {
@@ -1718,7 +1718,7 @@ TEST_P(PacingControllerTest, TaskLate) {
   // Simulate a late process call, executed just before we allow sending the
   // fourth packet.
   clock_.AdvanceTime((time_between_packets * 3) -
-                     (PacingController::kMinSleepTime + TimeDelta::ms(1)));
+                     (PacingController::kMinSleepTime + TimeDelta::Millis(1)));
 
   EXPECT_CALL(callback_, SendPacket).Times(2);
   pacer_->ProcessPackets();
@@ -1726,10 +1726,10 @@ TEST_P(PacingControllerTest, TaskLate) {
   // Check that next scheduled send time is within sleep-time + 1ms.
   next_send_time = pacer_->NextSendTime();
   EXPECT_LE(next_send_time - clock_.CurrentTime(),
-            PacingController::kMinSleepTime + TimeDelta::ms(1));
+            PacingController::kMinSleepTime + TimeDelta::Millis(1));
 
   // Advance to within error margin for execution.
-  clock_.AdvanceTime(TimeDelta::ms(1));
+  clock_.AdvanceTime(TimeDelta::Millis(1));
   EXPECT_CALL(callback_, SendPacket).Times(1);
   pacer_->ProcessPackets();
 }

modules/pacing/packet_router_unittest.cc

@@ -453,7 +453,7 @@ TEST(PacketRouterRembTest, LowerEstimateToSendRemb) {
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
   // Call OnReceiveBitrateChanged twice to get a first estimate.
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   EXPECT_CALL(rtp, SetRemb(bitrate_estimate, ssrcs)).Times(1);
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
@@ -479,7 +479,7 @@ TEST(PacketRouterRembTest, VerifyIncreasingAndDecreasing) {
 
   // Call OnReceiveBitrateChanged twice to get a first estimate.
   EXPECT_CALL(rtp, SetRemb(bitrate_estimate[0], ssrcs)).Times(1);
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate[0]);
 
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate[1] + 100);
@@ -504,7 +504,7 @@ TEST(PacketRouterRembTest, NoRembForIncreasedBitrate) {
 
   // Call OnReceiveBitrateChanged twice to get a first estimate.
   EXPECT_CALL(rtp, SetRemb(bitrate_estimate, ssrcs)).Times(1);
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
   // Increased estimate shouldn't trigger a callback right away.
@@ -533,7 +533,7 @@ TEST(PacketRouterRembTest, ChangeSendRtpModule) {
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
   // Call OnReceiveBitrateChanged twice to get a first estimate.
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   EXPECT_CALL(rtp_send, SetRemb(bitrate_estimate, ssrcs)).Times(1);
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
@@ -566,7 +566,7 @@ TEST(PacketRouterRembTest, OnlyOneRembForRepeatedOnReceiveBitrateChanged) {
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
   // Call OnReceiveBitrateChanged twice to get a first estimate.
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   EXPECT_CALL(rtp, SetRemb(_, _)).Times(1);
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
@@ -584,7 +584,7 @@ TEST(PacketRouterRembTest, OnlyOneRembForRepeatedOnReceiveBitrateChanged) {
 TEST(PacketRouterRembTest, SetMaxDesiredReceiveBitrateLimitsSetRemb) {
   rtc::ScopedFakeClock clock;
   PacketRouter packet_router;
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   NiceMock<MockRtpRtcp> remb_sender;
   constexpr bool remb_candidate = true;
   packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
@@ -596,7 +596,7 @@ TEST(PacketRouterRembTest, SetMaxDesiredReceiveBitrateLimitsSetRemb) {
   const std::vector<uint32_t> ssrcs = {1234};
   packet_router.SetMaxDesiredReceiveBitrate(cap_bitrate);
   packet_router.OnReceiveBitrateChanged(ssrcs, cap_bitrate + 5000);
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   packet_router.OnReceiveBitrateChanged(ssrcs, cap_bitrate - 5000);
 
   // Test tear-down.
@@ -607,7 +607,7 @@ TEST(PacketRouterRembTest,
      SetMaxDesiredReceiveBitrateTriggersRembWhenMoreRestrictive) {
   rtc::ScopedFakeClock clock;
   PacketRouter packet_router;
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   NiceMock<MockRtpRtcp> remb_sender;
   constexpr bool remb_candidate = true;
   packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
@@ -629,7 +629,7 @@ TEST(PacketRouterRembTest,
      SetMaxDesiredReceiveBitrateDoesNotTriggerRembWhenAsRestrictive) {
   rtc::ScopedFakeClock clock;
   PacketRouter packet_router;
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   NiceMock<MockRtpRtcp> remb_sender;
   constexpr bool remb_candidate = true;
   packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
@@ -651,7 +651,7 @@ TEST(PacketRouterRembTest,
      SetMaxDesiredReceiveBitrateDoesNotTriggerRembWhenLessRestrictive) {
   rtc::ScopedFakeClock clock;
   PacketRouter packet_router;
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   NiceMock<MockRtpRtcp> remb_sender;
   constexpr bool remb_candidate = true;
   packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
@@ -673,7 +673,7 @@ TEST(PacketRouterRembTest,
      SetMaxDesiredReceiveBitrateTriggersRembWhenNoRecentMeasure) {
   rtc::ScopedFakeClock clock;
   PacketRouter packet_router;
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   NiceMock<MockRtpRtcp> remb_sender;
   constexpr bool remb_candidate = true;
   packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
@@ -683,7 +683,7 @@ TEST(PacketRouterRembTest,
   const std::vector<uint32_t> ssrcs = {1234};
   EXPECT_CALL(remb_sender, SetRemb(measured_bitrate_bps, _));
   packet_router.OnReceiveBitrateChanged(ssrcs, measured_bitrate_bps);
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
 
   EXPECT_CALL(remb_sender, SetRemb(cap_bitrate_bps, _));
   packet_router.SetMaxDesiredReceiveBitrate(cap_bitrate_bps);
@@ -696,7 +696,7 @@ TEST(PacketRouterRembTest,
      SetMaxDesiredReceiveBitrateTriggersRembWhenNoMeasures) {
   rtc::ScopedFakeClock clock;
   PacketRouter packet_router;
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   NiceMock<MockRtpRtcp> remb_sender;
   constexpr bool remb_candidate = true;
   packet_router.AddSendRtpModule(&remb_sender, remb_candidate);
@@ -730,7 +730,7 @@ TEST(PacketRouterRembTest, NoSendingRtpModule) {
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
   // Call OnReceiveBitrateChanged twice to get a first estimate.
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   EXPECT_CALL(rtp, SetRemb(bitrate_estimate, ssrcs)).Times(1);
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
@@ -754,7 +754,7 @@ TEST(PacketRouterRembTest, NonCandidateSendRtpModuleNotUsedForRemb) {
   constexpr uint32_t bitrate_estimate = 456;
   const std::vector<uint32_t> ssrcs = {1234};
   EXPECT_CALL(module, SetRemb(_, _)).Times(0);
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
   // Test tear-down
@@ -773,7 +773,7 @@ TEST(PacketRouterRembTest, CandidateSendRtpModuleUsedForRemb) {
   constexpr uint32_t bitrate_estimate = 456;
   const std::vector<uint32_t> ssrcs = {1234};
   EXPECT_CALL(module, SetRemb(bitrate_estimate, ssrcs)).Times(1);
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
   // Test tear-down
@@ -792,7 +792,7 @@ TEST(PacketRouterRembTest, NonCandidateReceiveRtpModuleNotUsedForRemb) {
   constexpr uint32_t bitrate_estimate = 456;
   const std::vector<uint32_t> ssrcs = {1234};
   EXPECT_CALL(module, SetRemb(_, _)).Times(0);
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
   // Test tear-down
@@ -811,7 +811,7 @@ TEST(PacketRouterRembTest, CandidateReceiveRtpModuleUsedForRemb) {
   constexpr uint32_t bitrate_estimate = 456;
   const std::vector<uint32_t> ssrcs = {1234};
   EXPECT_CALL(module, SetRemb(bitrate_estimate, ssrcs)).Times(1);
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
   // Test tear-down
@@ -838,7 +838,7 @@ TEST(PacketRouterRembTest,
   EXPECT_CALL(send_module, SetRemb(bitrate_estimate, ssrcs)).Times(1);
   EXPECT_CALL(receive_module, SetRemb(_, _)).Times(0);
 
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
   // Test tear-down
@@ -866,7 +866,7 @@ TEST(PacketRouterRembTest,
   EXPECT_CALL(send_module, SetRemb(bitrate_estimate, ssrcs)).Times(1);
   EXPECT_CALL(receive_module, SetRemb(_, _)).Times(0);
 
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
   // Test tear-down
@@ -893,7 +893,7 @@ TEST(PacketRouterRembTest, ReceiveModuleTakesOverWhenLastSendModuleRemoved) {
   EXPECT_CALL(send_module, SetRemb(_, _)).Times(0);
   EXPECT_CALL(receive_module, SetRemb(bitrate_estimate, ssrcs)).Times(1);
 
-  clock.AdvanceTime(TimeDelta::ms(1000));
+  clock.AdvanceTime(TimeDelta::Millis(1000));
   packet_router.OnReceiveBitrateChanged(ssrcs, bitrate_estimate);
 
   // Test tear-down

modules/pacing/round_robin_packet_queue.cc

@@ -235,7 +235,7 @@ void RoundRobinPacketQueue::UpdateQueueTime(Timestamp now) {
   if (paused_) {
     pause_time_sum_ += delta;
   } else {
-    queue_time_sum_ += TimeDelta::us(delta.us() * size_packets_);
+    queue_time_sum_ += TimeDelta::Micros(delta.us() * size_packets_);
   }
 
   time_last_updated_ = now;

modules/pacing/task_queue_paced_sender.cc

@@ -23,10 +23,10 @@ namespace {
 // If no calls to MaybeProcessPackets() happen, make sure we update stats
 // at least every |kMaxTimeBetweenStatsUpdates| as long as the pacer isn't
 // completely drained.
-constexpr TimeDelta kMaxTimeBetweenStatsUpdates = TimeDelta::Millis<33>();
+constexpr TimeDelta kMaxTimeBetweenStatsUpdates = TimeDelta::Millis(33);
 // Don't call UpdateStats() more than |kMinTimeBetweenStatsUpdates| apart,
 // for performance reasons.
-constexpr TimeDelta kMinTimeBetweenStatsUpdates = TimeDelta::Millis<1>();
+constexpr TimeDelta kMinTimeBetweenStatsUpdates = TimeDelta::Millis(1);
 }  // namespace
 
 TaskQueuePacedSender::TaskQueuePacedSender(

modules/pacing/task_queue_paced_sender_unittest.cc

@@ -51,7 +51,7 @@ namespace test {
 class TaskQueuePacedSenderTest : public ::testing::Test {
  public:
   TaskQueuePacedSenderTest()
-      : time_controller_(Timestamp::ms(1234)),
+      : time_controller_(Timestamp::Millis(1234)),
         pacer_(time_controller_.GetClock(),
                &packet_router_,
                /*event_log=*/nullptr,
@@ -123,7 +123,7 @@ TEST_F(TaskQueuePacedSenderTest, PacesPackets) {
 
   // Packets should be sent over a period of close to 1s. Expect a little lower
   // than this since initial probing is a bit quicker.
-  time_controller_.AdvanceTime(TimeDelta::seconds(1));
+  time_controller_.AdvanceTime(TimeDelta::Seconds(1));
   EXPECT_EQ(packets_sent, kPacketsToSend);
   ASSERT_TRUE(end_time.IsFinite());
   EXPECT_NEAR((end_time - start_time).ms<double>(), 1000.0, 50.0);
@@ -140,7 +140,7 @@ TEST_F(TaskQueuePacedSenderTest, ReschedulesProcessOnRateChange) {
   EXPECT_CALL(packet_router_, SendPacket).Times(kPacketsPerSecond);
   pacer_.EnqueuePackets(
       GeneratePackets(RtpPacketMediaType::kVideo, kPacketsPerSecond));
-  time_controller_.AdvanceTime(TimeDelta::seconds(1));
+  time_controller_.AdvanceTime(TimeDelta::Seconds(1));
 
   // Insert three packets, and record send time of each of them.
   // After the second packet is sent, double the send rate so we can
@@ -164,7 +164,7 @@ TEST_F(TaskQueuePacedSenderTest, ReschedulesProcessOnRateChange) {
       });
 
   pacer_.EnqueuePackets(GeneratePackets(RtpPacketMediaType::kVideo, 3));
-  time_controller_.AdvanceTime(TimeDelta::ms(500));
+  time_controller_.AdvanceTime(TimeDelta::Millis(500));
   ASSERT_TRUE(third_packet_time.IsFinite());
   EXPECT_NEAR((second_packet_time - first_packet_time).ms<double>(), 200.0,
               1.0);

modules/remote_bitrate_estimator/aimd_rate_control.cc

@@ -30,7 +30,7 @@
 namespace webrtc {
 namespace {
 
-constexpr TimeDelta kDefaultRtt = TimeDelta::Millis<200>();
+constexpr TimeDelta kDefaultRtt = TimeDelta::Millis(200);
 constexpr double kDefaultBackoffFactor = 0.85;
 
 constexpr char kBweBackOffFactorExperiment[] = "WebRTC-BweBackOffFactor";
@@ -140,15 +140,15 @@ TimeDelta AimdRateControl::GetFeedbackInterval() const {
   const DataSize kRtcpSize = DataSize::bytes(80);
   const DataRate rtcp_bitrate = current_bitrate_ * 0.05;
   const TimeDelta interval = kRtcpSize / rtcp_bitrate;
-  const TimeDelta kMinFeedbackInterval = TimeDelta::ms(200);
+  const TimeDelta kMinFeedbackInterval = TimeDelta::Millis(200);
-  const TimeDelta kMaxFeedbackInterval = TimeDelta::ms(1000);
+  const TimeDelta kMaxFeedbackInterval = TimeDelta::Millis(1000);
   return interval.Clamped(kMinFeedbackInterval, kMaxFeedbackInterval);
 }
 
 bool AimdRateControl::TimeToReduceFurther(Timestamp at_time,
                                           DataRate estimated_throughput) const {
   const TimeDelta bitrate_reduction_interval =
-      rtt_.Clamped(TimeDelta::ms(10), TimeDelta::ms(200));
+      rtt_.Clamped(TimeDelta::Millis(10), TimeDelta::Millis(200));
   if (at_time - time_last_bitrate_change_ >= bitrate_reduction_interval) {
     return true;
   }
@@ -192,7 +192,7 @@ DataRate AimdRateControl::Update(const RateControlInput* input,
   // second.
   // TODO(bugs.webrtc.org/9379): The comment above doesn't match to the code.
   if (!bitrate_is_initialized_) {
-    const TimeDelta kInitializationTime = TimeDelta::seconds(5);
+    const TimeDelta kInitializationTime = TimeDelta::Seconds(5);
     RTC_DCHECK_LE(kBitrateWindowMs, kInitializationTime.ms());
     if (time_first_throughput_estimate_.IsInfinite()) {
       if (input->estimated_throughput)
@@ -230,14 +230,14 @@ void AimdRateControl::SetNetworkStateEstimate(
 
 double AimdRateControl::GetNearMaxIncreaseRateBpsPerSecond() const {
   RTC_DCHECK(!current_bitrate_.IsZero());
-  const TimeDelta kFrameInterval = TimeDelta::seconds(1) / 30;
+  const TimeDelta kFrameInterval = TimeDelta::Seconds(1) / 30;
   DataSize frame_size = current_bitrate_ * kFrameInterval;
   const DataSize kPacketSize = DataSize::bytes(1200);
   double packets_per_frame = std::ceil(frame_size / kPacketSize);
   DataSize avg_packet_size = frame_size / packets_per_frame;
 
   // Approximate the over-use estimator delay to 100 ms.
-  TimeDelta response_time = rtt_ + TimeDelta::ms(100);
+  TimeDelta response_time = rtt_ + TimeDelta::Millis(100);
   if (in_experiment_)
     response_time = response_time * 2;
   double increase_rate_bps_per_second =
@@ -248,16 +248,16 @@ double AimdRateControl::GetNearMaxIncreaseRateBpsPerSecond() const {
 
 TimeDelta AimdRateControl::GetExpectedBandwidthPeriod() const {
   const TimeDelta kMinPeriod =
-      smoothing_experiment_ ? TimeDelta::ms(500) : TimeDelta::seconds(2);
+      smoothing_experiment_ ? TimeDelta::Millis(500) : TimeDelta::Seconds(2);
-  const TimeDelta kDefaultPeriod = TimeDelta::seconds(3);
+  const TimeDelta kDefaultPeriod = TimeDelta::Seconds(3);
-  const TimeDelta kMaxPeriod = TimeDelta::seconds(50);
+  const TimeDelta kMaxPeriod = TimeDelta::Seconds(50);
 
   double increase_rate_bps_per_second = GetNearMaxIncreaseRateBpsPerSecond();
   if (!last_decrease_)
     return smoothing_experiment_ ? kMinPeriod : kDefaultPeriod;
   double time_to_recover_decrease_seconds =
       last_decrease_->bps() / increase_rate_bps_per_second;
-  TimeDelta period = TimeDelta::seconds(time_to_recover_decrease_seconds);
+  TimeDelta period = TimeDelta::Seconds(time_to_recover_decrease_seconds);
   return period.Clamped(kMinPeriod, kMaxPeriod);
 }
 

modules/remote_bitrate_estimator/aimd_rate_control_unittest.cc

@@ -58,7 +58,7 @@ void UpdateRateControl(const AimdRateControlStates& states,
                        int64_t now_ms) {
   RateControlInput input(bandwidth_usage,
                          OptionalRateFromOptionalBps(throughput_estimate));
-  states.aimd_rate_control->Update(&input, Timestamp::ms(now_ms));
+  states.aimd_rate_control->Update(&input, Timestamp::Millis(now_ms));
 }
 void SetEstimate(const AimdRateControlStates& states, int bitrate_bps) {
   states.aimd_rate_control->SetEstimate(DataRate::bps(bitrate_bps),
@@ -87,7 +87,7 @@ TEST(AimdRateControlTest, NearMaxIncreaseRateIs5kbpsOn60kbpsAnd100msRtt) {
   auto states = CreateAimdRateControlStates();
   constexpr int kBitrate = 60000;
   SetEstimate(states, kBitrate);
-  states.aimd_rate_control->SetRtt(TimeDelta::ms(100));
+  states.aimd_rate_control->SetRtt(TimeDelta::Millis(100));
   EXPECT_EQ(5000,
             states.aimd_rate_control->GetNearMaxIncreaseRateBpsPerSecond());
 }

modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc

@@ -202,7 +202,7 @@ RemoteBitrateEstimatorAbsSendTime::ProcessClusters(int64_t now_ms) {
                        << " ms, mean recv delta: " << best_it->recv_mean_ms
                        << " ms, num probes: " << best_it->count;
       remote_rate_.SetEstimate(DataRate::bps(probe_bitrate_bps),
-                               Timestamp::ms(now_ms));
+                               Timestamp::Millis(now_ms));
       return ProbeResult::kBitrateUpdated;
     }
   }
@@ -336,7 +336,7 @@ void RemoteBitrateEstimatorAbsSendTime::IncomingPacketInfo(
         absl::optional<uint32_t> incoming_rate =
             incoming_bitrate_.Rate(arrival_time_ms);
         if (incoming_rate &&
-            remote_rate_.TimeToReduceFurther(Timestamp::ms(now_ms),
+            remote_rate_.TimeToReduceFurther(Timestamp::Millis(now_ms),
                                              DataRate::bps(*incoming_rate))) {
           update_estimate = true;
         }
@@ -351,7 +351,8 @@ void RemoteBitrateEstimatorAbsSendTime::IncomingPacketInfo(
           detector_.State(),
           OptionalRateFromOptionalBps(incoming_bitrate_.Rate(arrival_time_ms)));
       target_bitrate_bps =
-          remote_rate_.Update(&input, Timestamp::ms(now_ms)).bps<uint32_t>();
+          remote_rate_.Update(&input, Timestamp::Millis(now_ms))
+              .bps<uint32_t>();
       update_estimate = remote_rate_.ValidEstimate();
       ssrcs = Keys(ssrcs_);
     }
@@ -391,7 +392,7 @@ void RemoteBitrateEstimatorAbsSendTime::TimeoutStreams(int64_t now_ms) {
 void RemoteBitrateEstimatorAbsSendTime::OnRttUpdate(int64_t avg_rtt_ms,
                                                     int64_t max_rtt_ms) {
   rtc::CritScope lock(&crit_);
-  remote_rate_.SetRtt(TimeDelta::ms(avg_rtt_ms));
+  remote_rate_.SetRtt(TimeDelta::Millis(avg_rtt_ms));
 }
 
 void RemoteBitrateEstimatorAbsSendTime::RemoveStream(uint32_t ssrc) {

modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc

@@ -143,10 +143,10 @@ void RemoteBitrateEstimatorSingleStream::IncomingPacket(
   if (estimator->detector.State() == BandwidthUsage::kBwOverusing) {
     absl::optional<uint32_t> incoming_bitrate_bps =
         incoming_bitrate_.Rate(now_ms);
-    if (incoming_bitrate_bps &&
+    if (incoming_bitrate_bps && (prior_state != BandwidthUsage::kBwOverusing ||
-        (prior_state != BandwidthUsage::kBwOverusing ||
                                  GetRemoteRate()->TimeToReduceFurther(
-             Timestamp::ms(now_ms), DataRate::bps(*incoming_bitrate_bps)))) {
+                                     Timestamp::Millis(now_ms),
+                                     DataRate::bps(*incoming_bitrate_bps)))) {
       // The first overuse should immediately trigger a new estimate.
       // We also have to update the estimate immediately if we are overusing
       // and the target bitrate is too high compared to what we are receiving.
@@ -203,7 +203,7 @@ void RemoteBitrateEstimatorSingleStream::UpdateEstimate(int64_t now_ms) {
   const RateControlInput input(
       bw_state, OptionalRateFromOptionalBps(incoming_bitrate_.Rate(now_ms)));
   uint32_t target_bitrate =
-      remote_rate->Update(&input, Timestamp::ms(now_ms)).bps<uint32_t>();
+      remote_rate->Update(&input, Timestamp::Millis(now_ms)).bps<uint32_t>();
   if (remote_rate->ValidEstimate()) {
     process_interval_ms_ = remote_rate->GetFeedbackInterval().ms();
     RTC_DCHECK_GT(process_interval_ms_, 0);
@@ -217,7 +217,7 @@ void RemoteBitrateEstimatorSingleStream::UpdateEstimate(int64_t now_ms) {
 void RemoteBitrateEstimatorSingleStream::OnRttUpdate(int64_t avg_rtt_ms,
                                                      int64_t max_rtt_ms) {
   rtc::CritScope cs(&crit_sect_);
-  GetRemoteRate()->SetRtt(TimeDelta::ms(avg_rtt_ms));
+  GetRemoteRate()->SetRtt(TimeDelta::Millis(avg_rtt_ms));
 }
 
 void RemoteBitrateEstimatorSingleStream::RemoveStream(unsigned int ssrc) {

modules/remote_bitrate_estimator/remote_estimator_proxy.cc

@@ -112,12 +112,12 @@ void RemoteEstimatorProxy::IncomingPacket(int64_t arrival_time_ms,
 
   if (network_state_estimator_ && header.extension.hasAbsoluteSendTime) {
     PacketResult packet_result;
-    packet_result.receive_time = Timestamp::ms(arrival_time_ms);
+    packet_result.receive_time = Timestamp::Millis(arrival_time_ms);
     // Ignore reordering of packets and assume they have approximately the same
     // send time.
     abs_send_timestamp_ += std::max(
         header.extension.GetAbsoluteSendTimeDelta(previous_abs_send_time_),
-        TimeDelta::ms(0));
+        TimeDelta::Millis(0));
     previous_abs_send_time_ = header.extension.absoluteSendTime;
     packet_result.sent_packet.send_time = abs_send_timestamp_;
     // TODO(webrtc:10742): Take IP header and transport overhead into account.

modules/remote_bitrate_estimator/remote_estimator_proxy.h

@@ -56,10 +56,11 @@ class RemoteEstimatorProxy : public RemoteBitrateEstimator {
 
  private:
   struct TransportWideFeedbackConfig {
-    FieldTrialParameter<TimeDelta> back_window{"wind", TimeDelta::ms(500)};
+    FieldTrialParameter<TimeDelta> back_window{"wind", TimeDelta::Millis(500)};
-    FieldTrialParameter<TimeDelta> min_interval{"min", TimeDelta::ms(50)};
+    FieldTrialParameter<TimeDelta> min_interval{"min", TimeDelta::Millis(50)};
-    FieldTrialParameter<TimeDelta> max_interval{"max", TimeDelta::ms(250)};
+    FieldTrialParameter<TimeDelta> max_interval{"max", TimeDelta::Millis(250)};
-    FieldTrialParameter<TimeDelta> default_interval{"def", TimeDelta::ms(100)};
+    FieldTrialParameter<TimeDelta> default_interval{"def",
+                                                    TimeDelta::Millis(100)};
     FieldTrialParameter<double> bandwidth_fraction{"frac", 0.05};
     explicit TransportWideFeedbackConfig(
         const WebRtcKeyValueConfig* key_value_config) {

modules/remote_bitrate_estimator/remote_estimator_proxy_unittest.cc

@@ -595,10 +595,10 @@ TEST_F(RemoteEstimatorProxyOnRequestTest,
 }
 
 TEST_F(RemoteEstimatorProxyTest, ReportsIncomingPacketToNetworkStateEstimator) {
-  Timestamp first_send_timestamp = Timestamp::ms(0);
+  Timestamp first_send_timestamp = Timestamp::Millis(0);
   EXPECT_CALL(network_state_estimator_, OnReceivedPacket(_))
       .WillOnce(Invoke([&first_send_timestamp](const PacketResult& packet) {
-        EXPECT_EQ(packet.receive_time, Timestamp::ms(kBaseTimeMs));
+        EXPECT_EQ(packet.receive_time, Timestamp::Millis(kBaseTimeMs));
         first_send_timestamp = packet.sent_packet.send_time;
       }));
   // Incoming packet with abs sendtime but without transport sequence number.
@@ -611,7 +611,7 @@ TEST_F(RemoteEstimatorProxyTest, ReportsIncomingPacketToNetworkStateEstimator) {
   // time as the previous packet due to reordering.
   EXPECT_CALL(network_state_estimator_, OnReceivedPacket(_))
       .WillOnce(Invoke([&first_send_timestamp](const PacketResult& packet) {
-        EXPECT_EQ(packet.receive_time, Timestamp::ms(kBaseTimeMs));
+        EXPECT_EQ(packet.receive_time, Timestamp::Millis(kBaseTimeMs));
         EXPECT_EQ(packet.sent_packet.send_time, first_send_timestamp);
       }));
   proxy_.IncomingPacket(
@@ -626,12 +626,12 @@ TEST_F(RemoteEstimatorProxyTest, IncomingPacketHandlesWrapInAbsSendTime) {
       AbsoluteSendTime::MsTo24Bits((1 << 24) - 30);
   // Second abs send time has wrapped.
   const uint32_t kSecondAbsSendTime = AbsoluteSendTime::MsTo24Bits((1 << 24));
-  const TimeDelta kExpectedAbsSendTimeDelta = TimeDelta::ms(30);
+  const TimeDelta kExpectedAbsSendTimeDelta = TimeDelta::Millis(30);
 
-  Timestamp first_send_timestamp = Timestamp::ms(0);
+  Timestamp first_send_timestamp = Timestamp::Millis(0);
   EXPECT_CALL(network_state_estimator_, OnReceivedPacket(_))
       .WillOnce(Invoke([&first_send_timestamp](const PacketResult& packet) {
-        EXPECT_EQ(packet.receive_time, Timestamp::ms(kBaseTimeMs));
+        EXPECT_EQ(packet.receive_time, Timestamp::Millis(kBaseTimeMs));
         first_send_timestamp = packet.sent_packet.send_time;
       }));
   proxy_.IncomingPacket(
@@ -641,7 +641,7 @@ TEST_F(RemoteEstimatorProxyTest, IncomingPacketHandlesWrapInAbsSendTime) {
   EXPECT_CALL(network_state_estimator_, OnReceivedPacket(_))
       .WillOnce(Invoke([first_send_timestamp,
                         kExpectedAbsSendTimeDelta](const PacketResult& packet) {
-        EXPECT_EQ(packet.receive_time, Timestamp::ms(kBaseTimeMs + 123));
+        EXPECT_EQ(packet.receive_time, Timestamp::Millis(kBaseTimeMs + 123));
         EXPECT_EQ(packet.sent_packet.send_time.ms(),
                   (first_send_timestamp + kExpectedAbsSendTimeDelta).ms());
       }));

modules/rtp_rtcp/source/absolute_capture_time_receiver.h

@@ -36,7 +36,7 @@ namespace webrtc {
 class AbsoluteCaptureTimeReceiver {
  public:
   static constexpr TimeDelta kInterpolationMaxInterval =
-      TimeDelta::Millis<5000>();
+      TimeDelta::Millis(5000);
 
   explicit AbsoluteCaptureTimeReceiver(Clock* clock);
 

modules/rtp_rtcp/source/absolute_capture_time_sender.h

@@ -41,8 +41,8 @@ namespace webrtc {
 class AbsoluteCaptureTimeSender {
  public:
   static constexpr TimeDelta kInterpolationMaxInterval =
-      TimeDelta::Millis<1000>();
+      TimeDelta::Millis(1000);
-  static constexpr TimeDelta kInterpolationMaxError = TimeDelta::Millis<1>();
+  static constexpr TimeDelta kInterpolationMaxError = TimeDelta::Millis(1);
 
   explicit AbsoluteCaptureTimeSender(Clock* clock);
 

modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc

@@ -377,7 +377,7 @@ int64_t TransportFeedback::GetBaseTimeUs() const {
 }
 
 TimeDelta TransportFeedback::GetBaseTime() const {
-  return TimeDelta::us(GetBaseTimeUs());
+  return TimeDelta::Micros(GetBaseTimeUs());
 }
 
 int64_t TransportFeedback::GetBaseDeltaUs(int64_t prev_timestamp_us) const {
@@ -393,7 +393,7 @@ int64_t TransportFeedback::GetBaseDeltaUs(int64_t prev_timestamp_us) const {
 }
 
 TimeDelta TransportFeedback::GetBaseDelta(TimeDelta prev_timestamp) const {
-  return TimeDelta::us(GetBaseDeltaUs(prev_timestamp.us()));
+  return TimeDelta::Micros(GetBaseDeltaUs(prev_timestamp.us()));
 }
 
 // De-serialize packet.

modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h

@@ -37,7 +37,7 @@ class TransportFeedback : public Rtpfb {
     uint16_t sequence_number() const { return sequence_number_; }
     int16_t delta_ticks() const { return delta_ticks_; }
     int32_t delta_us() const { return delta_ticks_ * kDeltaScaleFactor; }
-    TimeDelta delta() const { return TimeDelta::us(delta_us()); }
+    TimeDelta delta() const { return TimeDelta::Micros(delta_us()); }
     bool received() const { return received_; }
 
    private:

modules/rtp_rtcp/source/rtcp_receiver_unittest.cc

@@ -1211,7 +1211,7 @@ TEST_F(RtcpReceiverTest,
   // The "report_block_timestamp_utc_us" is obtained from the global UTC clock
   // (not the simulcated |system_clock_|) and requires a scoped fake clock.
   rtc::ScopedFakeClock fake_clock;
-  fake_clock.SetTime(Timestamp::us(kUtcNowUs));
+  fake_clock.SetTime(Timestamp::Micros(kUtcNowUs));
 
   rtcp::ReportBlock rtcp_block;
   rtcp_block.SetMediaSsrc(kReceiverMainSsrc);

modules/rtp_rtcp/source/rtcp_transceiver_impl.cc

@@ -332,11 +332,11 @@ void RtcpTransceiverImpl::ReschedulePeriodicCompoundPackets() {
 
 void RtcpTransceiverImpl::SchedulePeriodicCompoundPackets(int64_t delay_ms) {
   periodic_task_handle_ = RepeatingTaskHandle::DelayedStart(
-      config_.task_queue->Get(), TimeDelta::ms(delay_ms), [this] {
+      config_.task_queue->Get(), TimeDelta::Millis(delay_ms), [this] {
         RTC_DCHECK(config_.schedule_periodic_compound_packets);
         RTC_DCHECK(ready_to_send_);
         SendPeriodicCompoundPacket();
-        return TimeDelta::ms(config_.report_period_ms);
+        return TimeDelta::Millis(config_.report_period_ms);
       });
 }
 

modules/rtp_rtcp/source/rtcp_transceiver_impl_unittest.cc

@@ -734,10 +734,10 @@ TEST(RtcpTransceiverImplTest,
   };
 
   receive_sender_report(kRemoteSsrc1);
-  clock.AdvanceTime(webrtc::TimeDelta::ms(100));
+  clock.AdvanceTime(webrtc::TimeDelta::Millis(100));
 
   receive_sender_report(kRemoteSsrc2);
-  clock.AdvanceTime(webrtc::TimeDelta::ms(100));
+  clock.AdvanceTime(webrtc::TimeDelta::Millis(100));
 
   // Trigger ReceiverReport back.
   rtcp_transceiver.SendCompoundPacket();

modules/rtp_rtcp/source/time_util_unittest.cc

@@ -21,18 +21,18 @@ TEST(TimeUtilTest, TimeMicrosToNtpDoesntChangeBetweenRuns) {
   // TimeMicrosToNtp is not pure: it behave differently between different
   // execution of the program, but should behave same during same execution.
   const int64_t time_us = 12345;
-  clock.SetTime(Timestamp::us(2));
+  clock.SetTime(Timestamp::Micros(2));
   NtpTime time_ntp = TimeMicrosToNtp(time_us);
-  clock.SetTime(Timestamp::us(time_us));
+  clock.SetTime(Timestamp::Micros(time_us));
   EXPECT_EQ(TimeMicrosToNtp(time_us), time_ntp);
-  clock.SetTime(Timestamp::us(1000000));
+  clock.SetTime(Timestamp::Micros(1000000));
   EXPECT_EQ(TimeMicrosToNtp(time_us), time_ntp);
 }
 
 TEST(TimeUtilTest, TimeMicrosToNtpKeepsIntervals) {
   rtc::ScopedFakeClock clock;
   NtpTime time_ntp1 = TimeMicrosToNtp(rtc::TimeMicros());
-  clock.AdvanceTime(TimeDelta::ms(20));
+  clock.AdvanceTime(TimeDelta::Millis(20));
   NtpTime time_ntp2 = TimeMicrosToNtp(rtc::TimeMicros());
   EXPECT_EQ(time_ntp2.ToMs() - time_ntp1.ToMs(), 20);
 }

modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc

@@ -113,7 +113,7 @@ class ScreenshareLayerTest : public ::testing::Test {
 
   Vp8FrameConfig NextFrameConfig(size_t stream_index, uint32_t timestamp) {
     int64_t timestamp_ms = timestamp / 90;
-    clock_.AdvanceTime(TimeDelta::ms(timestamp_ms - rtc::TimeMillis()));
+    clock_.AdvanceTime(TimeDelta::Millis(timestamp_ms - rtc::TimeMillis()));
     return layers_->NextFrameConfig(stream_index, timestamp);
   }
 
@@ -563,7 +563,7 @@ TEST_F(ScreenshareLayerTest, UpdatesHistograms) {
     } else {
       RTC_NOTREACHED() << "Unexpected flags";
     }
-    clock_.AdvanceTime(TimeDelta::ms(1000 / 5));
+    clock_.AdvanceTime(TimeDelta::Millis(1000 / 5));
   }
 
   EXPECT_TRUE(overshoot);
@@ -626,7 +626,7 @@ TEST_F(ScreenshareLayerTest, RespectsConfiguredFramerate) {
                             IgnoredCodecSpecificInfo());
     }
     timestamp += kFrameIntervalsMs * 90;
-    clock_.AdvanceTime(TimeDelta::ms(kFrameIntervalsMs));
+    clock_.AdvanceTime(TimeDelta::Millis(kFrameIntervalsMs));
 
     ++num_input_frames;
   }
@@ -644,7 +644,7 @@ TEST_F(ScreenshareLayerTest, RespectsConfiguredFramerate) {
                             IgnoredCodecSpecificInfo());
     }
     timestamp += kFrameIntervalsMs * 90 / 2;
-    clock_.AdvanceTime(TimeDelta::ms(kFrameIntervalsMs));
+    clock_.AdvanceTime(TimeDelta::Millis(kFrameIntervalsMs));
     ++num_input_frames;
   }
 

modules/video_coding/frame_buffer2.cc

@@ -92,7 +92,7 @@ void FrameBuffer::StartWaitForNextFrameOnQueue() {
   RTC_DCHECK(!callback_task_.Running());
   int64_t wait_ms = FindNextFrame(clock_->TimeInMilliseconds());
   callback_task_ = RepeatingTaskHandle::DelayedStart(
-      callback_queue_->Get(), TimeDelta::ms(wait_ms), [this] {
+      callback_queue_->Get(), TimeDelta::Millis(wait_ms), [this] {
         // If this task has not been cancelled, we did not get any new frames
         // while waiting. Continue with frame delivery.
         rtc::CritScope lock(&crit_);
@@ -111,7 +111,7 @@ void FrameBuffer::StartWaitForNextFrameOnQueue() {
           // means that the frame buffer was cleared between creation and
           // execution of this task. Continue waiting for the remaining time.
           int64_t wait_ms = FindNextFrame(clock_->TimeInMilliseconds());
-          return TimeDelta::ms(wait_ms);
+          return TimeDelta::Millis(wait_ms);
         }
       });
 }

modules/video_coding/frame_buffer2_unittest.cc

@@ -135,7 +135,7 @@ class TestFrameBuffer2 : public ::testing::Test {
 
   TestFrameBuffer2()
       : trial_("WebRTC-AddRttToPlayoutDelay/Enabled/"),
-        time_controller_(Timestamp::seconds(0)),
+        time_controller_(Timestamp::Seconds(0)),
         time_task_queue_(
             time_controller_.GetTaskQueueFactory()->CreateTaskQueue(
                 "extract queue",
@@ -206,7 +206,7 @@ class TestFrameBuffer2 : public ::testing::Test {
           });
     });
     if (max_wait_time == 0) {
-      time_controller_.AdvanceTime(TimeDelta::ms(0));
+      time_controller_.AdvanceTime(TimeDelta::Millis(0));
     }
   }
 
@@ -256,7 +256,7 @@ TEST_F(TestFrameBuffer2, WaitForFrame) {
 
   ExtractFrame(50);
   InsertFrame(pid, 0, ts, false, true, kFrameSize);
-  time_controller_.AdvanceTime(TimeDelta::ms(50));
+  time_controller_.AdvanceTime(TimeDelta::Millis(50));
   CheckFrame(0, pid, 0);
 }
 
@@ -293,7 +293,7 @@ TEST_F(TestFrameBuffer2, DISABLED_OneUnorderedSuperFrame) {
   ExtractFrame(50);
   InsertFrame(pid, 1, ts, true, true, kFrameSize);
   InsertFrame(pid, 0, ts, false, false, kFrameSize);
-  time_controller_.AdvanceTime(TimeDelta::ms(0));
+  time_controller_.AdvanceTime(TimeDelta::Millis(0));
 
   CheckFrame(0, pid, 0);
   CheckFrame(1, pid, 1);
@@ -310,10 +310,10 @@ TEST_F(TestFrameBuffer2, DISABLED_OneLayerStreamReordered) {
     ExtractFrame(50);
     InsertFrame(pid + i + 1, 0, ts + (i + 1) * kFps10, false, true, kFrameSize,
                 pid + i);
-    time_controller_.AdvanceTime(TimeDelta::ms(kFps10));
+    time_controller_.AdvanceTime(TimeDelta::Millis(kFps10));
     InsertFrame(pid + i, 0, ts + i * kFps10, false, true, kFrameSize,
                 pid + i - 1);
-    time_controller_.AdvanceTime(TimeDelta::ms(kFps10));
+    time_controller_.AdvanceTime(TimeDelta::Millis(kFps10));
     ExtractFrame();
     CheckFrame(i, pid + i, 0);
     CheckFrame(i + 1, pid + i + 1, 0);
@@ -352,7 +352,7 @@ TEST_F(TestFrameBuffer2, OneLayerStream) {
     InsertFrame(pid + i, 0, ts + i * kFps10, false, true, kFrameSize,
                 pid + i - 1);
     ExtractFrame();
-    time_controller_.AdvanceTime(TimeDelta::ms(kFps10));
+    time_controller_.AdvanceTime(TimeDelta::Millis(kFps10));
     CheckFrame(i, pid + i, 0);
   }
 }
@@ -374,7 +374,7 @@ TEST_F(TestFrameBuffer2, DropTemporalLayerSlowDecoder) {
 
   for (int i = 0; i < 10; ++i) {
     ExtractFrame();
-    time_controller_.AdvanceTime(TimeDelta::ms(70));
+    time_controller_.AdvanceTime(TimeDelta::Millis(70));
   }
 
   CheckFrame(0, pid, 0);
@@ -400,7 +400,7 @@ TEST_F(TestFrameBuffer2, DropFramesIfSystemIsStalled) {
 
   ExtractFrame();
   // Jump forward in time, simulating the system being stalled for some reason.
-  time_controller_.AdvanceTime(TimeDelta::ms(3) * kFps10);
+  time_controller_.AdvanceTime(TimeDelta::Millis(3) * kFps10);
   // Extract one more frame, expect second and third frame to be dropped.
   EXPECT_CALL(stats_callback_, OnDroppedFrames(2)).Times(1);
   ExtractFrame();
@@ -683,7 +683,7 @@ TEST_F(TestFrameBuffer2, HigherSpatialLayerNonDecodable) {
   InsertFrame(pid + 2, 0, ts + kFps10, false, false, kFrameSize, pid);
   InsertFrame(pid + 2, 1, ts + kFps10, true, true, kFrameSize, pid + 1);
 
-  time_controller_.AdvanceTime(TimeDelta::ms(1000));
+  time_controller_.AdvanceTime(TimeDelta::Millis(1000));
   // Frame pid+1 is decodable but too late.
   // In superframe pid+2 frame sid=0 is decodable, but frame sid=1 is not.
   // Incorrect implementation might skip pid+1 frame and output undecodable

modules/video_coding/nack_module.cc

@@ -65,11 +65,11 @@ NackModule::BackoffSettings::BackoffSettings(TimeDelta min_retry,
 absl::optional<NackModule::BackoffSettings>
 NackModule::BackoffSettings::ParseFromFieldTrials() {
   // Matches magic number in RTPSender::OnReceivedNack().
-  const TimeDelta kDefaultMinRetryInterval = TimeDelta::ms(5);
+  const TimeDelta kDefaultMinRetryInterval = TimeDelta::Millis(5);
   // Upper bound on link-delay considered for exponential backoff.
   // Selected so that cumulative delay with 1.25 base and 10 retries ends up
   // below 3s, since above that there will be a FIR generated instead.
-  const TimeDelta kDefaultMaxRtt = TimeDelta::ms(160);
+  const TimeDelta kDefaultMaxRtt = TimeDelta::Millis(160);
   // Default base for exponential backoff, adds 25% RTT delay for each retry.
   const double kDefaultBase = 1.25;
 
@@ -296,13 +296,13 @@ std::vector<uint16_t> NackModule::GetNackBatch(NackFilterOptions options) {
   std::vector<uint16_t> nack_batch;
   auto it = nack_list_.begin();
   while (it != nack_list_.end()) {
-    TimeDelta resend_delay = TimeDelta::ms(rtt_ms_);
+    TimeDelta resend_delay = TimeDelta::Millis(rtt_ms_);
     if (backoff_settings_) {
       resend_delay =
           std::max(resend_delay, backoff_settings_->min_retry_interval);
       if (it->second.retries > 1) {
         TimeDelta exponential_backoff =
-            std::min(TimeDelta::ms(rtt_ms_), backoff_settings_->max_rtt) *
+            std::min(TimeDelta::Millis(rtt_ms_), backoff_settings_->max_rtt) *
             std::pow(backoff_settings_->base, it->second.retries - 1);
         resend_delay = std::max(resend_delay, exponential_backoff);
       }

modules/video_coding/nack_module_unittest.cc

@@ -184,12 +184,12 @@ TEST_P(TestNackModule, ResendNack) {
   const double b = GetParam() ? 1.25 : 1.0;
   for (int i = 2; i < 10; ++i) {
     // Change RTT, above the 40ms max for exponential backoff.
-    TimeDelta rtt = TimeDelta::ms(160);  // + (i * 10 - 40)
+    TimeDelta rtt = TimeDelta::Millis(160);  // + (i * 10 - 40)
     nack_module_.UpdateRtt(rtt.ms());
 
     // RTT gets capped at 160ms in backoff calculations.
     TimeDelta expected_backoff_delay =
-        std::pow(b, i - 1) * std::min(rtt, TimeDelta::ms(160));
+        std::pow(b, i - 1) * std::min(rtt, TimeDelta::Millis(160));
 
     // Move to one millisecond before next allowed NACK.
     clock_->AdvanceTimeMilliseconds(expected_backoff_delay.ms() - 1);

modules/video_coding/utility/quality_scaler.cc

@@ -104,9 +104,10 @@ QualityScaler::QualityScaler(AdaptationObserverInterface* observer,
   }
   RTC_DCHECK(observer_ != nullptr);
   check_qp_task_ = RepeatingTaskHandle::DelayedStart(
-      TaskQueueBase::Current(), TimeDelta::ms(GetSamplingPeriodMs()), [this]() {
+      TaskQueueBase::Current(), TimeDelta::Millis(GetSamplingPeriodMs()),
+      [this]() {
         CheckQp();
-        return TimeDelta::ms(GetSamplingPeriodMs());
+        return TimeDelta::Millis(GetSamplingPeriodMs());
       });
   RTC_LOG(LS_INFO) << "QP thresholds: low: " << thresholds_.low
                    << ", high: " << thresholds_.high;