Use newer version of TimeDelta and TimeStamp factories in webrtc

find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/TimeDelta::Micros<\(.*\)>()/TimeDelta::Micros(\1)/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/TimeDelta::Millis<\(.*\)>()/TimeDelta::Millis(\1)/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/TimeDelta::Seconds<\(.*\)>()/TimeDelta::Seconds(\1)/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/TimeDelta::us/TimeDelta::Micros/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/TimeDelta::ms/TimeDelta::Millis/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/TimeDelta::seconds/TimeDelta::Seconds/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/Timestamp::Micros<\(.*\)>()/Timestamp::Micros(\1)/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/Timestamp::Millis<\(.*\)>()/Timestamp::Millis(\1)/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/Timestamp::Seconds<\(.*\)>()/Timestamp::Seconds(\1)/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/Timestamp::us/Timestamp::Micros/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/Timestamp::ms/Timestamp::Millis/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/Timestamp::seconds/Timestamp::Seconds/g"
git cl format

Bug: None
Change-Id: I87469d2e4a38369654da839ab7c838215a7911e7
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/168402
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30491}

4 files changed, 45 insertions, 44 deletions

diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
index c52e0c77ef..3059621690 100644
--- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
+++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
@@ -784,7 +784,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpReceiverReport) {
   }
 
   rtc::ScopedFakeClock fake_clock;
-  fake_clock.SetTime(Timestamp::ms(prng_.Rand<uint32_t>()));
+  fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
 
   for (auto direction : {kIncomingPacket, kOutgoingPacket}) {
     std::vector<rtcp::ReceiverReport> events(event_count_);
@@ -800,7 +800,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpReceiverReport) {
         history_.push_back(
             std::make_unique<RtcEventRtcpPacketOutgoing>(buffer));
       }
-      fake_clock.AdvanceTime(TimeDelta::ms(prng_.Rand(0, 1000)));
+      fake_clock.AdvanceTime(TimeDelta::Millis(prng_.Rand(0, 1000)));
     }
 
     std::string encoded =
@@ -823,7 +823,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpSenderReport) {
   }
 
   rtc::ScopedFakeClock fake_clock;
-  fake_clock.SetTime(Timestamp::ms(prng_.Rand<uint32_t>()));
+  fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
 
   for (auto direction : {kIncomingPacket, kOutgoingPacket}) {
     std::vector<rtcp::SenderReport> events(event_count_);
@@ -839,7 +839,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpSenderReport) {
         history_.push_back(
             std::make_unique<RtcEventRtcpPacketOutgoing>(buffer));
       }
-      fake_clock.AdvanceTime(TimeDelta::ms(prng_.Rand(0, 1000)));
+      fake_clock.AdvanceTime(TimeDelta::Millis(prng_.Rand(0, 1000)));
     }
 
     std::string encoded =
@@ -862,7 +862,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpExtendedReports) {
   }
 
   rtc::ScopedFakeClock fake_clock;
-  fake_clock.SetTime(Timestamp::ms(prng_.Rand<uint32_t>()));
+  fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
 
   for (auto direction : {kIncomingPacket, kOutgoingPacket}) {
     std::vector<rtcp::ExtendedReports> events(event_count_);
@@ -878,7 +878,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpExtendedReports) {
         history_.push_back(
             std::make_unique<RtcEventRtcpPacketOutgoing>(buffer));
       }
-      fake_clock.AdvanceTime(TimeDelta::ms(prng_.Rand(0, 1000)));
+      fake_clock.AdvanceTime(TimeDelta::Millis(prng_.Rand(0, 1000)));
     }
 
     std::string encoded =
@@ -901,7 +901,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpFir) {
   }
 
   rtc::ScopedFakeClock fake_clock;
-  fake_clock.SetTime(Timestamp::ms(prng_.Rand<uint32_t>()));
+  fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
 
   for (auto direction : {kIncomingPacket, kOutgoingPacket}) {
     std::vector<rtcp::Fir> events(event_count_);
@@ -917,7 +917,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpFir) {
         history_.push_back(
             std::make_unique<RtcEventRtcpPacketOutgoing>(buffer));
       }
-      fake_clock.AdvanceTime(TimeDelta::ms(prng_.Rand(0, 1000)));
+      fake_clock.AdvanceTime(TimeDelta::Millis(prng_.Rand(0, 1000)));
     }
 
     std::string encoded =
@@ -939,7 +939,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPli) {
   }
 
   rtc::ScopedFakeClock fake_clock;
-  fake_clock.SetTime(Timestamp::ms(prng_.Rand<uint32_t>()));
+  fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
 
   for (auto direction : {kIncomingPacket, kOutgoingPacket}) {
     std::vector<rtcp::Pli> events(event_count_);
@@ -955,7 +955,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpPli) {
         history_.push_back(
             std::make_unique<RtcEventRtcpPacketOutgoing>(buffer));
       }
-      fake_clock.AdvanceTime(TimeDelta::ms(prng_.Rand(0, 1000)));
+      fake_clock.AdvanceTime(TimeDelta::Millis(prng_.Rand(0, 1000)));
     }
 
     std::string encoded =
@@ -977,7 +977,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpNack) {
   }
 
   rtc::ScopedFakeClock fake_clock;
-  fake_clock.SetTime(Timestamp::ms(prng_.Rand<uint32_t>()));
+  fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
 
   for (auto direction : {kIncomingPacket, kOutgoingPacket}) {
     std::vector<rtcp::Nack> events(event_count_);
@@ -993,7 +993,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpNack) {
         history_.push_back(
             std::make_unique<RtcEventRtcpPacketOutgoing>(buffer));
       }
-      fake_clock.AdvanceTime(TimeDelta::ms(prng_.Rand(0, 1000)));
+      fake_clock.AdvanceTime(TimeDelta::Millis(prng_.Rand(0, 1000)));
     }
 
     std::string encoded =
@@ -1015,7 +1015,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpRemb) {
   }
 
   rtc::ScopedFakeClock fake_clock;
-  fake_clock.SetTime(Timestamp::ms(prng_.Rand<uint32_t>()));
+  fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
 
   for (auto direction : {kIncomingPacket, kOutgoingPacket}) {
     std::vector<rtcp::Remb> events(event_count_);
@@ -1031,7 +1031,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpRemb) {
         history_.push_back(
             std::make_unique<RtcEventRtcpPacketOutgoing>(buffer));
       }
-      fake_clock.AdvanceTime(TimeDelta::ms(prng_.Rand(0, 1000)));
+      fake_clock.AdvanceTime(TimeDelta::Millis(prng_.Rand(0, 1000)));
     }
 
     std::string encoded =
@@ -1053,7 +1053,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpTransportFeedback) {
   }
 
   rtc::ScopedFakeClock fake_clock;
-  fake_clock.SetTime(Timestamp::ms(prng_.Rand<uint32_t>()));
+  fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
 
   for (auto direction : {kIncomingPacket, kOutgoingPacket}) {
     std::vector<rtcp::TransportFeedback> events;
@@ -1070,7 +1070,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpTransportFeedback) {
         history_.push_back(
             std::make_unique<RtcEventRtcpPacketOutgoing>(buffer));
       }
-      fake_clock.AdvanceTime(TimeDelta::ms(prng_.Rand(0, 1000)));
+      fake_clock.AdvanceTime(TimeDelta::Millis(prng_.Rand(0, 1000)));
     }
 
     std::string encoded =
@@ -1094,7 +1094,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpLossNotification) {
   }
 
   rtc::ScopedFakeClock fake_clock;
-  fake_clock.SetTime(Timestamp::ms(prng_.Rand<uint32_t>()));
+  fake_clock.SetTime(Timestamp::Millis(prng_.Rand<uint32_t>()));
 
   for (auto direction : {kIncomingPacket, kOutgoingPacket}) {
     std::vector<rtcp::LossNotification> events;
@@ -1111,7 +1111,7 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRtcpLossNotification) {
         history_.push_back(
             std::make_unique<RtcEventRtcpPacketOutgoing>(buffer));
       }
-      fake_clock.AdvanceTime(TimeDelta::ms(prng_.Rand(0, 1000)));
+      fake_clock.AdvanceTime(TimeDelta::Millis(prng_.Rand(0, 1000)));
     }
 
     std::string encoded =
diff --git a/logging/rtc_event_log/logged_events.cc b/logging/rtc_event_log/logged_events.cc
index c5b5a46fb1..3cba8bab21 100644
--- a/logging/rtc_event_log/logged_events.cc
+++ b/logging/rtc_event_log/logged_events.cc
@@ -31,7 +31,7 @@ LoggedPacketInfo::LoggedPacketInfo(const LoggedRtpPacket& rtp,
           has_transport_seq_no ? rtp.header.extension.transportSequenceNumber
                                : 0)),
       capture_time(capture_time),
-      log_packet_time(Timestamp::us(rtp.log_time_us())),
+      log_packet_time(Timestamp::Micros(rtp.log_time_us())),
       reported_send_time(rtp.header.extension.hasAbsoluteSendTime
                              ? rtp.header.extension.GetAbsoluteSendTimestamp()
                              : Timestamp::MinusInfinity()) {}
diff --git a/logging/rtc_event_log/rtc_event_log_parser.cc b/logging/rtc_event_log/rtc_event_log_parser.cc
index 9e0e6e5a50..6a8c64cd53 100644
--- a/logging/rtc_event_log/rtc_event_log_parser.cc
+++ b/logging/rtc_event_log/rtc_event_log_parser.cc
@@ -2034,7 +2034,7 @@ std::vector<InferredRouteChangeEvent> ParsedRtcEventLog::GetRouteChanges()
     if (candidate.type == IceCandidatePairConfigType::kSelected) {
       InferredRouteChangeEvent route;
       route.route_id = candidate.candidate_pair_id;
-      route.log_time = Timestamp::ms(candidate.log_time_ms());
+      route.log_time = Timestamp::Millis(candidate.log_time_ms());
 
       route.send_overhead = kUdpOverhead + kSrtpOverhead + kIpv4Overhead;
       if (candidate.remote_address_family ==
@@ -2083,7 +2083,7 @@ std::vector<LoggedPacketInfo> ParsedRtcEventLog::GetPacketInfos(
     // If we have a large time delta, it can be caused by a gap in logging,
     // therefore we don't want to match up sequence numbers as we might have had
     // a wraparound.
-    if (new_log_time - last_log_time > TimeDelta::seconds(30)) {
+    if (new_log_time - last_log_time > TimeDelta::Seconds(30)) {
       seq_num_unwrapper = SequenceNumberUnwrapper();
       indices.clear();
     }
@@ -2092,7 +2092,7 @@ std::vector<LoggedPacketInfo> ParsedRtcEventLog::GetPacketInfos(
   };
 
   auto rtp_handler = [&](const LoggedRtpPacket& rtp) {
-    advance_time(Timestamp::ms(rtp.log_time_ms()));
+    advance_time(Timestamp::Millis(rtp.log_time_ms()));
     MediaStreamInfo* stream = &streams[rtp.header.ssrc];
     Timestamp capture_time = Timestamp::MinusInfinity();
     if (!stream->rtx) {
@@ -2107,7 +2107,7 @@ std::vector<LoggedPacketInfo> ParsedRtcEventLog::GetPacketInfos(
           kStartingCaptureTimeTicks +
           stream->unwrap_capture_ticks.Unwrap(rtp.header.timestamp);
       // TODO(srte): Use logged sample rate when it is added to the format.
-      capture_time = Timestamp::seconds(
+      capture_time = Timestamp::Seconds(
           capture_ticks /
           (stream->media_type == LoggedMediaType::kAudio ? 48000.0 : 90000.0));
     }
@@ -2135,7 +2135,7 @@ std::vector<LoggedPacketInfo> ParsedRtcEventLog::GetPacketInfos(
 
   auto feedback_handler =
       [&](const LoggedRtcpPacketTransportFeedback& logged_rtcp) {
-        auto log_feedback_time = Timestamp::ms(logged_rtcp.log_time_ms());
+        auto log_feedback_time = Timestamp::Millis(logged_rtcp.log_time_ms());
         advance_time(log_feedback_time);
         const auto& feedback = logged_rtcp.transport_feedback;
         // Add timestamp deltas to a local time base selected on first packet
@@ -2144,7 +2144,7 @@ std::vector<LoggedPacketInfo> ParsedRtcEventLog::GetPacketInfos(
         if (!last_feedback_base_time_us) {
           feedback_base_time = log_feedback_time;
         } else {
-          feedback_base_time += TimeDelta::us(
+          feedback_base_time += TimeDelta::Micros(
               feedback.GetBaseDeltaUs(*last_feedback_base_time_us));
         }
         last_feedback_base_time_us = feedback.GetBaseTimeUs();
@@ -2163,15 +2163,16 @@ std::vector<LoggedPacketInfo> ParsedRtcEventLog::GetPacketInfos(
           }
           LoggedPacketInfo* sent = &packets[it->second];
           if (log_feedback_time - sent->log_packet_time >
-              TimeDelta::seconds(60)) {
+              TimeDelta::Seconds(60)) {
             RTC_LOG(LS_WARNING)
                 << "Received very late feedback, possibly due to wraparound.";
             continue;
           }
           if (packet.received()) {
-            receive_timestamp += TimeDelta::us(packet.delta_us());
+            receive_timestamp += TimeDelta::Micros(packet.delta_us());
             if (sent->reported_recv_time.IsInfinite()) {
-              sent->reported_recv_time = Timestamp::ms(receive_timestamp.ms());
+              sent->reported_recv_time =
+                  Timestamp::Millis(receive_timestamp.ms());
               sent->log_feedback_time = log_feedback_time;
             }
           } else {
@@ -2246,12 +2247,12 @@ std::vector<LoggedIceEvent> ParsedRtcEventLog::GetIceEvents() const {
   std::vector<LoggedIceEvent> log_events;
   auto handle_check = [&](const LoggedIceCandidatePairEvent& check) {
     log_events.push_back(LoggedIceEvent{check.candidate_pair_id,
-                                        Timestamp::ms(check.log_time_ms()),
+                                        Timestamp::Millis(check.log_time_ms()),
                                         check_map[check.type]});
   };
   auto handle_config = [&](const LoggedIceCandidatePairConfig& conf) {
     log_events.push_back(LoggedIceEvent{conf.candidate_pair_id,
-                                        Timestamp::ms(conf.log_time_ms()),
+                                        Timestamp::Millis(conf.log_time_ms()),
                                         config_map[conf.type]});
   };
   RtcEventProcessor process;
diff --git a/logging/rtc_event_log/rtc_event_log_unittest.cc b/logging/rtc_event_log/rtc_event_log_unittest.cc
index c05940202b..579c652880 100644
--- a/logging/rtc_event_log/rtc_event_log_unittest.cc
+++ b/logging/rtc_event_log/rtc_event_log_unittest.cc
@@ -113,7 +113,7 @@ class RtcEventLogSession
         encoding_type_(std::get<2>(GetParam())),
         gen_(seed_ * 880001UL),
         verifier_(encoding_type_) {
-    clock_.SetTime(Timestamp::us(prng_.Rand<uint32_t>()));
+    clock_.SetTime(Timestamp::Micros(prng_.Rand<uint32_t>()));
     // Find the name of the current test, in order to use it as a temporary
     // filename.
     // TODO(terelius): Use a general utility function to generate a temp file.
@@ -217,7 +217,7 @@ void RtcEventLogSession::WriteAudioRecvConfigs(size_t audio_recv_streams,
   RTC_CHECK(event_log != nullptr);
   uint32_t ssrc;
   for (size_t i = 0; i < audio_recv_streams; i++) {
-    clock_.AdvanceTime(TimeDelta::ms(prng_.Rand(20)));
+    clock_.AdvanceTime(TimeDelta::Millis(prng_.Rand(20)));
     do {
       ssrc = prng_.Rand<uint32_t>();
     } while (SsrcUsed(ssrc, incoming_extensions_));
@@ -234,7 +234,7 @@ void RtcEventLogSession::WriteAudioSendConfigs(size_t audio_send_streams,
   RTC_CHECK(event_log != nullptr);
   uint32_t ssrc;
   for (size_t i = 0; i < audio_send_streams; i++) {
-    clock_.AdvanceTime(TimeDelta::ms(prng_.Rand(20)));
+    clock_.AdvanceTime(TimeDelta::Millis(prng_.Rand(20)));
     do {
       ssrc = prng_.Rand<uint32_t>();
     } while (SsrcUsed(ssrc, outgoing_extensions_));
@@ -256,14 +256,14 @@ void RtcEventLogSession::WriteVideoRecvConfigs(size_t video_recv_streams,
   RtpHeaderExtensionMap all_extensions =
       ParsedRtcEventLog::GetDefaultHeaderExtensionMap();
 
-  clock_.AdvanceTime(TimeDelta::ms(prng_.Rand(20)));
+  clock_.AdvanceTime(TimeDelta::Millis(prng_.Rand(20)));
   uint32_t ssrc = prng_.Rand<uint32_t>();
   incoming_extensions_.emplace_back(ssrc, all_extensions);
   auto event = gen_.NewVideoReceiveStreamConfig(ssrc, all_extensions);
   event_log->Log(event->Copy());
   video_recv_config_list_.push_back(std::move(event));
   for (size_t i = 1; i < video_recv_streams; i++) {
-    clock_.AdvanceTime(TimeDelta::ms(prng_.Rand(20)));
+    clock_.AdvanceTime(TimeDelta::Millis(prng_.Rand(20)));
     do {
       ssrc = prng_.Rand<uint32_t>();
     } while (SsrcUsed(ssrc, incoming_extensions_));
@@ -285,14 +285,14 @@ void RtcEventLogSession::WriteVideoSendConfigs(size_t video_send_streams,
   RtpHeaderExtensionMap all_extensions =
       ParsedRtcEventLog::GetDefaultHeaderExtensionMap();
 
-  clock_.AdvanceTime(TimeDelta::ms(prng_.Rand(20)));
+  clock_.AdvanceTime(TimeDelta::Millis(prng_.Rand(20)));
   uint32_t ssrc = prng_.Rand<uint32_t>();
   outgoing_extensions_.emplace_back(ssrc, all_extensions);
   auto event = gen_.NewVideoSendStreamConfig(ssrc, all_extensions);
   event_log->Log(event->Copy());
   video_send_config_list_.push_back(std::move(event));
   for (size_t i = 1; i < video_send_streams; i++) {
-    clock_.AdvanceTime(TimeDelta::ms(prng_.Rand(20)));
+    clock_.AdvanceTime(TimeDelta::Millis(prng_.Rand(20)));
     do {
       ssrc = prng_.Rand<uint32_t>();
     } while (SsrcUsed(ssrc, outgoing_extensions_));
@@ -329,7 +329,7 @@ void RtcEventLogSession::WriteLog(EventCounts count,
   size_t remaining_events_at_start = remaining_events - num_events_before_start;
   for (; remaining_events > 0; remaining_events--) {
     if (remaining_events == remaining_events_at_start) {
-      clock_.AdvanceTime(TimeDelta::ms(prng_.Rand(20)));
+      clock_.AdvanceTime(TimeDelta::Millis(prng_.Rand(20)));
       event_log->StartLogging(
           std::make_unique<RtcEventLogOutputFile>(temp_filename_, 10000000),
           output_period_ms_);
@@ -337,7 +337,7 @@ void RtcEventLogSession::WriteLog(EventCounts count,
       utc_start_time_us_ = rtc::TimeUTCMicros();
     }
 
-    clock_.AdvanceTime(TimeDelta::ms(prng_.Rand(20)));
+    clock_.AdvanceTime(TimeDelta::Millis(prng_.Rand(20)));
     size_t selection = prng_.Rand(remaining_events - 1);
     first_timestamp_ms_ = std::min(first_timestamp_ms_, rtc::TimeMillis());
     last_timestamp_ms_ = std::max(last_timestamp_ms_, rtc::TimeMillis());
@@ -844,7 +844,7 @@ TEST_P(RtcEventLogCircularBufferTest, KeepsMostRecentEvents) {
 
   std::unique_ptr<rtc::ScopedFakeClock> fake_clock =
       std::make_unique<rtc::ScopedFakeClock>();
-  fake_clock->SetTime(Timestamp::seconds(kStartTimeSeconds));
+  fake_clock->SetTime(Timestamp::Seconds(kStartTimeSeconds));
 
   auto task_queue_factory = CreateDefaultTaskQueueFactory();
   RtcEventLogFactory rtc_event_log_factory(task_queue_factory.get());
@@ -862,14 +862,14 @@ TEST_P(RtcEventLogCircularBufferTest, KeepsMostRecentEvents) {
     // consistency checks when we read back.
     log_dumper->Log(std::make_unique<RtcEventProbeResultSuccess>(
         i, kStartBitrate + i * 1000));
-    fake_clock->AdvanceTime(TimeDelta::ms(10));
+    fake_clock->AdvanceTime(TimeDelta::Millis(10));
   }
   int64_t start_time_us = rtc::TimeMicros();
   int64_t utc_start_time_us = rtc::TimeUTCMicros();
   log_dumper->StartLogging(
       std::make_unique<RtcEventLogOutputFile>(temp_filename, 10000000),
       RtcEventLog::kImmediateOutput);
-  fake_clock->AdvanceTime(TimeDelta::ms(10));
+  fake_clock->AdvanceTime(TimeDelta::Millis(10));
   int64_t stop_time_us = rtc::TimeMicros();
   log_dumper->StopLogging();
 
@@ -902,9 +902,9 @@ TEST_P(RtcEventLogCircularBufferTest, KeepsMostRecentEvents) {
   // destroyed before the new one is created, so we have to reset() first.
   fake_clock.reset();
   fake_clock = std::make_unique<rtc::ScopedFakeClock>();
-  fake_clock->SetTime(Timestamp::us(first_timestamp_us));
+  fake_clock->SetTime(Timestamp::Micros(first_timestamp_us));
   for (size_t i = 1; i < probe_success_events.size(); i++) {
-    fake_clock->AdvanceTime(TimeDelta::ms(10));
+    fake_clock->AdvanceTime(TimeDelta::Millis(10));
     verifier_.VerifyLoggedBweProbeSuccessEvent(
         RtcEventProbeResultSuccess(first_id + i, first_bitrate_bps + i * 1000),
         probe_success_events[i]);