diff --git a/modules/rtp_rtcp/source/deprecated/deprecated_rtp_sender_egress.cc b/modules/rtp_rtcp/source/deprecated/deprecated_rtp_sender_egress.cc
index 9cef33165c..db6b50a449 100644
--- a/modules/rtp_rtcp/source/deprecated/deprecated_rtp_sender_egress.cc
+++ b/modules/rtp_rtcp/source/deprecated/deprecated_rtp_sender_egress.cc
@@ -201,7 +201,7 @@ void DEPRECATED_RtpSenderEgress::SendPacket(
   // actual sending fails.
   if (is_media && packet->allow_retransmission()) {
     packet_history_->PutRtpPacket(std::make_unique<RtpPacketToSend>(*packet),
-                                  now_ms);
+                                  Timestamp::Millis(now_ms));
   } else if (packet->retransmitted_sequence_number()) {
     packet_history_->MarkPacketAsSent(*packet->retransmitted_sequence_number());
   }
diff --git a/modules/rtp_rtcp/source/rtp_packet_history.cc b/modules/rtp_rtcp/source/rtp_packet_history.cc
index eda3ecdee5..c8d400a985 100644
--- a/modules/rtp_rtcp/source/rtp_packet_history.cc
+++ b/modules/rtp_rtcp/source/rtp_packet_history.cc
@@ -23,19 +23,13 @@
 
 namespace webrtc {
 
-constexpr size_t RtpPacketHistory::kMaxCapacity;
-constexpr size_t RtpPacketHistory::kMaxPaddingHistory;
-constexpr int64_t RtpPacketHistory::kMinPacketDurationMs;
-constexpr int RtpPacketHistory::kMinPacketDurationRtt;
-constexpr int RtpPacketHistory::kPacketCullingDelayFactor;
-
 RtpPacketHistory::StoredPacket::StoredPacket(
     std::unique_ptr<RtpPacketToSend> packet,
-    int64_t send_time_ms,
+    Timestamp send_time,
     uint64_t insert_order)
-    : send_time_ms_(send_time_ms),
-      packet_(std::move(packet)),
+    : packet_(std::move(packet)),
       pending_transmission_(false),
+      send_time_(send_time),
       insert_order_(insert_order),
       times_retransmitted_(0) {}
 
@@ -78,7 +72,7 @@ RtpPacketHistory::RtpPacketHistory(Clock* clock, bool enable_padding_prio)
       enable_padding_prio_(enable_padding_prio),
       number_to_store_(0),
       mode_(StorageMode::kDisabled),
-      rtt_ms_(-1),
+      rtt_(TimeDelta::MinusInfinity()),
       packets_inserted_(0) {}
 
 RtpPacketHistory::~RtpPacketHistory() {}
@@ -100,29 +94,28 @@ RtpPacketHistory::StorageMode RtpPacketHistory::GetStorageMode() const {
   return mode_;
 }
 
-void RtpPacketHistory::SetRtt(int64_t rtt_ms) {
+void RtpPacketHistory::SetRtt(TimeDelta rtt) {
   MutexLock lock(&lock_);
-  RTC_DCHECK_GE(rtt_ms, 0);
-  rtt_ms_ = rtt_ms;
+  RTC_DCHECK_GE(rtt, TimeDelta::Zero());
+  rtt_ = rtt;
   // If storage is not disabled,  packets will be removed after a timeout
   // that depends on the RTT. Changing the RTT may thus cause some packets
   // become "old" and subject to removal.
   if (mode_ != StorageMode::kDisabled) {
-    CullOldPackets(clock_->TimeInMilliseconds());
+    CullOldPackets();
   }
 }
 
 void RtpPacketHistory::PutRtpPacket(std::unique_ptr<RtpPacketToSend> packet,
-                                    int64_t send_time_ms) {
+                                    Timestamp send_time) {
   RTC_DCHECK(packet);
   MutexLock lock(&lock_);
-  int64_t now_ms = clock_->TimeInMilliseconds();
   if (mode_ == StorageMode::kDisabled) {
     return;
   }
 
   RTC_DCHECK(packet->allow_retransmission());
-  CullOldPackets(now_ms);
+  CullOldPackets();
 
   // Store packet.
   const uint16_t rtp_seq_no = packet->SequenceNumber();
@@ -150,7 +143,7 @@ void RtpPacketHistory::PutRtpPacket(std::unique_ptr<RtpPacketToSend> packet,
   RTC_DCHECK(packet_history_[packet_index].packet_ == nullptr);
 
   packet_history_[packet_index] =
-      StoredPacket(std::move(packet), send_time_ms, packets_inserted_++);
+      StoredPacket(std::move(packet), send_time, packets_inserted_++);
 
   if (enable_padding_prio_) {
     if (padding_priority_.size() >= kMaxPaddingHistory - 1) {
@@ -188,7 +181,7 @@ std::unique_ptr<RtpPacketToSend> RtpPacketHistory::GetPacketAndMarkAsPending(
     return nullptr;
   }
 
-  if (!VerifyRtt(*packet, clock_->TimeInMilliseconds())) {
+  if (!VerifyRtt(*packet)) {
     // Packet already resent within too short a time window, ignore.
     return nullptr;
   }
@@ -216,7 +209,7 @@ void RtpPacketHistory::MarkPacketAsSent(uint16_t sequence_number) {
 
   // Update send-time, mark as no longer in pacer queue, and increment
   // transmission count.
-  packet->send_time_ms_ = clock_->TimeInMilliseconds();
+  packet->set_send_time(clock_->CurrentTime());
   packet->pending_transmission_ = false;
   packet->IncrementTimesRetransmitted(enable_padding_prio_ ? &padding_priority_
                                                            : nullptr);
@@ -238,17 +231,17 @@ bool RtpPacketHistory::GetPacketState(uint16_t sequence_number) const {
     return false;
   }
 
-  if (!VerifyRtt(packet, clock_->TimeInMilliseconds())) {
+  if (!VerifyRtt(packet)) {
     return false;
   }
 
   return true;
 }
 
-bool RtpPacketHistory::VerifyRtt(const RtpPacketHistory::StoredPacket& packet,
-                                 int64_t now_ms) const {
+bool RtpPacketHistory::VerifyRtt(
+    const RtpPacketHistory::StoredPacket& packet) const {
   if (packet.times_retransmitted() > 0 &&
-      now_ms < packet.send_time_ms_ + rtt_ms_) {
+      clock_->CurrentTime() - packet.send_time() < rtt_) {
     // This packet has already been retransmitted once, and the time since
     // that even is lower than on RTT. Ignore request as this packet is
     // likely already in the network pipe.
@@ -305,7 +298,7 @@ std::unique_ptr<RtpPacketToSend> RtpPacketHistory::GetPayloadPaddingPacket(
     return nullptr;
   }
 
-  best_packet->send_time_ms_ = clock_->TimeInMilliseconds();
+  best_packet->set_send_time(clock_->CurrentTime());
   best_packet->IncrementTimesRetransmitted(
       enable_padding_prio_ ? &padding_priority_ : nullptr);
 
@@ -335,9 +328,12 @@ void RtpPacketHistory::Reset() {
   padding_priority_.clear();
 }
 
-void RtpPacketHistory::CullOldPackets(int64_t now_ms) {
-  int64_t packet_duration_ms =
-      std::max(kMinPacketDurationRtt * rtt_ms_, kMinPacketDurationMs);
+void RtpPacketHistory::CullOldPackets() {
+  Timestamp now = clock_->CurrentTime();
+  TimeDelta packet_duration =
+      rtt_.IsFinite()
+          ? std::max(kMinPacketDurationRtt * rtt_, kMinPacketDuration)
+          : kMinPacketDuration;
   while (!packet_history_.empty()) {
     if (packet_history_.size() >= kMaxCapacity) {
       // We have reached the absolute max capacity, remove one packet
@@ -352,15 +348,15 @@ void RtpPacketHistory::CullOldPackets(int64_t now_ms) {
       return;
     }
 
-    if (stored_packet.send_time_ms_ + packet_duration_ms > now_ms) {
+    if (stored_packet.send_time() + packet_duration > now) {
       // Don't cull packets too early to avoid failed retransmission requests.
       return;
     }
 
     if (packet_history_.size() >= number_to_store_ ||
-        stored_packet.send_time_ms_ +
-                (packet_duration_ms * kPacketCullingDelayFactor) <=
-            now_ms) {
+        stored_packet.send_time() +
+                (packet_duration * kPacketCullingDelayFactor) <=
+            now) {
       // Too many packets in history, or this packet has timed out. Remove it
       // and continue.
       RemovePacket(0);
diff --git a/modules/rtp_rtcp/source/rtp_packet_history.h b/modules/rtp_rtcp/source/rtp_packet_history.h
index 18cef0aa13..390fd98e08 100644
--- a/modules/rtp_rtcp/source/rtp_packet_history.h
+++ b/modules/rtp_rtcp/source/rtp_packet_history.h
@@ -15,9 +15,13 @@
 #include <map>
 #include <memory>
 #include <set>
+#include <utility>
 #include <vector>
 
+#include "absl/base/attributes.h"
 #include "api/function_view.h"
+#include "api/units/time_delta.h"
+#include "api/units/timestamp.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/thread_annotations.h"
@@ -39,8 +43,8 @@ class RtpPacketHistory {
   static constexpr size_t kMaxCapacity = 9600;
   // Maximum number of entries in prioritized queue of padding packets.
   static constexpr size_t kMaxPaddingHistory = 63;
-  // Don't remove packets within max(1000ms, 3x RTT).
-  static constexpr int64_t kMinPacketDurationMs = 1000;
+  // Don't remove packets within max(1 second, 3x RTT).
+  static constexpr TimeDelta kMinPacketDuration = TimeDelta::Seconds(1);
   static constexpr int kMinPacketDurationRtt = 3;
   // With kStoreAndCull, always remove packets after 3x max(1000ms, 3x rtt).
   static constexpr int kPacketCullingDelayFactor = 3;
@@ -60,10 +64,19 @@ class RtpPacketHistory {
 
   // Set RTT, used to avoid premature retransmission and to prevent over-writing
   // a packet in the history before we are reasonably sure it has been received.
-  void SetRtt(int64_t rtt_ms);
+  ABSL_DEPRECATED("Use SetRtt below that takes TimeDelta")
+  void SetRtt(int64_t rtt_ms) { SetRtt(TimeDelta::Millis(rtt_ms)); }
+
+  void SetRtt(TimeDelta rtt);
+
+  ABSL_DEPRECATED("Use PutRtpPacket below that take Timestamp")
+  void PutRtpPacket(std::unique_ptr<RtpPacketToSend> packet,
+                    int64_t send_time_ms) {
+    PutRtpPacket(std::move(packet), Timestamp::Millis(send_time_ms));
+  }
 
   void PutRtpPacket(std::unique_ptr<RtpPacketToSend> packet,
-                    int64_t send_time_ms);
+                    Timestamp send_time);
 
   // Gets stored RTP packet corresponding to the input |sequence number|.
   // Returns nullptr if packet is not found or was (re)sent too recently.
@@ -120,7 +133,7 @@ class RtpPacketHistory {
    public:
     StoredPacket() = default;
     StoredPacket(std::unique_ptr<RtpPacketToSend> packet,
-                 int64_t send_time_ms,
+                 Timestamp send_time,
                  uint64_t insert_order);
     StoredPacket(StoredPacket&&);
     StoredPacket& operator=(StoredPacket&&);
@@ -131,7 +144,8 @@ class RtpPacketHistory {
     void IncrementTimesRetransmitted(PacketPrioritySet* priority_set);
 
     // The time of last transmission, including retransmissions.
-    int64_t send_time_ms_;
+    Timestamp send_time() const { return send_time_; }
+    void set_send_time(Timestamp value) { send_time_ = value; }
 
     // The actual packet.
     std::unique_ptr<RtpPacketToSend> packet_;
@@ -140,6 +154,8 @@ class RtpPacketHistory {
     bool pending_transmission_;
 
    private:
+    Timestamp send_time_ = Timestamp::Zero();
+
     // Unique number per StoredPacket, incremented by one for each added
     // packet. Used to sort on insert order.
     uint64_t insert_order_;
@@ -152,10 +168,10 @@ class RtpPacketHistory {
   };
 
   // Helper method to check if packet has too recently been sent.
-  bool VerifyRtt(const StoredPacket& packet, int64_t now_ms) const
+  bool VerifyRtt(const StoredPacket& packet) const
       RTC_EXCLUSIVE_LOCKS_REQUIRED(lock_);
   void Reset() RTC_EXCLUSIVE_LOCKS_REQUIRED(lock_);
-  void CullOldPackets(int64_t now_ms) RTC_EXCLUSIVE_LOCKS_REQUIRED(lock_);
+  void CullOldPackets() RTC_EXCLUSIVE_LOCKS_REQUIRED(lock_);
   // Removes the packet from the history, and context/mapping that has been
   // stored. Returns the RTP packet instance contained within the StoredPacket.
   std::unique_ptr<RtpPacketToSend> RemovePacket(int packet_index)
@@ -170,7 +186,7 @@ class RtpPacketHistory {
   mutable Mutex lock_;
   size_t number_to_store_ RTC_GUARDED_BY(lock_);
   StorageMode mode_ RTC_GUARDED_BY(lock_);
-  int64_t rtt_ms_ RTC_GUARDED_BY(lock_);
+  TimeDelta rtt_ RTC_GUARDED_BY(lock_);
 
   // Queue of stored packets, ordered by sequence number, with older packets in
   // the front and new packets being added to the back. Note that there may be
diff --git a/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc b/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
index ffe167c5f6..f50541849e 100644
--- a/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
@@ -64,7 +64,7 @@ TEST_P(RtpPacketHistoryTest, SetStoreStatus) {
 TEST_P(RtpPacketHistoryTest, ClearsHistoryAfterSetStoreStatus) {
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 10);
   hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum),
-                     fake_clock_.TimeInMilliseconds());
+                     /*send_time=*/fake_clock_.CurrentTime());
   EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
 
   // Changing store status, even to the current one, will clear the history.
@@ -75,7 +75,7 @@ TEST_P(RtpPacketHistoryTest, ClearsHistoryAfterSetStoreStatus) {
 TEST_P(RtpPacketHistoryTest, StartSeqResetAfterReset) {
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 10);
   hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum),
-                     fake_clock_.TimeInMilliseconds());
+                     /*send_time=*/fake_clock_.CurrentTime());
   // Mark packet as pending so it won't be removed.
   EXPECT_TRUE(hist_.GetPacketAndMarkAsPending(kStartSeqNum));
 
@@ -85,17 +85,16 @@ TEST_P(RtpPacketHistoryTest, StartSeqResetAfterReset) {
 
   // Add a new packet.
   hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + 1)),
-                     fake_clock_.TimeInMilliseconds());
+                     /*send_time=*/fake_clock_.CurrentTime());
   EXPECT_TRUE(hist_.GetPacketAndMarkAsPending(To16u(kStartSeqNum + 1)));
 
   // Advance time past where packet expires.
-  fake_clock_.AdvanceTimeMilliseconds(
-      RtpPacketHistory::kPacketCullingDelayFactor *
-      RtpPacketHistory::kMinPacketDurationMs);
+  fake_clock_.AdvanceTime(RtpPacketHistory::kPacketCullingDelayFactor *
+                          RtpPacketHistory::kMinPacketDuration);
 
   // Add one more packet and verify no state left from packet before reset.
   hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + 2)),
-                     fake_clock_.TimeInMilliseconds());
+                     /*send_time=*/fake_clock_.CurrentTime());
   EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
   EXPECT_TRUE(hist_.GetPacketState(To16u(kStartSeqNum + 1)));
   EXPECT_TRUE(hist_.GetPacketState(To16u(kStartSeqNum + 2)));
@@ -104,7 +103,8 @@ TEST_P(RtpPacketHistoryTest, StartSeqResetAfterReset) {
 TEST_P(RtpPacketHistoryTest, NoStoreStatus) {
   EXPECT_EQ(StorageMode::kDisabled, hist_.GetStorageMode());
   std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum);
-  hist_.PutRtpPacket(std::move(packet), fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(std::move(packet),
+                     /*send_time=*/fake_clock_.CurrentTime());
   // Packet should not be stored.
   EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
 }
@@ -119,7 +119,8 @@ TEST_P(RtpPacketHistoryTest, PutRtpPacket) {
   std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum);
 
   EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
-  hist_.PutRtpPacket(std::move(packet), fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(std::move(packet),
+                     /*send_time=*/fake_clock_.CurrentTime());
   EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
 }
 
@@ -129,7 +130,8 @@ TEST_P(RtpPacketHistoryTest, GetRtpPacket) {
   std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum);
   packet->set_capture_time(capture_time);
   rtc::CopyOnWriteBuffer buffer = packet->Buffer();
-  hist_.PutRtpPacket(std::move(packet), fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(std::move(packet),
+                     /*send_time=*/fake_clock_.CurrentTime());
 
   std::unique_ptr<RtpPacketToSend> packet_out =
       hist_.GetPacketAndMarkAsPending(kStartSeqNum);
@@ -139,14 +141,14 @@ TEST_P(RtpPacketHistoryTest, GetRtpPacket) {
 }
 
 TEST_P(RtpPacketHistoryTest, MinResendTime) {
-  static const int64_t kMinRetransmitIntervalMs = 100;
+  static const TimeDelta kMinRetransmitInterval = TimeDelta::Millis(100);
 
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 10);
-  hist_.SetRtt(kMinRetransmitIntervalMs);
+  hist_.SetRtt(kMinRetransmitInterval);
   Timestamp capture_time = fake_clock_.CurrentTime();
   std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum);
   size_t len = packet->size();
-  hist_.PutRtpPacket(std::move(packet), fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(std::move(packet), fake_clock_.CurrentTime());
 
   // First retransmission - allow early retransmission.
   fake_clock_.AdvanceTimeMilliseconds(1);
@@ -157,7 +159,7 @@ TEST_P(RtpPacketHistoryTest, MinResendTime) {
   hist_.MarkPacketAsSent(kStartSeqNum);
 
   // Second retransmission - advance time to just before retransmission OK.
-  fake_clock_.AdvanceTimeMilliseconds(kMinRetransmitIntervalMs - 1);
+  fake_clock_.AdvanceTime(kMinRetransmitInterval - TimeDelta::Millis(1));
   EXPECT_FALSE(hist_.GetPacketAndMarkAsPending(kStartSeqNum));
 
   // Advance time to just after retransmission OK.
@@ -169,18 +171,18 @@ TEST_P(RtpPacketHistoryTest, RemovesOldestSentPacketWhenAtMaxSize) {
   const size_t kMaxNumPackets = 10;
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, kMaxNumPackets);
 
-  // History does not allow removing packets within kMinPacketDurationMs,
+  // History does not allow removing packets within kMinPacketDuration,
   // so in order to test capacity, make sure insertion spans this time.
-  const int64_t kPacketIntervalMs =
-      RtpPacketHistory::kMinPacketDurationMs / kMaxNumPackets;
+  const TimeDelta kPacketInterval =
+      RtpPacketHistory::kMinPacketDuration / kMaxNumPackets;
 
   // Add packets until the buffer is full.
   for (size_t i = 0; i < kMaxNumPackets; ++i) {
     std::unique_ptr<RtpPacketToSend> packet =
         CreateRtpPacket(To16u(kStartSeqNum + i));
     // Immediate mark packet as sent.
-    hist_.PutRtpPacket(std::move(packet), fake_clock_.TimeInMilliseconds());
-    fake_clock_.AdvanceTimeMilliseconds(kPacketIntervalMs);
+    hist_.PutRtpPacket(std::move(packet), fake_clock_.CurrentTime());
+    fake_clock_.AdvanceTime(kPacketInterval);
   }
 
   // First packet should still be there.
@@ -189,7 +191,7 @@ TEST_P(RtpPacketHistoryTest, RemovesOldestSentPacketWhenAtMaxSize) {
   // History is full, oldest one should be overwritten.
   std::unique_ptr<RtpPacketToSend> packet =
       CreateRtpPacket(To16u(kStartSeqNum + kMaxNumPackets));
-  hist_.PutRtpPacket(std::move(packet), fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(std::move(packet), fake_clock_.CurrentTime());
 
   // Oldest packet should be gone, but packet after than one still present.
   EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
@@ -207,7 +209,8 @@ TEST_P(RtpPacketHistoryTest, RemovesOldestPacketWhenAtMaxCapacity) {
   for (size_t i = 0; i < kMaxNumPackets; ++i) {
     std::unique_ptr<RtpPacketToSend> packet =
         CreateRtpPacket(To16u(kStartSeqNum + i));
-    hist_.PutRtpPacket(std::move(packet), fake_clock_.TimeInMilliseconds());
+    hist_.PutRtpPacket(std::move(packet),
+                       /*send_time=*/fake_clock_.CurrentTime());
     // Mark packets as pending, preventing it from being removed.
     hist_.GetPacketAndMarkAsPending(To16u(kStartSeqNum + i));
   }
@@ -218,7 +221,7 @@ TEST_P(RtpPacketHistoryTest, RemovesOldestPacketWhenAtMaxCapacity) {
   // History is full, oldest one should be overwritten.
   std::unique_ptr<RtpPacketToSend> packet =
       CreateRtpPacket(To16u(kStartSeqNum + kMaxNumPackets));
-  hist_.PutRtpPacket(std::move(packet), fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(std::move(packet), fake_clock_.CurrentTime());
 
   // Oldest packet should be gone, but packet after than one still present.
   EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
@@ -235,14 +238,14 @@ TEST_P(RtpPacketHistoryTest, RemovesLowestPrioPaddingWhenAtMaxCapacity) {
   // set of potential padding packets.
   const size_t kMaxNumPackets = RtpPacketHistory::kMaxPaddingHistory;
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, kMaxNumPackets * 2);
-  hist_.SetRtt(1);
+  hist_.SetRtt(TimeDelta::Millis(1));
 
   // Add packets until the max is reached, and then yet another one.
   for (size_t i = 0; i < kMaxNumPackets + 1; ++i) {
     std::unique_ptr<RtpPacketToSend> packet =
         CreateRtpPacket(To16u(kStartSeqNum + i));
     // Don't mark packets as sent, preventing them from being removed.
-    hist_.PutRtpPacket(std::move(packet), fake_clock_.TimeInMilliseconds());
+    hist_.PutRtpPacket(std::move(packet), fake_clock_.CurrentTime());
   }
 
   // Advance time to allow retransmission/padding.
@@ -267,50 +270,48 @@ TEST_P(RtpPacketHistoryTest, DontRemoveTooRecentlyTransmittedPackets) {
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 1);
 
   // Add a packet, marked as send, and advance time to just before removal time.
-  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum),
-                     fake_clock_.TimeInMilliseconds());
-  fake_clock_.AdvanceTimeMilliseconds(RtpPacketHistory::kMinPacketDurationMs -
-                                      1);
+  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum), fake_clock_.CurrentTime());
+  fake_clock_.AdvanceTime(RtpPacketHistory::kMinPacketDuration -
+                          TimeDelta::Millis(1));
 
   // Add a new packet to trigger culling.
   hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + 1)),
-                     fake_clock_.TimeInMilliseconds());
+                     fake_clock_.CurrentTime());
   // First packet should still be there.
   EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
 
   // Advance time to where packet will be eligible for removal and try again.
   fake_clock_.AdvanceTimeMilliseconds(1);
   hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + 2)),
-                     fake_clock_.TimeInMilliseconds());
+                     fake_clock_.CurrentTime());
   // First packet should no be gone, but next one still there.
   EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
   EXPECT_TRUE(hist_.GetPacketState(To16u(kStartSeqNum + 1)));
 }
 
 TEST_P(RtpPacketHistoryTest, DontRemoveTooRecentlyTransmittedPacketsHighRtt) {
-  const int64_t kRttMs = RtpPacketHistory::kMinPacketDurationMs * 2;
-  const int64_t kPacketTimeoutMs =
-      kRttMs * RtpPacketHistory::kMinPacketDurationRtt;
+  const TimeDelta kRtt = RtpPacketHistory::kMinPacketDuration * 2;
+  const TimeDelta kPacketTimeout =
+      kRtt * RtpPacketHistory::kMinPacketDurationRtt;
 
   // Set size to remove old packets as soon as possible.
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 1);
-  hist_.SetRtt(kRttMs);
+  hist_.SetRtt(kRtt);
 
   // Add a packet, marked as send, and advance time to just before removal time.
-  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum),
-                     fake_clock_.TimeInMilliseconds());
-  fake_clock_.AdvanceTimeMilliseconds(kPacketTimeoutMs - 1);
+  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum), fake_clock_.CurrentTime());
+  fake_clock_.AdvanceTime(kPacketTimeout - TimeDelta::Millis(1));
 
   // Add a new packet to trigger culling.
   hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + 1)),
-                     fake_clock_.TimeInMilliseconds());
+                     fake_clock_.CurrentTime());
   // First packet should still be there.
   EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
 
   // Advance time to where packet will be eligible for removal and try again.
   fake_clock_.AdvanceTimeMilliseconds(1);
   hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + 2)),
-                     fake_clock_.TimeInMilliseconds());
+                     fake_clock_.CurrentTime());
   // First packet should no be gone, but next one still there.
   EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
   EXPECT_TRUE(hist_.GetPacketState(To16u(kStartSeqNum + 1)));
@@ -321,12 +322,11 @@ TEST_P(RtpPacketHistoryTest, RemovesOldWithCulling) {
   // Enable culling. Even without feedback, this can trigger early removal.
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, kMaxNumPackets);
 
-  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum),
-                     fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum), fake_clock_.CurrentTime());
 
-  int64_t kMaxPacketDurationMs = RtpPacketHistory::kMinPacketDurationMs *
+  TimeDelta kMaxPacketDuration = RtpPacketHistory::kMinPacketDuration *
                                  RtpPacketHistory::kPacketCullingDelayFactor;
-  fake_clock_.AdvanceTimeMilliseconds(kMaxPacketDurationMs - 1);
+  fake_clock_.AdvanceTime(kMaxPacketDuration - TimeDelta::Millis(1));
 
   // First packet should still be there.
   EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
@@ -334,25 +334,24 @@ TEST_P(RtpPacketHistoryTest, RemovesOldWithCulling) {
   // Advance to where packet can be culled, even if buffer is not full.
   fake_clock_.AdvanceTimeMilliseconds(1);
   hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + 1)),
-                     fake_clock_.TimeInMilliseconds());
+                     fake_clock_.CurrentTime());
 
   EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
 }
 
 TEST_P(RtpPacketHistoryTest, RemovesOldWithCullingHighRtt) {
   const size_t kMaxNumPackets = 10;
-  const int64_t kRttMs = RtpPacketHistory::kMinPacketDurationMs * 2;
+  const TimeDelta kRtt = RtpPacketHistory::kMinPacketDuration * 2;
   // Enable culling. Even without feedback, this can trigger early removal.
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, kMaxNumPackets);
-  hist_.SetRtt(kRttMs);
+  hist_.SetRtt(kRtt);
 
-  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum),
-                     fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum), fake_clock_.CurrentTime());
 
-  int64_t kMaxPacketDurationMs = kRttMs *
+  TimeDelta kMaxPacketDuration = kRtt *
                                  RtpPacketHistory::kMinPacketDurationRtt *
                                  RtpPacketHistory::kPacketCullingDelayFactor;
-  fake_clock_.AdvanceTimeMilliseconds(kMaxPacketDurationMs - 1);
+  fake_clock_.AdvanceTime(kMaxPacketDuration - TimeDelta::Millis(1));
 
   // First packet should still be there.
   EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
@@ -360,30 +359,33 @@ TEST_P(RtpPacketHistoryTest, RemovesOldWithCullingHighRtt) {
   // Advance to where packet can be culled, even if buffer is not full.
   fake_clock_.AdvanceTimeMilliseconds(1);
   hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + 1)),
-                     fake_clock_.TimeInMilliseconds());
+                     fake_clock_.CurrentTime());
 
   EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
 }
 
 TEST_P(RtpPacketHistoryTest, CullWithAcks) {
-  const int64_t kPacketLifetime = RtpPacketHistory::kMinPacketDurationMs *
-                                  RtpPacketHistory::kPacketCullingDelayFactor;
+  const TimeDelta kPacketLifetime = RtpPacketHistory::kMinPacketDuration *
+                                    RtpPacketHistory::kPacketCullingDelayFactor;
 
-  const int64_t start_time = fake_clock_.TimeInMilliseconds();
+  const Timestamp start_time = fake_clock_.CurrentTime();
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 10);
 
   // Insert three packets 33ms apart, immediately mark them as sent.
   std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum);
   packet->SetPayloadSize(50);
-  hist_.PutRtpPacket(std::move(packet), fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(std::move(packet),
+                     /*send_time=*/fake_clock_.CurrentTime());
   fake_clock_.AdvanceTimeMilliseconds(33);
   packet = CreateRtpPacket(To16u(kStartSeqNum + 1));
   packet->SetPayloadSize(50);
-  hist_.PutRtpPacket(std::move(packet), fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(std::move(packet),
+                     /*send_time=*/fake_clock_.CurrentTime());
   fake_clock_.AdvanceTimeMilliseconds(33);
   packet = CreateRtpPacket(To16u(kStartSeqNum + 2));
   packet->SetPayloadSize(50);
-  hist_.PutRtpPacket(std::move(packet), fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(std::move(packet),
+                     /*send_time=*/fake_clock_.CurrentTime());
 
   EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
   EXPECT_TRUE(hist_.GetPacketState(To16u(kStartSeqNum + 1)));
@@ -399,38 +401,38 @@ TEST_P(RtpPacketHistoryTest, CullWithAcks) {
 
   // Advance time to where second packet would have expired, verify first packet
   // is removed.
-  int64_t second_packet_expiry_time = start_time + kPacketLifetime + 33 + 1;
-  fake_clock_.AdvanceTimeMilliseconds(second_packet_expiry_time -
-                                      fake_clock_.TimeInMilliseconds());
-  hist_.SetRtt(1);  // Trigger culling of old packets.
+  Timestamp second_packet_expiry_time =
+      start_time + kPacketLifetime + TimeDelta::Millis(33 + 1);
+  fake_clock_.AdvanceTime(second_packet_expiry_time -
+                          fake_clock_.CurrentTime());
+  hist_.SetRtt(TimeDelta::Millis(1));  // Trigger culling of old packets.
   EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
   EXPECT_FALSE(hist_.GetPacketState(To16u(kStartSeqNum + 1)));
   EXPECT_TRUE(hist_.GetPacketState(To16u(kStartSeqNum + 2)));
 
   // Advance to where last packet expires, verify all gone.
   fake_clock_.AdvanceTimeMilliseconds(33);
-  hist_.SetRtt(1);  // Trigger culling of old packets.
+  hist_.SetRtt(TimeDelta::Millis(1));  // Trigger culling of old packets.
   EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
   EXPECT_FALSE(hist_.GetPacketState(To16u(kStartSeqNum + 1)));
   EXPECT_FALSE(hist_.GetPacketState(To16u(kStartSeqNum + 2)));
 }
 
 TEST_P(RtpPacketHistoryTest, GetPacketAndSetSent) {
-  const int64_t kRttMs = RtpPacketHistory::kMinPacketDurationMs * 2;
-  hist_.SetRtt(kRttMs);
+  const TimeDelta kRtt = RtpPacketHistory::kMinPacketDuration * 2;
+  hist_.SetRtt(kRtt);
 
   // Set size to remove old packets as soon as possible.
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 1);
 
   // Add a sent packet to the history.
-  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum),
-                     fake_clock_.TimeInMicroseconds());
+  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum), fake_clock_.CurrentTime());
 
   // Retransmission request, first retransmission is allowed immediately.
   EXPECT_TRUE(hist_.GetPacketAndMarkAsPending(kStartSeqNum));
 
   // Packet not yet sent, new retransmission not allowed.
-  fake_clock_.AdvanceTimeMilliseconds(kRttMs);
+  fake_clock_.AdvanceTime(kRtt);
   EXPECT_FALSE(hist_.GetPacketAndMarkAsPending(kStartSeqNum));
 
   // Mark as sent, but too early for retransmission.
@@ -438,14 +440,14 @@ TEST_P(RtpPacketHistoryTest, GetPacketAndSetSent) {
   EXPECT_FALSE(hist_.GetPacketAndMarkAsPending(kStartSeqNum));
 
   // Enough time has passed, retransmission is allowed again.
-  fake_clock_.AdvanceTimeMilliseconds(kRttMs);
+  fake_clock_.AdvanceTime(kRtt);
   EXPECT_TRUE(hist_.GetPacketAndMarkAsPending(kStartSeqNum));
 }
 
 TEST_P(RtpPacketHistoryTest, GetPacketWithEncapsulation) {
   const uint32_t kSsrc = 92384762;
-  const int64_t kRttMs = RtpPacketHistory::kMinPacketDurationMs * 2;
-  hist_.SetRtt(kRttMs);
+  const TimeDelta kRtt = RtpPacketHistory::kMinPacketDuration * 2;
+  hist_.SetRtt(kRtt);
 
   // Set size to remove old packets as soon as possible.
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 1);
@@ -453,7 +455,7 @@ TEST_P(RtpPacketHistoryTest, GetPacketWithEncapsulation) {
   // Add a sent packet to the history, with a set SSRC.
   std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum);
   packet->SetSsrc(kSsrc);
-  hist_.PutRtpPacket(std::move(packet), fake_clock_.TimeInMicroseconds());
+  hist_.PutRtpPacket(std::move(packet), fake_clock_.CurrentTime());
 
   // Retransmission request, simulate an RTX-like encapsulation, were the packet
   // is sent on a different SSRC.
@@ -472,8 +474,7 @@ TEST_P(RtpPacketHistoryTest, GetPacketWithEncapsulation) {
 TEST_P(RtpPacketHistoryTest, GetPacketWithEncapsulationAbortOnNullptr) {
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 1);
 
-  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum),
-                     fake_clock_.TimeInMicroseconds());
+  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum), fake_clock_.CurrentTime());
 
   // Retransmission request, but the encapsulator determines that this packet is
   // not suitable for retransmission (bandwidth exhausted?) so the retransmit is
@@ -487,20 +488,19 @@ TEST_P(RtpPacketHistoryTest, GetPacketWithEncapsulationAbortOnNullptr) {
 }
 
 TEST_P(RtpPacketHistoryTest, DontRemovePendingTransmissions) {
-  const int64_t kRttMs = RtpPacketHistory::kMinPacketDurationMs * 2;
-  const int64_t kPacketTimeoutMs =
-      kRttMs * RtpPacketHistory::kMinPacketDurationRtt;
+  const TimeDelta kRtt = RtpPacketHistory::kMinPacketDuration * 2;
+  const TimeDelta kPacketTimeout =
+      kRtt * RtpPacketHistory::kMinPacketDurationRtt;
 
   // Set size to remove old packets as soon as possible.
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 1);
-  hist_.SetRtt(kRttMs);
+  hist_.SetRtt(kRtt);
 
   // Add a sent packet.
-  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum),
-                     fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum), fake_clock_.CurrentTime());
 
   // Advance clock to just before packet timeout.
-  fake_clock_.AdvanceTimeMilliseconds(kPacketTimeoutMs - 1);
+  fake_clock_.AdvanceTime(kPacketTimeout - TimeDelta::Millis(1));
   // Mark as enqueued in pacer.
   EXPECT_TRUE(hist_.GetPacketAndMarkAsPending(kStartSeqNum));
 
@@ -511,7 +511,7 @@ TEST_P(RtpPacketHistoryTest, DontRemovePendingTransmissions) {
 
   // Packet sent. Now it can be removed.
   hist_.MarkPacketAsSent(kStartSeqNum);
-  hist_.SetRtt(kRttMs);  // Force culling of old packets.
+  hist_.SetRtt(kRtt);  // Force culling of old packets.
   EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
 }
 
@@ -524,12 +524,11 @@ TEST_P(RtpPacketHistoryTest, PrioritizedPayloadPadding) {
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 1);
 
   // Add two sent packets, one millisecond apart.
-  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum),
-                     fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum), fake_clock_.CurrentTime());
   fake_clock_.AdvanceTimeMilliseconds(1);
 
   hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum + 1),
-                     fake_clock_.TimeInMilliseconds());
+                     fake_clock_.CurrentTime());
   fake_clock_.AdvanceTimeMilliseconds(1);
 
   // Latest packet given equal retransmission count.
@@ -560,8 +559,7 @@ TEST_P(RtpPacketHistoryTest, PrioritizedPayloadPadding) {
 TEST_P(RtpPacketHistoryTest, NoPendingPacketAsPadding) {
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 1);
 
-  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum),
-                     fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum), fake_clock_.CurrentTime());
   fake_clock_.AdvanceTimeMilliseconds(1);
 
   EXPECT_EQ(hist_.GetPayloadPaddingPacket()->SequenceNumber(), kStartSeqNum);
@@ -578,8 +576,7 @@ TEST_P(RtpPacketHistoryTest, NoPendingPacketAsPadding) {
 TEST_P(RtpPacketHistoryTest, PayloadPaddingWithEncapsulation) {
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 1);
 
-  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum),
-                     fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum), fake_clock_.CurrentTime());
   fake_clock_.AdvanceTimeMilliseconds(1);
 
   // Aborted padding.
@@ -600,10 +597,9 @@ TEST_P(RtpPacketHistoryTest, PayloadPaddingWithEncapsulation) {
 TEST_P(RtpPacketHistoryTest, NackAfterAckIsNoop) {
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 2);
   // Add two sent packets.
-  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum),
-                     fake_clock_.TimeInMilliseconds());
+  hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum), fake_clock_.CurrentTime());
   hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum + 1),
-                     fake_clock_.TimeInMilliseconds());
+                     fake_clock_.CurrentTime());
   // Remove newest one.
   hist_.CullAcknowledgedPackets(std::vector<uint16_t>{kStartSeqNum + 1});
   // Retransmission request for already acked packet, should be noop.
@@ -622,7 +618,7 @@ TEST_P(RtpPacketHistoryTest, OutOfOrderInsertRemoval) {
     uint16_t seq_no = To16u(kStartSeqNum + offset);
     std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(seq_no);
     packet->SetPayloadSize(50);
-    hist_.PutRtpPacket(std::move(packet), fake_clock_.TimeInMilliseconds());
+    hist_.PutRtpPacket(std::move(packet), fake_clock_.CurrentTime());
     fake_clock_.AdvanceTimeMilliseconds(33);
   }
 
@@ -649,7 +645,7 @@ TEST_P(RtpPacketHistoryTest, UsesLastPacketAsPaddingWithPrioOff) {
 
   for (size_t i = 0; i < kHistorySize; ++i) {
     hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + i)),
-                       fake_clock_.TimeInMilliseconds());
+                       fake_clock_.CurrentTime());
     hist_.MarkPacketAsSent(To16u(kStartSeqNum + i));
     fake_clock_.AdvanceTimeMilliseconds(1);
 
diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
index 367785846b..a98dab3972 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@@ -787,7 +787,7 @@ void ModuleRtpRtcpImpl::set_rtt_ms(int64_t rtt_ms) {
     rtt_ms_ = rtt_ms;
   }
   if (rtp_sender_) {
-    rtp_sender_->packet_history.SetRtt(rtt_ms);
+    rtp_sender_->packet_history.SetRtt(TimeDelta::Millis(rtt_ms));
   }
 }
 
diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl2.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl2.cc
index 6f39c5ce53..06fbbe01b5 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl2.cc
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl2.cc
@@ -745,7 +745,7 @@ void ModuleRtpRtcpImpl2::set_rtt_ms(int64_t rtt_ms) {
     rtt_ms_ = rtt_ms;
   }
   if (rtp_sender_) {
-    rtp_sender_->packet_history.SetRtt(rtt_ms);
+    rtp_sender_->packet_history.SetRtt(TimeDelta::Millis(rtt_ms));
   }
 }
 
diff --git a/modules/rtp_rtcp/source/rtp_sender.cc b/modules/rtp_rtcp/source/rtp_sender.cc
index f644c7d64a..d5c6c16978 100644
--- a/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/modules/rtp_rtcp/source/rtp_sender.cc
@@ -354,7 +354,7 @@ void RTPSender::OnReceivedAckOnRtxSsrc(
 void RTPSender::OnReceivedNack(
     const std::vector<uint16_t>& nack_sequence_numbers,
     int64_t avg_rtt) {
-  packet_history_->SetRtt(5 + avg_rtt);
+  packet_history_->SetRtt(TimeDelta::Millis(5 + avg_rtt));
   for (uint16_t seq_no : nack_sequence_numbers) {
     const int32_t bytes_sent = ReSendPacket(seq_no);
     if (bytes_sent < 0) {
diff --git a/modules/rtp_rtcp/source/rtp_sender_egress.cc b/modules/rtp_rtcp/source/rtp_sender_egress.cc
index b34b54c1fa..e5c2e536f6 100644
--- a/modules/rtp_rtcp/source/rtp_sender_egress.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_egress.cc
@@ -276,7 +276,7 @@ void RtpSenderEgress::SendPacket(RtpPacketToSend* packet,
   // actual sending fails.
   if (is_media && packet->allow_retransmission()) {
     packet_history_->PutRtpPacket(std::make_unique<RtpPacketToSend>(*packet),
-                                  now_ms);
+                                  Timestamp::Millis(now_ms));
   } else if (packet->retransmitted_sequence_number()) {
     packet_history_->MarkPacketAsSent(*packet->retransmitted_sequence_number());
   }
diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index 0582d71453..d77d566c17 100644
--- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -371,7 +371,7 @@ TEST_F(RtpSenderTest, ReSendPacketForwardsPacketsToPacer) {
   auto packet = BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, now_ms);
   packet->SetSequenceNumber(kSeqNum);
   packet->set_allow_retransmission(true);
-  packet_history_->PutRtpPacket(std::move(packet), now_ms);
+  packet_history_->PutRtpPacket(std::move(packet), Timestamp::Millis(now_ms));
 
   EXPECT_CALL(mock_paced_sender_,
               EnqueuePackets(ElementsAre(AllOf(
@@ -571,7 +571,8 @@ TEST_F(RtpSenderTest, KeepsTimestampsOnPayloadPadding) {
                                  Timestamp::Millis(start_time)))))));
   std::unique_ptr<RtpPacketToSend> media_packet =
       SendPacket(start_time, kPayloadSize);
-  packet_history_->PutRtpPacket(std::move(media_packet), start_time);
+  packet_history_->PutRtpPacket(std::move(media_packet),
+                                Timestamp::Millis(start_time));
 
   // Advance time before sending padding.
   const TimeDelta kTimeDiff = TimeDelta::Millis(17);
@@ -626,7 +627,7 @@ TEST_F(RtpSenderTest, RidIncludedOnRtxSentPackets) {
       .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
         sequencer_->Sequence(*packets[0]);
         packet_history_->PutRtpPacket(std::move(packets[0]),
-                                      clock_->TimeInMilliseconds());
+                                      clock_->CurrentTime());
       });
   SendGenericPacket();
 
@@ -705,7 +706,7 @@ TEST_F(RtpSenderTest, MidAndRidIncludedOnFirstRtxPacket) {
   EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1)))
       .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
         packet_history_->PutRtpPacket(std::move(packets[0]),
-                                      clock_->TimeInMilliseconds());
+                                      clock_->CurrentTime());
       });
   auto second_built_packet = SendGenericPacket();
 
@@ -734,7 +735,7 @@ TEST_F(RtpSenderTest, MidAndRidNotIncludedOnRtxPacketsAfterAck) {
   sequencer_->Sequence(*first_built_packet);
   packet_history_->PutRtpPacket(
       std::make_unique<RtpPacketToSend>(*first_built_packet),
-      /*send_time=*/clock_->TimeInMilliseconds());
+      /*send_time=*/clock_->CurrentTime());
   rtp_sender_->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
 
   // The second packet will include neither since an ack was received.
@@ -742,7 +743,7 @@ TEST_F(RtpSenderTest, MidAndRidNotIncludedOnRtxPacketsAfterAck) {
   sequencer_->Sequence(*second_built_packet);
   packet_history_->PutRtpPacket(
       std::make_unique<RtpPacketToSend>(*second_built_packet),
-      /*send_time=*/clock_->TimeInMilliseconds());
+      /*send_time=*/clock_->CurrentTime());
 
   // The first RTX packet will include MID and RRID.
   EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1)))
@@ -782,7 +783,7 @@ TEST_F(RtpSenderTest, MidAndRidAlwaysIncludedOnRtxPacketsWhenConfigured) {
       .WillRepeatedly(
           [&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
             packet_history_->PutRtpPacket(std::move(packets[0]),
-                                          clock_->TimeInMilliseconds());
+                                          clock_->CurrentTime());
           });
   auto media_packet1 = SendGenericPacket();
   rtp_sender_->OnReceivedAckOnSsrc(media_packet1->SequenceNumber());
@@ -850,7 +851,7 @@ TEST_F(RtpSenderTest, MidAndRridNotIncludedOnRtxPacketsAfterRtpStateRestored) {
   EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1)))
       .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
         packet_history_->PutRtpPacket(std::move(packets[0]),
-                                      clock_->TimeInMilliseconds());
+                                      clock_->CurrentTime());
       });
   auto built_packet = SendGenericPacket();
 
@@ -877,7 +878,7 @@ TEST_F(RtpSenderTest, RespectsNackBitrateLimit) {
     sequencer_->Sequence(*packet);
     sequence_numbers.push_back(packet->SequenceNumber());
     packet_history_->PutRtpPacket(std::move(packet),
-                                  /*send_time=*/clock_->TimeInMilliseconds());
+                                  /*send_time=*/clock_->CurrentTime());
     time_controller_.AdvanceTime(TimeDelta::Millis(1));
   }
 
@@ -994,8 +995,7 @@ TEST_F(RtpSenderTest, SendPacketHandlesRetransmissionHistory) {
       BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
   const uint16_t media_sequence_number = packet->SequenceNumber();
   packet->set_allow_retransmission(true);
-  packet_history_->PutRtpPacket(std::move(packet),
-                                clock_->TimeInMilliseconds());
+  packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
 
   // Simulate successful retransmission request.
   time_controller_.AdvanceTime(TimeDelta::Millis(30));
@@ -1022,8 +1022,7 @@ TEST_F(RtpSenderTest, MarksRetransmittedPackets) {
       BuildRtpPacket(kPayload, true, 0, clock_->TimeInMilliseconds());
   const uint16_t media_sequence_number = packet->SequenceNumber();
   packet->set_allow_retransmission(true);
-  packet_history_->PutRtpPacket(std::move(packet),
-                                clock_->TimeInMilliseconds());
+  packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
 
   // Expect a retransmission packet marked with which packet it is a
   // retransmit of.
@@ -1055,8 +1054,7 @@ TEST_F(RtpSenderTest, GeneratedPaddingHasBweExtensions) {
   packet->set_allow_retransmission(true);
   packet->SetPayloadSize(kMinPaddingSize);
   packet->set_packet_type(RtpPacketMediaType::kVideo);
-  packet_history_->PutRtpPacket(std::move(packet),
-                                clock_->TimeInMilliseconds());
+  packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
 
   // Generate a plain padding packet, check that extensions are registered.
   std::vector<std::unique_ptr<RtpPacketToSend>> generated_packets =
@@ -1098,8 +1096,7 @@ TEST_F(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) {
   packet->set_allow_retransmission(true);
   packet->SetPayloadSize(kPayloadPacketSize);
   packet->set_packet_type(RtpPacketMediaType::kVideo);
-  packet_history_->PutRtpPacket(std::move(packet),
-                                clock_->TimeInMilliseconds());
+  packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
 
   // Generated padding has large enough budget that the video packet should be
   // retransmitted as padding.
@@ -1149,8 +1146,7 @@ TEST_F(RtpSenderTest, LimitsPayloadPaddingSize) {
   packet->set_allow_retransmission(true);
   packet->SetPayloadSize(kPayloadPacketSize);
   packet->set_packet_type(RtpPacketMediaType::kVideo);
-  packet_history_->PutRtpPacket(std::move(packet),
-                                clock_->TimeInMilliseconds());
+  packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
 
   // Smallest target size that will result in the sent packet being returned as
   // padding.
@@ -1191,8 +1187,7 @@ TEST_F(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) {
   packet->SetPayloadSize(kPayloadPacketSize);
   packet->set_packet_type(RtpPacketMediaType::kVideo);
   sequencer_->Sequence(*packet);
-  packet_history_->PutRtpPacket(std::move(packet),
-                                clock_->TimeInMilliseconds());
+  packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
 
   // Payload padding not available without RTX, only generate plain padding on
   // the media SSRC.
@@ -1269,7 +1264,8 @@ TEST_F(RtpSenderTest, SetsCaptureTimeOnRtxRetransmissions) {
                      /*capture_time_ms=*/start_time_ms);
   packet->set_allow_retransmission(true);
   sequencer_->Sequence(*packet);
-  packet_history_->PutRtpPacket(std::move(packet), start_time_ms);
+  packet_history_->PutRtpPacket(std::move(packet),
+                                Timestamp::Millis(start_time_ms));
 
   // Advance time, request an RTX retransmission. Capture timestamp should be
   // preserved.
@@ -1283,7 +1279,7 @@ TEST_F(RtpSenderTest, SetsCaptureTimeOnRtxRetransmissions) {
 }
 
 TEST_F(RtpSenderTest, IgnoresNackAfterDisablingMedia) {
-  const int64_t kRtt = 10;
+  const TimeDelta kRtt = TimeDelta::Millis(10);
 
   EnableRtx();
   packet_history_->SetRtt(kRtt);
@@ -1295,18 +1291,19 @@ TEST_F(RtpSenderTest, IgnoresNackAfterDisablingMedia) {
                      /*capture_time_ms=*/start_time_ms);
   packet->set_allow_retransmission(true);
   sequencer_->Sequence(*packet);
-  packet_history_->PutRtpPacket(std::move(packet), start_time_ms);
+  packet_history_->PutRtpPacket(std::move(packet),
+                                Timestamp::Millis(start_time_ms));
 
   // Disable media sending and try to retransmit the packet, it should fail.
   rtp_sender_->SetSendingMediaStatus(false);
-  time_controller_.AdvanceTime(TimeDelta::Millis(kRtt));
+  time_controller_.AdvanceTime(kRtt);
   EXPECT_LT(rtp_sender_->ReSendPacket(kSeqNum), 0);
 }
 
 TEST_F(RtpSenderTest, DoesntFecProtectRetransmissions) {
   // Set up retranmission without RTX, so that a plain copy of the old packet is
   // re-sent instead.
-  const int64_t kRtt = 10;
+  const TimeDelta kRtt = TimeDelta::Millis(10);
   rtp_sender_->SetSendingMediaStatus(true);
   rtp_sender_->SetRtxStatus(kRtxOff);
   packet_history_->SetStorePacketsStatus(
@@ -1321,7 +1318,8 @@ TEST_F(RtpSenderTest, DoesntFecProtectRetransmissions) {
   packet->set_allow_retransmission(true);
   packet->set_fec_protect_packet(true);
   sequencer_->Sequence(*packet);
-  packet_history_->PutRtpPacket(std::move(packet), start_time_ms);
+  packet_history_->PutRtpPacket(std::move(packet),
+                                Timestamp::Millis(start_time_ms));
 
   // Re-send packet, the retransmitted packet should not have the FEC protection
   // flag set.
@@ -1329,7 +1327,7 @@ TEST_F(RtpSenderTest, DoesntFecProtectRetransmissions) {
               EnqueuePackets(ElementsAre(Pointee(
                   Property(&RtpPacketToSend::fec_protect_packet, false)))));
 
-  time_controller_.AdvanceTime(TimeDelta::Millis(kRtt));
+  time_controller_.AdvanceTime(kRtt);
   EXPECT_GT(rtp_sender_->ReSendPacket(kSeqNum), 0);
 }