Use the injected clock in rtcp_transciever.

Bug: webrtc:11327
Change-Id: Idb02842f2eb679f972c0449a01a81a26ceb85827
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/219789
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Paul Hallak <phallak@google.com>
Cr-Commit-Position: refs/heads/master@{#34080}

modules/rtp_rtcp/BUILD.gn

@@ -371,6 +371,7 @@ rtc_library("rtcp_transceiver") {
     "../../api:rtp_headers",
     "../../api:transport_api",
     "../../api/task_queue",
+    "../../api/units:timestamp",
     "../../api/video:video_bitrate_allocation",
     "../../rtc_base:checks",
     "../../rtc_base:rtc_base_approved",
@@ -574,6 +575,7 @@ if (rtc_include_tests) {
       "../../api/transport:field_trial_based_config",
       "../../api/transport/rtp:dependency_descriptor",
       "../../api/units:data_size",
+      "../../api/units:time_delta",
       "../../api/units:timestamp",
       "../../api/video:encoded_image",
       "../../api/video:video_bitrate_allocation",

modules/rtp_rtcp/source/rtcp_transceiver.cc

@@ -14,6 +14,7 @@
 #include <utility>
 #include <vector>
 
+#include "api/units/timestamp.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/event.h"
@@ -23,7 +24,8 @@
 namespace webrtc {
 
 RtcpTransceiver::RtcpTransceiver(const RtcpTransceiverConfig& config)
-    : task_queue_(config.task_queue),
+    : clock_(config.clock),
+      task_queue_(config.task_queue),
       rtcp_transceiver_(std::make_unique<RtcpTransceiverImpl>(config)) {
   RTC_DCHECK(task_queue_);
 }
@@ -82,9 +84,9 @@ void RtcpTransceiver::SetReadyToSend(bool ready) {
 void RtcpTransceiver::ReceivePacket(rtc::CopyOnWriteBuffer packet) {
   RTC_CHECK(rtcp_transceiver_);
   RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
-  int64_t now_us = rtc::TimeMicros();
+  Timestamp now = clock_->CurrentTime();
-  task_queue_->PostTask(ToQueuedTask(
+  task_queue_->PostTask(
-      [ptr, packet, now_us] { ptr->ReceivePacket(packet, now_us); }));
+      ToQueuedTask([ptr, packet, now] { ptr->ReceivePacket(packet, now); }));
 }
 
 void RtcpTransceiver::SendCompoundPacket() {

modules/rtp_rtcp/source/rtcp_transceiver.h

@@ -20,6 +20,7 @@
 #include "modules/rtp_rtcp/source/rtcp_transceiver_config.h"
 #include "modules/rtp_rtcp/source/rtcp_transceiver_impl.h"
 #include "rtc_base/copy_on_write_buffer.h"
+#include "system_wrappers/include/clock.h"
 
 namespace webrtc {
 //
@@ -93,6 +94,7 @@ class RtcpTransceiver : public RtcpFeedbackSenderInterface {
   void SendFullIntraRequest(std::vector<uint32_t> ssrcs, bool new_request);
 
  private:
+  Clock* const clock_;
   TaskQueueBase* const task_queue_;
   std::unique_ptr<RtcpTransceiverImpl> rtcp_transceiver_;
 };

modules/rtp_rtcp/source/rtcp_transceiver_impl.cc

@@ -40,7 +40,7 @@ namespace webrtc {
 namespace {
 
 struct SenderReportTimes {
-  int64_t local_received_time_us;
+  Timestamp local_received_time;
   NtpTime remote_sent_time;
 };
 
@@ -133,13 +133,13 @@ void RtcpTransceiverImpl::SetReadyToSend(bool ready) {
 }
 
 void RtcpTransceiverImpl::ReceivePacket(rtc::ArrayView<const uint8_t> packet,
-                                        int64_t now_us) {
+                                        Timestamp now) {
   while (!packet.empty()) {
     rtcp::CommonHeader rtcp_block;
     if (!rtcp_block.Parse(packet.data(), packet.size()))
       return;
 
-    HandleReceivedPacket(rtcp_block, now_us);
+    HandleReceivedPacket(rtcp_block, now);
 
     // TODO(danilchap): Use packet.remove_prefix() when that function exists.
     packet = packet.subview(rtcp_block.packet_size());
@@ -228,16 +228,16 @@ void RtcpTransceiverImpl::SendFullIntraRequest(
 
 void RtcpTransceiverImpl::HandleReceivedPacket(
     const rtcp::CommonHeader& rtcp_packet_header,
-    int64_t now_us) {
+    Timestamp now) {
   switch (rtcp_packet_header.type()) {
     case rtcp::Bye::kPacketType:
       HandleBye(rtcp_packet_header);
       break;
     case rtcp::SenderReport::kPacketType:
-      HandleSenderReport(rtcp_packet_header, now_us);
+      HandleSenderReport(rtcp_packet_header, now);
       break;
     case rtcp::ExtendedReports::kPacketType:
-      HandleExtendedReports(rtcp_packet_header, now_us);
+      HandleExtendedReports(rtcp_packet_header, now);
       break;
   }
 }
@@ -256,17 +256,14 @@ void RtcpTransceiverImpl::HandleBye(
 
 void RtcpTransceiverImpl::HandleSenderReport(
     const rtcp::CommonHeader& rtcp_packet_header,
-    int64_t now_us) {
+    Timestamp now) {
   rtcp::SenderReport sender_report;
   if (!sender_report.Parse(rtcp_packet_header))
     return;
   RemoteSenderState& remote_sender =
       remote_senders_[sender_report.sender_ssrc()];
-  absl::optional<SenderReportTimes>& last =
+  remote_sender.last_received_sender_report =
-      remote_sender.last_received_sender_report;
+      absl::optional<SenderReportTimes>({now, sender_report.ntp()});
-  last.emplace();
-  last->local_received_time_us = now_us;
-  last->remote_sent_time = sender_report.ntp();
 
   for (MediaReceiverRtcpObserver* observer : remote_sender.observers)
     observer->OnSenderReport(sender_report.sender_ssrc(), sender_report.ntp(),
@@ -275,26 +272,27 @@ void RtcpTransceiverImpl::HandleSenderReport(
 
 void RtcpTransceiverImpl::HandleExtendedReports(
     const rtcp::CommonHeader& rtcp_packet_header,
-    int64_t now_us) {
+    Timestamp now) {
   rtcp::ExtendedReports extended_reports;
   if (!extended_reports.Parse(rtcp_packet_header))
     return;
 
   if (extended_reports.dlrr())
-    HandleDlrr(extended_reports.dlrr(), now_us);
+    HandleDlrr(extended_reports.dlrr(), now);
 
   if (extended_reports.target_bitrate())
     HandleTargetBitrate(*extended_reports.target_bitrate(),
                         extended_reports.sender_ssrc());
 }
 
-void RtcpTransceiverImpl::HandleDlrr(const rtcp::Dlrr& dlrr, int64_t now_us) {
+void RtcpTransceiverImpl::HandleDlrr(const rtcp::Dlrr& dlrr, Timestamp now) {
   if (!config_.non_sender_rtt_measurement || config_.rtt_observer == nullptr)
     return;
 
   // Delay and last_rr are transferred using 32bit compact ntp resolution.
   // Convert packet arrival time to same format through 64bit ntp format.
-  uint32_t receive_time_ntp = CompactNtp(TimeMicrosToNtp(now_us));
+  uint32_t receive_time_ntp =
+      CompactNtp(config_.clock->ConvertTimestampToNtpTime(now));
   for (const rtcp::ReceiveTimeInfo& rti : dlrr.sub_blocks()) {
     if (rti.ssrc != config_.feedback_ssrc)
       continue;
@@ -353,10 +351,10 @@ void RtcpTransceiverImpl::SchedulePeriodicCompoundPackets(int64_t delay_ms) {
 void RtcpTransceiverImpl::CreateCompoundPacket(PacketSender* sender) {
   RTC_DCHECK(sender->IsEmpty());
   const uint32_t sender_ssrc = config_.feedback_ssrc;
-  int64_t now_us = rtc::TimeMicros();
+  Timestamp now = config_.clock->CurrentTime();
   rtcp::ReceiverReport receiver_report;
   receiver_report.SetSenderSsrc(sender_ssrc);
-  receiver_report.SetReportBlocks(CreateReportBlocks(now_us));
+  receiver_report.SetReportBlocks(CreateReportBlocks(now));
   sender->AppendPacket(receiver_report);
 
   if (!config_.cname.empty()) {
@@ -377,7 +375,7 @@ void RtcpTransceiverImpl::CreateCompoundPacket(PacketSender* sender) {
     rtcp::ExtendedReports xr;
 
     rtcp::Rrtr rrtr;
-    rrtr.SetNtp(TimeMicrosToNtp(now_us));
+    rrtr.SetNtp(config_.clock->ConvertTimestampToNtpTime(now));
     xr.SetRrtr(rrtr);
 
     xr.SetSenderSsrc(sender_ssrc);
@@ -428,7 +426,7 @@ void RtcpTransceiverImpl::SendImmediateFeedback(
 }
 
 std::vector<rtcp::ReportBlock> RtcpTransceiverImpl::CreateReportBlocks(
-    int64_t now_us) {
+    Timestamp now) {
   if (!config_.receive_statistics)
     return {};
   // TODO(danilchap): Support sending more than
@@ -448,7 +446,7 @@ std::vector<rtcp::ReportBlock> RtcpTransceiverImpl::CreateReportBlocks(
         *it->second.last_received_sender_report;
     last_sr = CompactNtp(last_sender_report.remote_sent_time);
     last_delay = SaturatedUsToCompactNtp(
-        now_us - last_sender_report.local_received_time_us);
+        now.us() - last_sender_report.local_received_time.us());
     report_block.SetLastSr(last_sr);
     report_block.SetDelayLastSr(last_delay);
   }

modules/rtp_rtcp/source/rtcp_transceiver_impl.h

@@ -18,6 +18,7 @@
 
 #include "absl/types/optional.h"
 #include "api/array_view.h"
+#include "api/units/timestamp.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/dlrr.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/remb.h"
@@ -48,7 +49,12 @@ class RtcpTransceiverImpl {
 
   void SetReadyToSend(bool ready);
 
-  void ReceivePacket(rtc::ArrayView<const uint8_t> packet, int64_t now_us);
+  // ABSL_DEPRECATED("bugs.webrtc.org/11327"): Remove this flavor once
+  // downstream projects migrate.
+  void ReceivePacket(rtc::ArrayView<const uint8_t> packet, int64_t now_us) {
+    ReceivePacket(packet, Timestamp::Micros(now_us));
+  }
+  void ReceivePacket(rtc::ArrayView<const uint8_t> packet, Timestamp now);
 
   void SendCompoundPacket();
 
@@ -76,15 +82,15 @@ class RtcpTransceiverImpl {
   struct RemoteSenderState;
 
   void HandleReceivedPacket(const rtcp::CommonHeader& rtcp_packet_header,
-                            int64_t now_us);
+                            Timestamp now);
   // Individual rtcp packet handlers.
   void HandleBye(const rtcp::CommonHeader& rtcp_packet_header);
   void HandleSenderReport(const rtcp::CommonHeader& rtcp_packet_header,
-                          int64_t now_us);
+                          Timestamp now);
   void HandleExtendedReports(const rtcp::CommonHeader& rtcp_packet_header,
-                             int64_t now_us);
+                             Timestamp now);
   // Extended Reports blocks handlers.
-  void HandleDlrr(const rtcp::Dlrr& dlrr, int64_t now_us);
+  void HandleDlrr(const rtcp::Dlrr& dlrr, Timestamp now);
   void HandleTargetBitrate(const rtcp::TargetBitrate& target_bitrate,
                            uint32_t remote_ssrc);
 
@@ -97,7 +103,7 @@ class RtcpTransceiverImpl {
   void SendPeriodicCompoundPacket();
   void SendImmediateFeedback(const rtcp::RtcpPacket& rtcp_packet);
   // Generate Report Blocks to be send in Sender or Receiver Report.
-  std::vector<rtcp::ReportBlock> CreateReportBlocks(int64_t now_us);
+  std::vector<rtcp::ReportBlock> CreateReportBlocks(Timestamp now);
 
   const RtcpTransceiverConfig config_;
 

modules/rtp_rtcp/source/rtcp_transceiver_impl_unittest.cc

@@ -16,6 +16,8 @@
 
 #include "absl/memory/memory.h"
 #include "api/rtp_headers.h"
+#include "api/units/time_delta.h"
+#include "api/units/timestamp.h"
 #include "api/video/video_bitrate_allocation.h"
 #include "modules/rtp_rtcp/include/receive_statistics.h"
 #include "modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h"
@@ -24,8 +26,9 @@
 #include "modules/rtp_rtcp/source/rtcp_packet/compound_packet.h"
 #include "modules/rtp_rtcp/source/time_util.h"
 #include "rtc_base/event.h"
-#include "rtc_base/fake_clock.h"
 #include "rtc_base/task_queue_for_test.h"
+#include "rtc_base/time_utils.h"
+#include "system_wrappers/include/clock.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
 #include "test/mock_transport.h"
@@ -46,8 +49,10 @@ using ::webrtc::NtpTime;
 using ::webrtc::RtcpTransceiverConfig;
 using ::webrtc::RtcpTransceiverImpl;
 using ::webrtc::SaturatedUsToCompactNtp;
+using ::webrtc::SimulatedClock;
 using ::webrtc::TaskQueueForTest;
-using ::webrtc::TimeMicrosToNtp;
+using ::webrtc::TimeDelta;
+using ::webrtc::Timestamp;
 using ::webrtc::VideoBitrateAllocation;
 using ::webrtc::rtcp::Bye;
 using ::webrtc::rtcp::CompoundPacket;
@@ -142,9 +147,11 @@ RtcpTransceiverConfig DefaultTestConfig() {
 }
 
 TEST(RtcpTransceiverImplTest, NeedToStopPeriodicTaskToDestroyOnTaskQueue) {
+  SimulatedClock clock(0);
   FakeRtcpTransport transport;
   TaskQueueForTest queue("rtcp");
   RtcpTransceiverConfig config = DefaultTestConfig();
+  config.clock = &clock;
   config.task_queue = queue.Get();
   config.schedule_periodic_compound_packets = true;
   config.outgoing_transport = &transport;
@@ -162,9 +169,11 @@ TEST(RtcpTransceiverImplTest, NeedToStopPeriodicTaskToDestroyOnTaskQueue) {
 }
 
 TEST(RtcpTransceiverImplTest, CanDestroyAfterTaskQueue) {
+  SimulatedClock clock(0);
   FakeRtcpTransport transport;
   auto* queue = new TaskQueueForTest("rtcp");
   RtcpTransceiverConfig config = DefaultTestConfig();
+  config.clock = &clock;
   config.task_queue = queue->Get();
   config.schedule_periodic_compound_packets = true;
   config.outgoing_transport = &transport;
@@ -177,9 +186,11 @@ TEST(RtcpTransceiverImplTest, CanDestroyAfterTaskQueue) {
 }
 
 TEST(RtcpTransceiverImplTest, DelaysSendingFirstCompondPacket) {
+  SimulatedClock clock(0);
   TaskQueueForTest queue("rtcp");
   FakeRtcpTransport transport;
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.outgoing_transport = &transport;
   config.initial_report_delay_ms = 10;
   config.task_queue = queue.Get();
@@ -202,9 +213,11 @@ TEST(RtcpTransceiverImplTest, DelaysSendingFirstCompondPacket) {
 }
 
 TEST(RtcpTransceiverImplTest, PeriodicallySendsPackets) {
+  SimulatedClock clock(0);
   TaskQueueForTest queue("rtcp");
   FakeRtcpTransport transport;
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.outgoing_transport = &transport;
   config.initial_report_delay_ms = 0;
   config.report_period_ms = kReportPeriodMs;
@@ -236,9 +249,11 @@ TEST(RtcpTransceiverImplTest, PeriodicallySendsPackets) {
 }
 
 TEST(RtcpTransceiverImplTest, SendCompoundPacketDelaysPeriodicSendPackets) {
+  SimulatedClock clock(0);
   TaskQueueForTest queue("rtcp");
   FakeRtcpTransport transport;
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.outgoing_transport = &transport;
   config.initial_report_delay_ms = 0;
   config.report_period_ms = kReportPeriodMs;
@@ -282,8 +297,10 @@ TEST(RtcpTransceiverImplTest, SendCompoundPacketDelaysPeriodicSendPackets) {
 }
 
 TEST(RtcpTransceiverImplTest, SendsNoRtcpWhenNetworkStateIsDown) {
+  SimulatedClock clock(0);
   MockTransport mock_transport;
   RtcpTransceiverConfig config = DefaultTestConfig();
+  config.clock = &clock;
   config.initial_ready_to_send = false;
   config.outgoing_transport = &mock_transport;
   RtcpTransceiverImpl rtcp_transceiver(config);
@@ -301,8 +318,10 @@ TEST(RtcpTransceiverImplTest, SendsNoRtcpWhenNetworkStateIsDown) {
 }
 
 TEST(RtcpTransceiverImplTest, SendsRtcpWhenNetworkStateIsUp) {
+  SimulatedClock clock(0);
   MockTransport mock_transport;
   RtcpTransceiverConfig config = DefaultTestConfig();
+  config.clock = &clock;
   config.initial_ready_to_send = false;
   config.outgoing_transport = &mock_transport;
   RtcpTransceiverImpl rtcp_transceiver(config);
@@ -322,9 +341,11 @@ TEST(RtcpTransceiverImplTest, SendsRtcpWhenNetworkStateIsUp) {
 }
 
 TEST(RtcpTransceiverImplTest, SendsPeriodicRtcpWhenNetworkStateIsUp) {
+  SimulatedClock clock(0);
   TaskQueueForTest queue("rtcp");
   FakeRtcpTransport transport;
   RtcpTransceiverConfig config = DefaultTestConfig();
+  config.clock = &clock;
   config.schedule_periodic_compound_packets = true;
   config.initial_ready_to_send = false;
   config.outgoing_transport = &transport;
@@ -348,7 +369,9 @@ TEST(RtcpTransceiverImplTest, SendsPeriodicRtcpWhenNetworkStateIsUp) {
 
 TEST(RtcpTransceiverImplTest, SendsMinimalCompoundPacket) {
   const uint32_t kSenderSsrc = 12345;
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.feedback_ssrc = kSenderSsrc;
   config.cname = "cname";
   RtcpPacketParser rtcp_parser;
@@ -371,7 +394,9 @@ TEST(RtcpTransceiverImplTest, SendsMinimalCompoundPacket) {
 
 TEST(RtcpTransceiverImplTest, SendsNoRembInitially) {
   const uint32_t kSenderSsrc = 12345;
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.feedback_ssrc = kSenderSsrc;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -387,7 +412,9 @@ TEST(RtcpTransceiverImplTest, SendsNoRembInitially) {
 
 TEST(RtcpTransceiverImplTest, SetRembIncludesRembInNextCompoundPacket) {
   const uint32_t kSenderSsrc = 12345;
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.feedback_ssrc = kSenderSsrc;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -406,7 +433,9 @@ TEST(RtcpTransceiverImplTest, SetRembIncludesRembInNextCompoundPacket) {
 
 TEST(RtcpTransceiverImplTest, SetRembUpdatesValuesToSend) {
   const uint32_t kSenderSsrc = 12345;
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.feedback_ssrc = kSenderSsrc;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -431,7 +460,9 @@ TEST(RtcpTransceiverImplTest, SetRembUpdatesValuesToSend) {
 
 TEST(RtcpTransceiverImplTest, SetRembSendsImmediatelyIfSendRembOnChange) {
   const uint32_t kSenderSsrc = 12345;
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.send_remb_on_change = true;
   config.feedback_ssrc = kSenderSsrc;
   RtcpPacketParser rtcp_parser;
@@ -457,7 +488,9 @@ TEST(RtcpTransceiverImplTest, SetRembSendsImmediatelyIfSendRembOnChange) {
 TEST(RtcpTransceiverImplTest,
      SetRembSendsImmediatelyIfSendRembOnChangeReducedSize) {
   const uint32_t kSenderSsrc = 12345;
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.send_remb_on_change = true;
   config.rtcp_mode = webrtc::RtcpMode::kReducedSize;
   config.feedback_ssrc = kSenderSsrc;
@@ -475,7 +508,9 @@ TEST(RtcpTransceiverImplTest,
 
 TEST(RtcpTransceiverImplTest, SetRembIncludesRembInAllCompoundPackets) {
   const uint32_t kSenderSsrc = 12345;
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.feedback_ssrc = kSenderSsrc;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -493,7 +528,9 @@ TEST(RtcpTransceiverImplTest, SetRembIncludesRembInAllCompoundPackets) {
 
 TEST(RtcpTransceiverImplTest, SendsNoRembAfterUnset) {
   const uint32_t kSenderSsrc = 12345;
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.feedback_ssrc = kSenderSsrc;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -522,7 +559,9 @@ TEST(RtcpTransceiverImplTest, ReceiverReportUsesReceiveStatistics) {
   EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
       .WillRepeatedly(Return(report_blocks));
 
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.feedback_ssrc = kSenderSsrc;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -543,9 +582,12 @@ TEST(RtcpTransceiverImplTest, ReceiverReportUsesReceiveStatistics) {
 
 TEST(RtcpTransceiverImplTest, MultipleObserversOnSameSsrc) {
   const uint32_t kRemoteSsrc = 12345;
+  SimulatedClock clock(0);
   StrictMock<MockMediaReceiverRtcpObserver> observer1;
   StrictMock<MockMediaReceiverRtcpObserver> observer2;
-  RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
+  RtcpTransceiverConfig config = DefaultTestConfig();
+  config.clock = &clock;
+  RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer2);
 
@@ -559,14 +601,17 @@ TEST(RtcpTransceiverImplTest, MultipleObserversOnSameSsrc) {
 
   EXPECT_CALL(observer1, OnSenderReport(kRemoteSsrc, kRemoteNtp, kRemoteRtp));
   EXPECT_CALL(observer2, OnSenderReport(kRemoteSsrc, kRemoteNtp, kRemoteRtp));
-  rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
+  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
 TEST(RtcpTransceiverImplTest, DoesntCallsObserverAfterRemoved) {
   const uint32_t kRemoteSsrc = 12345;
+  SimulatedClock clock(0);
   StrictMock<MockMediaReceiverRtcpObserver> observer1;
   StrictMock<MockMediaReceiverRtcpObserver> observer2;
-  RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
+  RtcpTransceiverConfig config = DefaultTestConfig();
+  config.clock = &clock;
+  RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer2);
 
@@ -578,15 +623,18 @@ TEST(RtcpTransceiverImplTest, DoesntCallsObserverAfterRemoved) {
 
   EXPECT_CALL(observer1, OnSenderReport(_, _, _)).Times(0);
   EXPECT_CALL(observer2, OnSenderReport(_, _, _));
-  rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
+  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
 TEST(RtcpTransceiverImplTest, CallsObserverOnSenderReportBySenderSsrc) {
   const uint32_t kRemoteSsrc1 = 12345;
   const uint32_t kRemoteSsrc2 = 22345;
+  SimulatedClock clock(0);
   StrictMock<MockMediaReceiverRtcpObserver> observer1;
   StrictMock<MockMediaReceiverRtcpObserver> observer2;
-  RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
+  RtcpTransceiverConfig config = DefaultTestConfig();
+  config.clock = &clock;
+  RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
 
@@ -600,15 +648,18 @@ TEST(RtcpTransceiverImplTest, CallsObserverOnSenderReportBySenderSsrc) {
 
   EXPECT_CALL(observer1, OnSenderReport(kRemoteSsrc1, kRemoteNtp, kRemoteRtp));
   EXPECT_CALL(observer2, OnSenderReport(_, _, _)).Times(0);
-  rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
+  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
 TEST(RtcpTransceiverImplTest, CallsObserverOnByeBySenderSsrc) {
   const uint32_t kRemoteSsrc1 = 12345;
   const uint32_t kRemoteSsrc2 = 22345;
+  SimulatedClock clock(0);
   StrictMock<MockMediaReceiverRtcpObserver> observer1;
   StrictMock<MockMediaReceiverRtcpObserver> observer2;
-  RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
+  RtcpTransceiverConfig config = DefaultTestConfig();
+  config.clock = &clock;
+  RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
 
@@ -618,15 +669,18 @@ TEST(RtcpTransceiverImplTest, CallsObserverOnByeBySenderSsrc) {
 
   EXPECT_CALL(observer1, OnBye(kRemoteSsrc1));
   EXPECT_CALL(observer2, OnBye(_)).Times(0);
-  rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
+  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
 TEST(RtcpTransceiverImplTest, CallsObserverOnTargetBitrateBySenderSsrc) {
   const uint32_t kRemoteSsrc1 = 12345;
   const uint32_t kRemoteSsrc2 = 22345;
+  SimulatedClock clock(0);
   StrictMock<MockMediaReceiverRtcpObserver> observer1;
   StrictMock<MockMediaReceiverRtcpObserver> observer2;
-  RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
+  RtcpTransceiverConfig config = DefaultTestConfig();
+  config.clock = &clock;
+  RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
 
@@ -647,13 +701,16 @@ TEST(RtcpTransceiverImplTest, CallsObserverOnTargetBitrateBySenderSsrc) {
   bitrate_allocation.SetBitrate(1, 1, /*bitrate_bps=*/80000);
   EXPECT_CALL(observer1, OnBitrateAllocation(kRemoteSsrc1, bitrate_allocation));
   EXPECT_CALL(observer2, OnBitrateAllocation(_, _)).Times(0);
-  rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
+  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
 TEST(RtcpTransceiverImplTest, SkipsIncorrectTargetBitrateEntries) {
   const uint32_t kRemoteSsrc = 12345;
+  SimulatedClock clock(0);
   MockMediaReceiverRtcpObserver observer;
-  RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
+  RtcpTransceiverConfig config = DefaultTestConfig();
+  config.clock = &clock;
+  RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
 
   webrtc::rtcp::TargetBitrate target_bitrate;
@@ -669,13 +726,16 @@ TEST(RtcpTransceiverImplTest, SkipsIncorrectTargetBitrateEntries) {
   VideoBitrateAllocation expected_allocation;
   expected_allocation.SetBitrate(0, 0, /*bitrate_bps=*/10000);
   EXPECT_CALL(observer, OnBitrateAllocation(kRemoteSsrc, expected_allocation));
-  rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
+  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
 TEST(RtcpTransceiverImplTest, CallsObserverOnByeBehindSenderReport) {
   const uint32_t kRemoteSsrc = 12345;
+  SimulatedClock clock(0);
   MockMediaReceiverRtcpObserver observer;
-  RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
+  RtcpTransceiverConfig config = DefaultTestConfig();
+  config.clock = &clock;
+  RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
 
   CompoundPacket compound;
@@ -689,13 +749,16 @@ TEST(RtcpTransceiverImplTest, CallsObserverOnByeBehindSenderReport) {
 
   EXPECT_CALL(observer, OnBye(kRemoteSsrc));
   EXPECT_CALL(observer, OnSenderReport(kRemoteSsrc, _, _));
-  rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
+  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
 TEST(RtcpTransceiverImplTest, CallsObserverOnByeBehindUnknownRtcpPacket) {
   const uint32_t kRemoteSsrc = 12345;
+  SimulatedClock clock(0);
   MockMediaReceiverRtcpObserver observer;
-  RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
+  RtcpTransceiverConfig config = DefaultTestConfig();
+  config.clock = &clock;
+  RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
 
   CompoundPacket compound;
@@ -708,7 +771,7 @@ TEST(RtcpTransceiverImplTest, CallsObserverOnByeBehindUnknownRtcpPacket) {
   auto raw_packet = compound.Build();
 
   EXPECT_CALL(observer, OnBye(kRemoteSsrc));
-  rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
+  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
 TEST(RtcpTransceiverImplTest,
@@ -722,7 +785,9 @@ TEST(RtcpTransceiverImplTest,
   EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
       .WillOnce(Return(statistics_report_blocks));
 
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -736,7 +801,7 @@ TEST(RtcpTransceiverImplTest,
   sr.SetSenderSsrc(kRemoteSsrc1);
   sr.SetNtp(kRemoteNtp);
   auto raw_packet = sr.Build();
-  rtcp_transceiver.ReceivePacket(raw_packet, /*now_us=*/0);
+  rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 
   // Trigger sending ReceiverReport.
   rtcp_transceiver.SendCompoundPacket();
@@ -759,7 +824,7 @@ TEST(RtcpTransceiverImplTest,
      WhenSendsReceiverReportCalculatesDelaySinceLastSenderReport) {
   const uint32_t kRemoteSsrc1 = 4321;
   const uint32_t kRemoteSsrc2 = 5321;
-  rtc::ScopedFakeClock clock;
+
   std::vector<ReportBlock> statistics_report_blocks(2);
   statistics_report_blocks[0].SetMediaSsrc(kRemoteSsrc1);
   statistics_report_blocks[1].SetMediaSsrc(kRemoteSsrc2);
@@ -767,7 +832,9 @@ TEST(RtcpTransceiverImplTest,
   EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
       .WillOnce(Return(statistics_report_blocks));
 
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -775,18 +842,19 @@ TEST(RtcpTransceiverImplTest,
   config.receive_statistics = &receive_statistics;
   RtcpTransceiverImpl rtcp_transceiver(config);
 
-  auto receive_sender_report = [&rtcp_transceiver](uint32_t remote_ssrc) {
+  auto receive_sender_report = [&rtcp_transceiver,
+                                &clock](uint32_t remote_ssrc) {
     SenderReport sr;
     sr.SetSenderSsrc(remote_ssrc);
     auto raw_packet = sr.Build();
-    rtcp_transceiver.ReceivePacket(raw_packet, rtc::TimeMicros());
+    rtcp_transceiver.ReceivePacket(raw_packet, clock.CurrentTime());
   };
 
   receive_sender_report(kRemoteSsrc1);
-  clock.AdvanceTime(webrtc::TimeDelta::Millis(100));
+  clock.AdvanceTime(TimeDelta::Millis(100));
 
   receive_sender_report(kRemoteSsrc2);
-  clock.AdvanceTime(webrtc::TimeDelta::Millis(100));
+  clock.AdvanceTime(TimeDelta::Millis(100));
 
   // Trigger ReceiverReport back.
   rtcp_transceiver.SendCompoundPacket();
@@ -808,7 +876,9 @@ TEST(RtcpTransceiverImplTest, SendsNack) {
   const uint32_t kSenderSsrc = 1234;
   const uint32_t kRemoteSsrc = 4321;
   std::vector<uint16_t> kMissingSequenceNumbers = {34, 37, 38};
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.feedback_ssrc = kSenderSsrc;
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
@@ -827,7 +897,9 @@ TEST(RtcpTransceiverImplTest, SendsNack) {
 TEST(RtcpTransceiverImplTest, RequestKeyFrameWithPictureLossIndication) {
   const uint32_t kSenderSsrc = 1234;
   const uint32_t kRemoteSsrc = 4321;
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.feedback_ssrc = kSenderSsrc;
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
@@ -846,7 +918,9 @@ TEST(RtcpTransceiverImplTest, RequestKeyFrameWithPictureLossIndication) {
 TEST(RtcpTransceiverImplTest, RequestKeyFrameWithFullIntraRequest) {
   const uint32_t kSenderSsrc = 1234;
   const uint32_t kRemoteSsrcs[] = {4321, 5321};
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.feedback_ssrc = kSenderSsrc;
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
@@ -863,7 +937,9 @@ TEST(RtcpTransceiverImplTest, RequestKeyFrameWithFullIntraRequest) {
 }
 
 TEST(RtcpTransceiverImplTest, RequestKeyFrameWithFirIncreaseSeqNoPerSsrc) {
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -893,7 +969,9 @@ TEST(RtcpTransceiverImplTest, RequestKeyFrameWithFirIncreaseSeqNoPerSsrc) {
 }
 
 TEST(RtcpTransceiverImplTest, SendFirDoesNotIncreaseSeqNoIfOldRequest) {
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -919,7 +997,9 @@ TEST(RtcpTransceiverImplTest, SendFirDoesNotIncreaseSeqNoIfOldRequest) {
 
 TEST(RtcpTransceiverImplTest, KeyFrameRequestCreatesCompoundPacket) {
   const uint32_t kRemoteSsrcs[] = {4321};
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   // Turn periodic off to ensure sent rtcp packet is explicitly requested.
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
@@ -938,7 +1018,9 @@ TEST(RtcpTransceiverImplTest, KeyFrameRequestCreatesCompoundPacket) {
 
 TEST(RtcpTransceiverImplTest, KeyFrameRequestCreatesReducedSizePacket) {
   const uint32_t kRemoteSsrcs[] = {4321};
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   // Turn periodic off to ensure sent rtcp packet is explicitly requested.
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
@@ -957,8 +1039,9 @@ TEST(RtcpTransceiverImplTest, KeyFrameRequestCreatesReducedSizePacket) {
 
 TEST(RtcpTransceiverImplTest, SendsXrRrtrWhenEnabled) {
   const uint32_t kSenderSsrc = 4321;
-  rtc::ScopedFakeClock clock;
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.feedback_ssrc = kSenderSsrc;
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
@@ -968,7 +1051,7 @@ TEST(RtcpTransceiverImplTest, SendsXrRrtrWhenEnabled) {
   RtcpTransceiverImpl rtcp_transceiver(config);
 
   rtcp_transceiver.SendCompoundPacket();
-  NtpTime ntp_time_now = TimeMicrosToNtp(rtc::TimeMicros());
+  NtpTime ntp_time_now = clock.CurrentNtpTime();
 
   EXPECT_EQ(rtcp_parser.xr()->num_packets(), 1);
   EXPECT_EQ(rtcp_parser.xr()->sender_ssrc(), kSenderSsrc);
@@ -977,7 +1060,9 @@ TEST(RtcpTransceiverImplTest, SendsXrRrtrWhenEnabled) {
 }
 
 TEST(RtcpTransceiverImplTest, SendsNoXrRrtrWhenDisabled) {
+  SimulatedClock clock(0);
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -995,9 +1080,11 @@ TEST(RtcpTransceiverImplTest, SendsNoXrRrtrWhenDisabled) {
 
 TEST(RtcpTransceiverImplTest, CalculatesRoundTripTimeOnDlrr) {
   const uint32_t kSenderSsrc = 4321;
+  SimulatedClock clock(0);
   MockRtcpRttStats rtt_observer;
   MockTransport null_transport;
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.feedback_ssrc = kSenderSsrc;
   config.schedule_periodic_compound_packets = false;
   config.outgoing_transport = &null_transport;
@@ -1005,25 +1092,27 @@ TEST(RtcpTransceiverImplTest, CalculatesRoundTripTimeOnDlrr) {
   config.rtt_observer = &rtt_observer;
   RtcpTransceiverImpl rtcp_transceiver(config);
 
-  int64_t time_us = 12345678;
+  Timestamp time = Timestamp::Micros(12345678);
   webrtc::rtcp::ReceiveTimeInfo rti;
   rti.ssrc = kSenderSsrc;
-  rti.last_rr = CompactNtp(TimeMicrosToNtp(time_us));
+  rti.last_rr = CompactNtp(clock.ConvertTimestampToNtpTime(time));
   rti.delay_since_last_rr = SaturatedUsToCompactNtp(10 * 1000);
   webrtc::rtcp::ExtendedReports xr;
   xr.AddDlrrItem(rti);
   auto raw_packet = xr.Build();
 
   EXPECT_CALL(rtt_observer, OnRttUpdate(100 /* rtt_ms */));
-  rtcp_transceiver.ReceivePacket(raw_packet, time_us + 110 * 1000);
+  rtcp_transceiver.ReceivePacket(raw_packet, time + TimeDelta::Millis(110));
 }
 
 TEST(RtcpTransceiverImplTest, IgnoresUnknownSsrcInDlrr) {
   const uint32_t kSenderSsrc = 4321;
   const uint32_t kUnknownSsrc = 4322;
+  SimulatedClock clock(0);
   MockRtcpRttStats rtt_observer;
   MockTransport null_transport;
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.feedback_ssrc = kSenderSsrc;
   config.schedule_periodic_compound_packets = false;
   config.outgoing_transport = &null_transport;
@@ -1031,16 +1120,16 @@ TEST(RtcpTransceiverImplTest, IgnoresUnknownSsrcInDlrr) {
   config.rtt_observer = &rtt_observer;
   RtcpTransceiverImpl rtcp_transceiver(config);
 
-  int64_t time_us = 12345678;
+  Timestamp time = Timestamp::Micros(12345678);
   webrtc::rtcp::ReceiveTimeInfo rti;
   rti.ssrc = kUnknownSsrc;
-  rti.last_rr = CompactNtp(TimeMicrosToNtp(time_us));
+  rti.last_rr = CompactNtp(clock.ConvertTimestampToNtpTime(time));
   webrtc::rtcp::ExtendedReports xr;
   xr.AddDlrrItem(rti);
   auto raw_packet = xr.Build();
 
   EXPECT_CALL(rtt_observer, OnRttUpdate(_)).Times(0);
-  rtcp_transceiver.ReceivePacket(raw_packet, time_us + 100000);
+  rtcp_transceiver.ReceivePacket(raw_packet, time + TimeDelta::Millis(100));
 }
 
 }  // namespace

modules/rtp_rtcp/source/rtcp_transceiver_unittest.cc

@@ -18,6 +18,7 @@
 #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "rtc_base/event.h"
 #include "rtc_base/task_queue_for_test.h"
+#include "system_wrappers/include/clock.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
 #include "test/mock_transport.h"
@@ -34,6 +35,7 @@ using ::testing::NiceMock;
 using ::webrtc::MockTransport;
 using ::webrtc::RtcpTransceiver;
 using ::webrtc::RtcpTransceiverConfig;
+using ::webrtc::SimulatedClock;
 using ::webrtc::TaskQueueForTest;
 using ::webrtc::rtcp::RemoteEstimate;
 using ::webrtc::rtcp::RtcpPacket;
@@ -57,9 +59,11 @@ void WaitPostedTasks(TaskQueueForTest* queue) {
 }
 
 TEST(RtcpTransceiverTest, SendsRtcpOnTaskQueueWhenCreatedOffTaskQueue) {
+  SimulatedClock clock(0);
   MockTransport outgoing_transport;
   TaskQueueForTest queue("rtcp");
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.outgoing_transport = &outgoing_transport;
   config.task_queue = queue.Get();
   EXPECT_CALL(outgoing_transport, SendRtcp(_, _))
@@ -74,9 +78,11 @@ TEST(RtcpTransceiverTest, SendsRtcpOnTaskQueueWhenCreatedOffTaskQueue) {
 }
 
 TEST(RtcpTransceiverTest, SendsRtcpOnTaskQueueWhenCreatedOnTaskQueue) {
+  SimulatedClock clock(0);
   MockTransport outgoing_transport;
   TaskQueueForTest queue("rtcp");
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.outgoing_transport = &outgoing_transport;
   config.task_queue = queue.Get();
   EXPECT_CALL(outgoing_transport, SendRtcp(_, _))
@@ -94,9 +100,11 @@ TEST(RtcpTransceiverTest, SendsRtcpOnTaskQueueWhenCreatedOnTaskQueue) {
 }
 
 TEST(RtcpTransceiverTest, CanBeDestroyedOnTaskQueue) {
+  SimulatedClock clock(0);
   NiceMock<MockTransport> outgoing_transport;
   TaskQueueForTest queue("rtcp");
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.outgoing_transport = &outgoing_transport;
   config.task_queue = queue.Get();
   auto rtcp_transceiver = std::make_unique<RtcpTransceiver>(config);
@@ -110,9 +118,11 @@ TEST(RtcpTransceiverTest, CanBeDestroyedOnTaskQueue) {
 }
 
 TEST(RtcpTransceiverTest, CanBeDestroyedWithoutBlocking) {
+  SimulatedClock clock(0);
   TaskQueueForTest queue("rtcp");
   NiceMock<MockTransport> outgoing_transport;
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.outgoing_transport = &outgoing_transport;
   config.task_queue = queue.Get();
   auto* rtcp_transceiver = new RtcpTransceiver(config);
@@ -131,9 +141,11 @@ TEST(RtcpTransceiverTest, CanBeDestroyedWithoutBlocking) {
 }
 
 TEST(RtcpTransceiverTest, MaySendPacketsAfterDestructor) {  // i.e. Be careful!
+  SimulatedClock clock(0);
   NiceMock<MockTransport> outgoing_transport;  // Must outlive queue below.
   TaskQueueForTest queue("rtcp");
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.outgoing_transport = &outgoing_transport;
   config.task_queue = queue.Get();
   auto* rtcp_transceiver = new RtcpTransceiver(config);
@@ -162,9 +174,11 @@ rtc::CopyOnWriteBuffer CreateSenderReport(uint32_t ssrc, uint32_t rtp_time) {
 
 TEST(RtcpTransceiverTest, DoesntPostToRtcpObserverAfterCallToRemove) {
   const uint32_t kRemoteSsrc = 1234;
+  SimulatedClock clock(0);
   MockTransport null_transport;
   TaskQueueForTest queue("rtcp");
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.outgoing_transport = &null_transport;
   config.task_queue = queue.Get();
   RtcpTransceiver rtcp_transceiver(config);
@@ -189,9 +203,11 @@ TEST(RtcpTransceiverTest, DoesntPostToRtcpObserverAfterCallToRemove) {
 
 TEST(RtcpTransceiverTest, RemoveMediaReceiverRtcpObserverIsNonBlocking) {
   const uint32_t kRemoteSsrc = 1234;
+  SimulatedClock clock(0);
   MockTransport null_transport;
   TaskQueueForTest queue("rtcp");
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.outgoing_transport = &null_transport;
   config.task_queue = queue.Get();
   RtcpTransceiver rtcp_transceiver(config);
@@ -213,9 +229,11 @@ TEST(RtcpTransceiverTest, RemoveMediaReceiverRtcpObserverIsNonBlocking) {
 }
 
 TEST(RtcpTransceiverTest, CanCallSendCompoundPacketFromAnyThread) {
+  SimulatedClock clock(0);
   MockTransport outgoing_transport;
   TaskQueueForTest queue("rtcp");
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.outgoing_transport = &outgoing_transport;
   config.task_queue = queue.Get();
 
@@ -242,9 +260,11 @@ TEST(RtcpTransceiverTest, CanCallSendCompoundPacketFromAnyThread) {
 }
 
 TEST(RtcpTransceiverTest, DoesntSendPacketsAfterStopCallback) {
+  SimulatedClock clock(0);
   NiceMock<MockTransport> outgoing_transport;
   TaskQueueForTest queue("rtcp");
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.outgoing_transport = &outgoing_transport;
   config.task_queue = queue.Get();
   config.schedule_periodic_compound_packets = true;
@@ -263,9 +283,11 @@ TEST(RtcpTransceiverTest, DoesntSendPacketsAfterStopCallback) {
 TEST(RtcpTransceiverTest, SendsCombinedRtcpPacketOnTaskQueue) {
   static constexpr uint32_t kSenderSsrc = 12345;
 
+  SimulatedClock clock(0);
   MockTransport outgoing_transport;
   TaskQueueForTest queue("rtcp");
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.feedback_ssrc = kSenderSsrc;
   config.outgoing_transport = &outgoing_transport;
   config.task_queue = queue.Get();
@@ -300,9 +322,11 @@ TEST(RtcpTransceiverTest, SendsCombinedRtcpPacketOnTaskQueue) {
 TEST(RtcpTransceiverTest, SendFrameIntraRequestDefaultsToNewRequest) {
   static constexpr uint32_t kSenderSsrc = 12345;
 
+  SimulatedClock clock(0);
   MockTransport outgoing_transport;
   TaskQueueForTest queue("rtcp");
   RtcpTransceiverConfig config;
+  config.clock = &clock;
   config.feedback_ssrc = kSenderSsrc;
   config.outgoing_transport = &outgoing_transport;
   config.task_queue = queue.Get();