diff --git a/modules/rtp_rtcp/BUILD.gn b/modules/rtp_rtcp/BUILD.gn
index b8299f305d..7b8f259969 100644
--- a/modules/rtp_rtcp/BUILD.gn
+++ b/modules/rtp_rtcp/BUILD.gn
@@ -606,12 +606,14 @@ if (rtc_include_tests) {
       ":rtp_rtcp_format",
       ":rtp_rtcp_legacy",
       "../../api:array_view",
+      "../../api:create_time_controller",
       "../../api:libjingle_peerconnection_api",
       "../../api:mock_frame_encryptor",
       "../../api:rtp_headers",
       "../../api:rtp_packet_info",
       "../../api:rtp_parameters",
       "../../api:scoped_refptr",
+      "../../api:time_controller",
       "../../api:transport_api",
       "../../api/rtc_event_log",
       "../../api/transport:field_trial_based_config",
diff --git a/modules/rtp_rtcp/source/rtcp_transceiver.cc b/modules/rtp_rtcp/source/rtcp_transceiver.cc
index 41fa5e6206..108d92cacf 100644
--- a/modules/rtp_rtcp/source/rtcp_transceiver.cc
+++ b/modules/rtp_rtcp/source/rtcp_transceiver.cc
@@ -19,7 +19,7 @@
 #include "rtc_base/checks.h"
 #include "rtc_base/event.h"
 #include "rtc_base/task_utils/to_queued_task.h"
-#include "rtc_base/time_utils.h"
+#include "system_wrappers/include/clock.h"
 
 namespace webrtc {
 
diff --git a/modules/rtp_rtcp/source/rtcp_transceiver_config.cc b/modules/rtp_rtcp/source/rtcp_transceiver_config.cc
index dea6286096..ebf9a2820e 100644
--- a/modules/rtp_rtcp/source/rtcp_transceiver_config.cc
+++ b/modules/rtp_rtcp/source/rtcp_transceiver_config.cc
@@ -44,6 +44,10 @@ bool RtcpTransceiverConfig::Validate() const {
                       << " more than " << IP_PACKET_SIZE << " is unsupported.";
     return false;
   }
+  if (clock == nullptr) {
+    RTC_LOG(LS_ERROR) << debug_id << "clock must be set";
+    return false;
+  }
   if (!outgoing_transport) {
     RTC_LOG(LS_ERROR) << debug_id << "outgoing transport must be set";
     return false;
diff --git a/modules/rtp_rtcp/source/rtcp_transceiver_impl.cc b/modules/rtp_rtcp/source/rtcp_transceiver_impl.cc
index 9ec1749860..80cb8b9e4d 100644
--- a/modules/rtp_rtcp/source/rtcp_transceiver_impl.cc
+++ b/modules/rtp_rtcp/source/rtcp_transceiver_impl.cc
@@ -37,7 +37,7 @@
 #include "rtc_base/numerics/divide_round.h"
 #include "rtc_base/task_utils/repeating_task.h"
 #include "rtc_base/task_utils/to_queued_task.h"
-#include "rtc_base/time_utils.h"
+#include "system_wrappers/include/clock.h"
 
 namespace webrtc {
 namespace {
@@ -562,13 +562,15 @@ void RtcpTransceiverImpl::ReschedulePeriodicCompoundPackets() {
 }
 
 void RtcpTransceiverImpl::SchedulePeriodicCompoundPackets(TimeDelta delay) {
-  periodic_task_handle_ =
-      RepeatingTaskHandle::DelayedStart(config_.task_queue, delay, [this] {
+  periodic_task_handle_ = RepeatingTaskHandle::DelayedStart(
+      config_.task_queue, delay,
+      [this] {
         RTC_DCHECK(config_.schedule_periodic_compound_packets);
         RTC_DCHECK(ready_to_send_);
         SendPeriodicCompoundPacket();
         return config_.report_period;
-      });
+      },
+      TaskQueueBase::DelayPrecision::kLow, config_.clock);
 }
 
 std::vector<uint32_t> RtcpTransceiverImpl::FillReports(
diff --git a/modules/rtp_rtcp/source/rtcp_transceiver_impl_unittest.cc b/modules/rtp_rtcp/source/rtcp_transceiver_impl_unittest.cc
index 02c1e20b41..97ceb56c8b 100644
--- a/modules/rtp_rtcp/source/rtcp_transceiver_impl_unittest.cc
+++ b/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/test/create_time_controller.h"
+#include "api/test/time_controller.h"
 #include "api/units/data_rate.h"
 #include "api/units/time_delta.h"
 #include "api/units/timestamp.h"
@@ -26,9 +28,7 @@
 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
 #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/task_queue_for_test.h"
-#include "rtc_base/time_utils.h"
+#include "rtc_base/task_utils/to_queued_task.h"
 #include "system_wrappers/include/clock.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
@@ -119,15 +119,8 @@ class MockNetworkLinkRtcpObserver : public NetworkLinkRtcpObserver {
               (override));
 };
 
-// Since some tests will need to wait for this period, make it small to avoid
-// slowing tests too much. As long as there are test bots with high scheduler
-// granularity, small period should be ok.
-constexpr TimeDelta kReportPeriod = TimeDelta::Millis(10);
-// On some systems task queue might be slow, instead of guessing right
-// grace period, use very large timeout, 100x larger expected wait time.
-// Use finite timeout to fail tests rather than hang them.
-constexpr int kAlmostForeverMs = 1000;
-
+constexpr TimeDelta kReportPeriod = TimeDelta::Seconds(1);
+constexpr TimeDelta kAlmostForever = TimeDelta::Seconds(2);
 constexpr TimeDelta kTimePrecision = TimeDelta::Millis(1);
 
 MATCHER_P(Near, value, "") {
@@ -137,8 +130,10 @@ MATCHER_P(Near, value, "") {
 // Helper to wait for an rtcp packet produced on a different thread/task queue.
 class FakeRtcpTransport : public webrtc::Transport {
  public:
+  explicit FakeRtcpTransport(TimeController& time) : time_(time) {}
+
   bool SendRtcp(const uint8_t* data, size_t size) override {
-    sent_rtcp_.Set();
+    sent_rtcp_ = true;
     return true;
   }
   bool SendRtp(const uint8_t*, size_t, const webrtc::PacketOptions&) override {
@@ -148,17 +143,15 @@ class FakeRtcpTransport : public webrtc::Transport {
 
   // Returns true when packet was received by the transport.
   bool WaitPacket() {
-    // Normally packet should be sent fast, long before the timeout.
-    bool packet_sent = sent_rtcp_.Wait(kAlmostForeverMs);
-    // Disallow tests to wait almost forever for no packets.
-    EXPECT_TRUE(packet_sent);
-    // Return wait result even though it is expected to be true, so that
-    // individual tests can EXPECT on it for better error message.
-    return packet_sent;
+    bool got_packet = time_.Wait([this] { return sent_rtcp_; }, kAlmostForever);
+    // Clear the 'event' to allow waiting for multiple packets.
+    sent_rtcp_ = false;
+    return got_packet;
   }
 
  private:
-  rtc::Event sent_rtcp_;
+  TimeController& time_;
+  bool sent_rtcp_ = false;
 };
 
 class RtcpParserTransport : public webrtc::Transport {
@@ -183,195 +176,197 @@ class RtcpParserTransport : public webrtc::Transport {
   int num_packets_ = 0;
 };
 
-RtcpTransceiverConfig DefaultTestConfig() {
-  // RtcpTransceiverConfig default constructor sets default values for prod.
-  // Test doesn't need to support all key features: Default test config returns
-  // valid config with all features turned off.
-  static MockTransport null_transport;
-  static SimulatedClock null_clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &null_clock;
-  config.outgoing_transport = &null_transport;
-  config.schedule_periodic_compound_packets = false;
-  config.initial_report_delay = TimeDelta::Millis(10);
-  config.report_period = kReportPeriod;
-  return config;
-}
+class RtcpTransceiverImplTest : public ::testing::Test {
+ public:
+  RtcpTransceiverConfig DefaultTestConfig() {
+    // RtcpTransceiverConfig default constructor sets default values for prod.
+    // Test doesn't need to support all key features: Default test config
+    // returns valid config with all features turned off.
+    RtcpTransceiverConfig config;
+    config.clock = time_->GetClock();
+    config.outgoing_transport = &null_transport_;
+    config.schedule_periodic_compound_packets = false;
+    config.initial_report_delay = kReportPeriod / 2;
+    config.report_period = kReportPeriod;
+    return config;
+  }
 
-TEST(RtcpTransceiverImplTest, NeedToStopPeriodicTaskToDestroyOnTaskQueue) {
-  SimulatedClock clock(0);
-  FakeRtcpTransport transport;
-  TaskQueueForTest queue("rtcp");
+  TimeController& time_controller() { return *time_; }
+  Timestamp CurrentTime() { return time_->GetClock()->CurrentTime(); }
+  void AdvanceTime(TimeDelta time) { time_->AdvanceTime(time); }
+  std::unique_ptr<TaskQueueBase, TaskQueueDeleter> CreateTaskQueue() {
+    return time_->GetTaskQueueFactory()->CreateTaskQueue(
+        "rtcp", TaskQueueFactory::Priority::NORMAL);
+  }
+
+ private:
+  MockTransport null_transport_;
+  std::unique_ptr<TimeController> time_ = CreateSimulatedTimeController();
+};
+
+TEST_F(RtcpTransceiverImplTest, NeedToStopPeriodicTaskToDestroyOnTaskQueue) {
+  FakeRtcpTransport transport(time_controller());
+  auto queue = CreateTaskQueue();
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
-  config.task_queue = queue.Get();
+  config.task_queue = queue.get();
   config.schedule_periodic_compound_packets = true;
   config.outgoing_transport = &transport;
   auto* rtcp_transceiver = new RtcpTransceiverImpl(config);
   // Wait for a periodic packet.
   EXPECT_TRUE(transport.WaitPacket());
 
-  rtc::Event done;
-  queue.PostTask([rtcp_transceiver, &done] {
+  bool done = false;
+  queue->PostTask(ToQueuedTask([rtcp_transceiver, &done] {
     rtcp_transceiver->StopPeriodicTask();
     delete rtcp_transceiver;
-    done.Set();
-  });
-  ASSERT_TRUE(done.Wait(/*milliseconds=*/1000));
+    done = true;
+  }));
+  ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
 }
 
-TEST(RtcpTransceiverImplTest, CanBeDestroyedRightAfterCreation) {
-  SimulatedClock clock(0);
-  FakeRtcpTransport transport;
-  TaskQueueForTest queue("rtcp");
+TEST_F(RtcpTransceiverImplTest, CanBeDestroyedRightAfterCreation) {
+  FakeRtcpTransport transport(time_controller());
+  auto queue = CreateTaskQueue();
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
-  config.task_queue = queue.Get();
+  config.task_queue = queue.get();
   config.schedule_periodic_compound_packets = true;
   config.outgoing_transport = &transport;
 
-  rtc::Event done;
-  queue.PostTask([&] {
+  bool done = false;
+  queue->PostTask(ToQueuedTask([&] {
     RtcpTransceiverImpl rtcp_transceiver(config);
     rtcp_transceiver.StopPeriodicTask();
-    done.Set();
-  });
-  ASSERT_TRUE(done.Wait(/*milliseconds=*/1000));
+    done = true;
+  }));
+  ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
 }
 
-TEST(RtcpTransceiverImplTest, CanDestroyAfterTaskQueue) {
-  SimulatedClock clock(0);
-  FakeRtcpTransport transport;
-  auto* queue = new TaskQueueForTest("rtcp");
+TEST_F(RtcpTransceiverImplTest, CanDestroyAfterTaskQueue) {
+  FakeRtcpTransport transport(time_controller());
+  auto queue = CreateTaskQueue();
+
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
-  config.task_queue = queue->Get();
+  config.task_queue = queue.get();
   config.schedule_periodic_compound_packets = true;
   config.outgoing_transport = &transport;
   auto* rtcp_transceiver = new RtcpTransceiverImpl(config);
   // Wait for a periodic packet.
   EXPECT_TRUE(transport.WaitPacket());
 
-  delete queue;
+  queue = nullptr;
   delete rtcp_transceiver;
 }
 
-TEST(RtcpTransceiverImplTest, DelaysSendingFirstCompondPacket) {
-  SimulatedClock clock(0);
-  TaskQueueForTest queue("rtcp");
-  FakeRtcpTransport transport;
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+TEST_F(RtcpTransceiverImplTest, DelaysSendingFirstCompondPacket) {
+  auto queue = CreateTaskQueue();
+  FakeRtcpTransport transport(time_controller());
+  RtcpTransceiverConfig config = DefaultTestConfig();
+  config.schedule_periodic_compound_packets = true;
   config.outgoing_transport = &transport;
   config.initial_report_delay = TimeDelta::Millis(10);
-  config.task_queue = queue.Get();
+  config.task_queue = queue.get();
   absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
 
-  int64_t started_ms = rtc::TimeMillis();
-  queue.PostTask([&] { rtcp_transceiver.emplace(config); });
+  Timestamp started = CurrentTime();
+  queue->PostTask(ToQueuedTask([&] { rtcp_transceiver.emplace(config); }));
   EXPECT_TRUE(transport.WaitPacket());
 
-  EXPECT_GE(rtc::TimeMillis() - started_ms, config.initial_report_delay.ms());
+  EXPECT_GE(CurrentTime() - started, config.initial_report_delay);
 
   // Cleanup.
-  rtc::Event done;
-  queue.PostTask([&] {
+  bool done = false;
+  queue->PostTask(ToQueuedTask([&] {
     rtcp_transceiver->StopPeriodicTask();
     rtcp_transceiver.reset();
-    done.Set();
-  });
-  ASSERT_TRUE(done.Wait(kAlmostForeverMs));
+    done = true;
+  }));
+  ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
 }
 
-TEST(RtcpTransceiverImplTest, PeriodicallySendsPackets) {
-  SimulatedClock clock(0);
-  TaskQueueForTest queue("rtcp");
-  FakeRtcpTransport transport;
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+TEST_F(RtcpTransceiverImplTest, PeriodicallySendsPackets) {
+  auto queue = CreateTaskQueue();
+  FakeRtcpTransport transport(time_controller());
+  RtcpTransceiverConfig config = DefaultTestConfig();
+  config.schedule_periodic_compound_packets = true;
   config.outgoing_transport = &transport;
   config.initial_report_delay = TimeDelta::Zero();
   config.report_period = kReportPeriod;
-  config.task_queue = queue.Get();
+  config.task_queue = queue.get();
   absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
-  int64_t time_just_before_1st_packet_ms = 0;
-  queue.PostTask([&] {
+  Timestamp time_just_before_1st_packet = Timestamp::MinusInfinity();
+  queue->PostTask(ToQueuedTask([&] {
     // Because initial_report_delay_ms is set to 0, time_just_before_the_packet
     // should be very close to the time_of_the_packet.
-    time_just_before_1st_packet_ms = rtc::TimeMillis();
+    time_just_before_1st_packet = CurrentTime();
     rtcp_transceiver.emplace(config);
-  });
+  }));
 
   EXPECT_TRUE(transport.WaitPacket());
   EXPECT_TRUE(transport.WaitPacket());
-  int64_t time_just_after_2nd_packet_ms = rtc::TimeMillis();
+  Timestamp time_just_after_2nd_packet = CurrentTime();
 
-  EXPECT_GE(time_just_after_2nd_packet_ms - time_just_before_1st_packet_ms,
-            config.report_period.ms() - 1);
+  EXPECT_GE(time_just_after_2nd_packet - time_just_before_1st_packet,
+            config.report_period);
 
   // Cleanup.
-  rtc::Event done;
-  queue.PostTask([&] {
+  bool done = false;
+  queue->PostTask(ToQueuedTask([&] {
     rtcp_transceiver->StopPeriodicTask();
     rtcp_transceiver.reset();
-    done.Set();
-  });
-  ASSERT_TRUE(done.Wait(kAlmostForeverMs));
+    done = true;
+  }));
+  ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
 }
 
-TEST(RtcpTransceiverImplTest, SendCompoundPacketDelaysPeriodicSendPackets) {
-  SimulatedClock clock(0);
-  TaskQueueForTest queue("rtcp");
-  FakeRtcpTransport transport;
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+TEST_F(RtcpTransceiverImplTest, SendCompoundPacketDelaysPeriodicSendPackets) {
+  auto queue = CreateTaskQueue();
+  FakeRtcpTransport transport(time_controller());
+  RtcpTransceiverConfig config = DefaultTestConfig();
+  config.schedule_periodic_compound_packets = true;
   config.outgoing_transport = &transport;
   config.initial_report_delay = TimeDelta::Zero();
   config.report_period = kReportPeriod;
-  config.task_queue = queue.Get();
+  config.task_queue = queue.get();
   absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
-  queue.PostTask([&] { rtcp_transceiver.emplace(config); });
+  queue->PostTask(ToQueuedTask([&] { rtcp_transceiver.emplace(config); }));
 
-  // Wait for first packet.
+  // Wait for the first packet.
   EXPECT_TRUE(transport.WaitPacket());
   // Send non periodic one after half period.
-  rtc::Event non_periodic;
-  int64_t time_of_non_periodic_packet_ms = 0;
-  queue.PostDelayedTask(
-      [&] {
-        time_of_non_periodic_packet_ms = rtc::TimeMillis();
-        rtcp_transceiver->SendCompoundPacket();
-        non_periodic.Set();
-      },
-      (config.report_period / 2).ms());
+  bool non_periodic = false;
+  Timestamp time_of_non_periodic_packet = Timestamp::MinusInfinity();
+  queue->PostDelayedTask(ToQueuedTask([&] {
+                           time_of_non_periodic_packet = CurrentTime();
+                           rtcp_transceiver->SendCompoundPacket();
+                           non_periodic = true;
+                         }),
+                         (config.report_period / 2).ms());
   // Though non-periodic packet is scheduled just in between periodic, due to
   // small period and task queue flakiness it migth end-up 1ms after next
   // periodic packet. To be sure duration after non-periodic packet is tested
   // wait for transport after ensuring non-periodic packet was sent.
-  EXPECT_TRUE(non_periodic.Wait(kAlmostForeverMs));
+  EXPECT_TRUE(
+      time_controller().Wait([&] { return non_periodic; }, kAlmostForever));
   EXPECT_TRUE(transport.WaitPacket());
   // Wait for next periodic packet.
   EXPECT_TRUE(transport.WaitPacket());
-  int64_t time_of_last_periodic_packet_ms = rtc::TimeMillis();
-
-  EXPECT_GE(time_of_last_periodic_packet_ms - time_of_non_periodic_packet_ms,
-            config.report_period.ms() - 1);
+  Timestamp time_of_last_periodic_packet = CurrentTime();
+  EXPECT_GE(time_of_last_periodic_packet - time_of_non_periodic_packet,
+            config.report_period);
 
   // Cleanup.
-  rtc::Event done;
-  queue.PostTask([&] {
+  bool done = false;
+  queue->PostTask(ToQueuedTask([&] {
     rtcp_transceiver->StopPeriodicTask();
     rtcp_transceiver.reset();
-    done.Set();
-  });
-  ASSERT_TRUE(done.Wait(kAlmostForeverMs));
+    done = true;
+  }));
+  ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
 }
 
-TEST(RtcpTransceiverImplTest, SendsNoRtcpWhenNetworkStateIsDown) {
-  SimulatedClock clock(0);
+TEST_F(RtcpTransceiverImplTest, SendsNoRtcpWhenNetworkStateIsDown) {
   MockTransport mock_transport;
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   config.initial_ready_to_send = false;
   config.outgoing_transport = &mock_transport;
   RtcpTransceiverImpl rtcp_transceiver(config);
@@ -388,11 +383,9 @@ TEST(RtcpTransceiverImplTest, SendsNoRtcpWhenNetworkStateIsDown) {
   rtcp_transceiver.SendFullIntraRequest(ssrcs, true);
 }
 
-TEST(RtcpTransceiverImplTest, SendsRtcpWhenNetworkStateIsUp) {
-  SimulatedClock clock(0);
+TEST_F(RtcpTransceiverImplTest, SendsRtcpWhenNetworkStateIsUp) {
   MockTransport mock_transport;
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   config.initial_ready_to_send = false;
   config.outgoing_transport = &mock_transport;
   RtcpTransceiverImpl rtcp_transceiver(config);
@@ -411,38 +404,35 @@ TEST(RtcpTransceiverImplTest, SendsRtcpWhenNetworkStateIsUp) {
   rtcp_transceiver.SendFullIntraRequest(ssrcs, true);
 }
 
-TEST(RtcpTransceiverImplTest, SendsPeriodicRtcpWhenNetworkStateIsUp) {
-  SimulatedClock clock(0);
-  TaskQueueForTest queue("rtcp");
-  FakeRtcpTransport transport;
+TEST_F(RtcpTransceiverImplTest, SendsPeriodicRtcpWhenNetworkStateIsUp) {
+  auto queue = CreateTaskQueue();
+  FakeRtcpTransport transport(time_controller());
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   config.schedule_periodic_compound_packets = true;
   config.initial_ready_to_send = false;
   config.outgoing_transport = &transport;
-  config.task_queue = queue.Get();
+  config.task_queue = queue.get();
   absl::optional<RtcpTransceiverImpl> rtcp_transceiver;
   rtcp_transceiver.emplace(config);
 
-  queue.PostTask([&] { rtcp_transceiver->SetReadyToSend(true); });
+  queue->PostTask(
+      ToQueuedTask([&] { rtcp_transceiver->SetReadyToSend(true); }));
 
   EXPECT_TRUE(transport.WaitPacket());
 
   // Cleanup.
-  rtc::Event done;
-  queue.PostTask([&] {
+  bool done = false;
+  queue->PostTask(ToQueuedTask([&] {
     rtcp_transceiver->StopPeriodicTask();
     rtcp_transceiver.reset();
-    done.Set();
-  });
-  ASSERT_TRUE(done.Wait(kAlmostForeverMs));
+    done = true;
+  }));
+  ASSERT_TRUE(time_controller().Wait([&] { return done; }, kAlmostForever));
 }
 
-TEST(RtcpTransceiverImplTest, SendsMinimalCompoundPacket) {
+TEST_F(RtcpTransceiverImplTest, SendsMinimalCompoundPacket) {
   const uint32_t kSenderSsrc = 12345;
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.feedback_ssrc = kSenderSsrc;
   config.cname = "cname";
   RtcpPacketParser rtcp_parser;
@@ -463,34 +453,28 @@ TEST(RtcpTransceiverImplTest, SendsMinimalCompoundPacket) {
   EXPECT_EQ(rtcp_parser.sdes()->chunks()[0].cname, config.cname);
 }
 
-TEST(RtcpTransceiverImplTest, AvoidsEmptyPacketsInReducedMode) {
+TEST_F(RtcpTransceiverImplTest, AvoidsEmptyPacketsInReducedMode) {
   MockTransport transport;
   EXPECT_CALL(transport, SendRtcp).Times(0);
   NiceMock<MockReceiveStatisticsProvider> receive_statistics;
-  SimulatedClock clock(0);
 
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   config.outgoing_transport = &transport;
   config.rtcp_mode = webrtc::RtcpMode::kReducedSize;
-  config.schedule_periodic_compound_packets = false;
   config.receive_statistics = &receive_statistics;
   RtcpTransceiverImpl rtcp_transceiver(config);
 
   rtcp_transceiver.SendCompoundPacket();
 }
 
-TEST(RtcpTransceiverImplTest, AvoidsEmptyReceiverReportsInReducedMode) {
+TEST_F(RtcpTransceiverImplTest, AvoidsEmptyReceiverReportsInReducedMode) {
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
   NiceMock<MockReceiveStatisticsProvider> receive_statistics;
-  SimulatedClock clock(0);
 
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   config.outgoing_transport = &transport;
   config.rtcp_mode = webrtc::RtcpMode::kReducedSize;
-  config.schedule_periodic_compound_packets = false;
   config.receive_statistics = &receive_statistics;
   // Set it to produce something (RRTR) in the "periodic" rtcp packets.
   config.non_sender_rtt_measurement = true;
@@ -504,11 +488,9 @@ TEST(RtcpTransceiverImplTest, AvoidsEmptyReceiverReportsInReducedMode) {
   EXPECT_GT(rtcp_parser.xr()->num_packets(), 0);
 }
 
-TEST(RtcpTransceiverImplTest, SendsNoRembInitially) {
+TEST_F(RtcpTransceiverImplTest, SendsNoRembInitially) {
   const uint32_t kSenderSsrc = 12345;
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.feedback_ssrc = kSenderSsrc;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -522,11 +504,9 @@ TEST(RtcpTransceiverImplTest, SendsNoRembInitially) {
   EXPECT_EQ(rtcp_parser.remb()->num_packets(), 0);
 }
 
-TEST(RtcpTransceiverImplTest, SetRembIncludesRembInNextCompoundPacket) {
+TEST_F(RtcpTransceiverImplTest, SetRembIncludesRembInNextCompoundPacket) {
   const uint32_t kSenderSsrc = 12345;
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.feedback_ssrc = kSenderSsrc;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -543,11 +523,9 @@ TEST(RtcpTransceiverImplTest, SetRembIncludesRembInNextCompoundPacket) {
   EXPECT_THAT(rtcp_parser.remb()->ssrcs(), ElementsAre(54321, 64321));
 }
 
-TEST(RtcpTransceiverImplTest, SetRembUpdatesValuesToSend) {
+TEST_F(RtcpTransceiverImplTest, SetRembUpdatesValuesToSend) {
   const uint32_t kSenderSsrc = 12345;
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.feedback_ssrc = kSenderSsrc;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -570,11 +548,9 @@ TEST(RtcpTransceiverImplTest, SetRembUpdatesValuesToSend) {
   EXPECT_THAT(rtcp_parser.remb()->ssrcs(), ElementsAre(67321));
 }
 
-TEST(RtcpTransceiverImplTest, SetRembSendsImmediatelyIfSendRembOnChange) {
+TEST_F(RtcpTransceiverImplTest, SetRembSendsImmediatelyIfSendRembOnChange) {
   const uint32_t kSenderSsrc = 12345;
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.send_remb_on_change = true;
   config.feedback_ssrc = kSenderSsrc;
   RtcpPacketParser rtcp_parser;
@@ -597,12 +573,10 @@ TEST(RtcpTransceiverImplTest, SetRembSendsImmediatelyIfSendRembOnChange) {
   EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 20000);
 }
 
-TEST(RtcpTransceiverImplTest,
-     SetRembSendsImmediatelyIfSendRembOnChangeReducedSize) {
+TEST_F(RtcpTransceiverImplTest,
+       SetRembSendsImmediatelyIfSendRembOnChangeReducedSize) {
   const uint32_t kSenderSsrc = 12345;
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.send_remb_on_change = true;
   config.rtcp_mode = webrtc::RtcpMode::kReducedSize;
   config.feedback_ssrc = kSenderSsrc;
@@ -618,11 +592,9 @@ TEST(RtcpTransceiverImplTest,
   EXPECT_EQ(rtcp_parser.remb()->bitrate_bps(), 10000);
 }
 
-TEST(RtcpTransceiverImplTest, SetRembIncludesRembInAllCompoundPackets) {
+TEST_F(RtcpTransceiverImplTest, SetRembIncludesRembInAllCompoundPackets) {
   const uint32_t kSenderSsrc = 12345;
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.feedback_ssrc = kSenderSsrc;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -638,11 +610,9 @@ TEST(RtcpTransceiverImplTest, SetRembIncludesRembInAllCompoundPackets) {
   EXPECT_EQ(rtcp_parser.remb()->num_packets(), 2);
 }
 
-TEST(RtcpTransceiverImplTest, SendsNoRembAfterUnset) {
+TEST_F(RtcpTransceiverImplTest, SendsNoRembAfterUnset) {
   const uint32_t kSenderSsrc = 12345;
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.feedback_ssrc = kSenderSsrc;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -662,7 +632,7 @@ TEST(RtcpTransceiverImplTest, SendsNoRembAfterUnset) {
   EXPECT_EQ(rtcp_parser.remb()->num_packets(), 1);
 }
 
-TEST(RtcpTransceiverImplTest, ReceiverReportUsesReceiveStatistics) {
+TEST_F(RtcpTransceiverImplTest, ReceiverReportUsesReceiveStatistics) {
   const uint32_t kSenderSsrc = 12345;
   const uint32_t kMediaSsrc = 54321;
   MockReceiveStatisticsProvider receive_statistics;
@@ -671,9 +641,7 @@ TEST(RtcpTransceiverImplTest, ReceiverReportUsesReceiveStatistics) {
   EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
       .WillRepeatedly(Return(report_blocks));
 
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.feedback_ssrc = kSenderSsrc;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -692,13 +660,11 @@ TEST(RtcpTransceiverImplTest, ReceiverReportUsesReceiveStatistics) {
             kMediaSsrc);
 }
 
-TEST(RtcpTransceiverImplTest, MultipleObserversOnSameSsrc) {
+TEST_F(RtcpTransceiverImplTest, MultipleObserversOnSameSsrc) {
   const uint32_t kRemoteSsrc = 12345;
-  SimulatedClock clock(0);
   StrictMock<MockMediaReceiverRtcpObserver> observer1;
   StrictMock<MockMediaReceiverRtcpObserver> observer2;
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer2);
@@ -716,13 +682,11 @@ TEST(RtcpTransceiverImplTest, MultipleObserversOnSameSsrc) {
   rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
-TEST(RtcpTransceiverImplTest, DoesntCallsObserverAfterRemoved) {
+TEST_F(RtcpTransceiverImplTest, DoesntCallsObserverAfterRemoved) {
   const uint32_t kRemoteSsrc = 12345;
-  SimulatedClock clock(0);
   StrictMock<MockMediaReceiverRtcpObserver> observer1;
   StrictMock<MockMediaReceiverRtcpObserver> observer2;
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer1);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer2);
@@ -738,14 +702,12 @@ TEST(RtcpTransceiverImplTest, DoesntCallsObserverAfterRemoved) {
   rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
-TEST(RtcpTransceiverImplTest, CallsObserverOnSenderReportBySenderSsrc) {
+TEST_F(RtcpTransceiverImplTest, CallsObserverOnSenderReportBySenderSsrc) {
   const uint32_t kRemoteSsrc1 = 12345;
   const uint32_t kRemoteSsrc2 = 22345;
-  SimulatedClock clock(0);
   StrictMock<MockMediaReceiverRtcpObserver> observer1;
   StrictMock<MockMediaReceiverRtcpObserver> observer2;
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
@@ -759,18 +721,16 @@ TEST(RtcpTransceiverImplTest, CallsObserverOnSenderReportBySenderSsrc) {
   auto raw_packet = sr.Build();
 
   EXPECT_CALL(observer1, OnSenderReport(kRemoteSsrc1, kRemoteNtp, kRemoteRtp));
-  EXPECT_CALL(observer2, OnSenderReport(_, _, _)).Times(0);
+  EXPECT_CALL(observer2, OnSenderReport).Times(0);
   rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
-TEST(RtcpTransceiverImplTest, CallsObserverOnByeBySenderSsrc) {
+TEST_F(RtcpTransceiverImplTest, CallsObserverOnByeBySenderSsrc) {
   const uint32_t kRemoteSsrc1 = 12345;
   const uint32_t kRemoteSsrc2 = 22345;
-  SimulatedClock clock(0);
   StrictMock<MockMediaReceiverRtcpObserver> observer1;
   StrictMock<MockMediaReceiverRtcpObserver> observer2;
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
@@ -784,14 +744,12 @@ TEST(RtcpTransceiverImplTest, CallsObserverOnByeBySenderSsrc) {
   rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
-TEST(RtcpTransceiverImplTest, CallsObserverOnTargetBitrateBySenderSsrc) {
+TEST_F(RtcpTransceiverImplTest, CallsObserverOnTargetBitrateBySenderSsrc) {
   const uint32_t kRemoteSsrc1 = 12345;
   const uint32_t kRemoteSsrc2 = 22345;
-  SimulatedClock clock(0);
   StrictMock<MockMediaReceiverRtcpObserver> observer1;
   StrictMock<MockMediaReceiverRtcpObserver> observer2;
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc1, &observer1);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc2, &observer2);
@@ -816,12 +774,10 @@ TEST(RtcpTransceiverImplTest, CallsObserverOnTargetBitrateBySenderSsrc) {
   rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
-TEST(RtcpTransceiverImplTest, SkipsIncorrectTargetBitrateEntries) {
+TEST_F(RtcpTransceiverImplTest, SkipsIncorrectTargetBitrateEntries) {
   const uint32_t kRemoteSsrc = 12345;
-  SimulatedClock clock(0);
   MockMediaReceiverRtcpObserver observer;
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
 
@@ -841,12 +797,10 @@ TEST(RtcpTransceiverImplTest, SkipsIncorrectTargetBitrateEntries) {
   rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
-TEST(RtcpTransceiverImplTest, CallsObserverOnByeBehindSenderReport) {
+TEST_F(RtcpTransceiverImplTest, CallsObserverOnByeBehindSenderReport) {
   const uint32_t kRemoteSsrc = 12345;
-  SimulatedClock clock(0);
   MockMediaReceiverRtcpObserver observer;
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
 
@@ -864,12 +818,10 @@ TEST(RtcpTransceiverImplTest, CallsObserverOnByeBehindSenderReport) {
   rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
-TEST(RtcpTransceiverImplTest, CallsObserverOnByeBehindUnknownRtcpPacket) {
+TEST_F(RtcpTransceiverImplTest, CallsObserverOnByeBehindUnknownRtcpPacket) {
   const uint32_t kRemoteSsrc = 12345;
-  SimulatedClock clock(0);
   MockMediaReceiverRtcpObserver observer;
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   RtcpTransceiverImpl rtcp_transceiver(config);
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, &observer);
 
@@ -886,8 +838,8 @@ TEST(RtcpTransceiverImplTest, CallsObserverOnByeBehindUnknownRtcpPacket) {
   rtcp_transceiver.ReceivePacket(raw_packet, Timestamp::Micros(0));
 }
 
-TEST(RtcpTransceiverImplTest,
-     WhenSendsReceiverReportSetsLastSenderReportTimestampPerRemoteSsrc) {
+TEST_F(RtcpTransceiverImplTest,
+       WhenSendsReceiverReportSetsLastSenderReportTimestampPerRemoteSsrc) {
   const uint32_t kRemoteSsrc1 = 4321;
   const uint32_t kRemoteSsrc2 = 5321;
   std::vector<ReportBlock> statistics_report_blocks(2);
@@ -897,9 +849,7 @@ TEST(RtcpTransceiverImplTest,
   EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
       .WillOnce(Return(statistics_report_blocks));
 
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -932,8 +882,8 @@ TEST(RtcpTransceiverImplTest,
   EXPECT_EQ(report_blocks[1].last_sr(), 0u);
 }
 
-TEST(RtcpTransceiverImplTest,
-     WhenSendsReceiverReportCalculatesDelaySinceLastSenderReport) {
+TEST_F(RtcpTransceiverImplTest,
+       WhenSendsReceiverReportCalculatesDelaySinceLastSenderReport) {
   const uint32_t kRemoteSsrc1 = 4321;
   const uint32_t kRemoteSsrc2 = 5321;
 
@@ -944,9 +894,7 @@ TEST(RtcpTransceiverImplTest,
   EXPECT_CALL(receive_statistics, RtcpReportBlocks(_))
       .WillOnce(Return(statistics_report_blocks));
 
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -954,19 +902,17 @@ TEST(RtcpTransceiverImplTest,
   config.receive_statistics = &receive_statistics;
   RtcpTransceiverImpl rtcp_transceiver(config);
 
-  auto receive_sender_report = [&rtcp_transceiver,
-                                &clock](uint32_t remote_ssrc) {
+  auto receive_sender_report = [&](uint32_t remote_ssrc) {
     SenderReport sr;
     sr.SetSenderSsrc(remote_ssrc);
-    auto raw_packet = sr.Build();
-    rtcp_transceiver.ReceivePacket(raw_packet, clock.CurrentTime());
+    rtcp_transceiver.ReceivePacket(sr.Build(), CurrentTime());
   };
 
   receive_sender_report(kRemoteSsrc1);
-  clock.AdvanceTime(TimeDelta::Millis(100));
+  time_controller().AdvanceTime(TimeDelta::Millis(100));
 
   receive_sender_report(kRemoteSsrc2);
-  clock.AdvanceTime(TimeDelta::Millis(100));
+  time_controller().AdvanceTime(TimeDelta::Millis(100));
 
   // Trigger ReceiverReport back.
   rtcp_transceiver.SendCompoundPacket();
@@ -986,15 +932,13 @@ TEST(RtcpTransceiverImplTest,
               Near(TimeDelta::Millis(100)));
 }
 
-TEST(RtcpTransceiverImplTest, MaySendMultipleReceiverReportInSinglePacket) {
+TEST_F(RtcpTransceiverImplTest, MaySendMultipleReceiverReportInSinglePacket) {
   std::vector<ReportBlock> statistics_report_blocks(40);
   MockReceiveStatisticsProvider receive_statistics;
   EXPECT_CALL(receive_statistics, RtcpReportBlocks(/*max_blocks=*/Ge(40u)))
       .WillOnce(Return(statistics_report_blocks));
 
-  SimulatedClock clock(0);
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
   config.outgoing_transport = &transport;
@@ -1014,15 +958,13 @@ TEST(RtcpTransceiverImplTest, MaySendMultipleReceiverReportInSinglePacket) {
   EXPECT_THAT(rtcp_parser.receiver_report()->report_blocks(), SizeIs(9));
 }
 
-TEST(RtcpTransceiverImplTest, AttachMaxNumberOfReportBlocksToCompoundPacket) {
+TEST_F(RtcpTransceiverImplTest, AttachMaxNumberOfReportBlocksToCompoundPacket) {
   MockReceiveStatisticsProvider receive_statistics;
   EXPECT_CALL(receive_statistics, RtcpReportBlocks)
       .WillOnce([](size_t max_blocks) {
         return std::vector<ReportBlock>(max_blocks);
       });
-  SimulatedClock clock(0);
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   config.rtcp_mode = RtcpMode::kCompound;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -1041,13 +983,11 @@ TEST(RtcpTransceiverImplTest, AttachMaxNumberOfReportBlocksToCompoundPacket) {
   EXPECT_EQ(rtcp_parser.pli()->num_packets(), 1);
 }
 
-TEST(RtcpTransceiverImplTest, SendsNack) {
+TEST_F(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;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.feedback_ssrc = kSenderSsrc;
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
@@ -1063,7 +1003,7 @@ TEST(RtcpTransceiverImplTest, SendsNack) {
   EXPECT_EQ(rtcp_parser.nack()->packet_ids(), kMissingSequenceNumbers);
 }
 
-TEST(RtcpTransceiverImplTest, ReceivesNack) {
+TEST_F(RtcpTransceiverImplTest, ReceivesNack) {
   static constexpr uint32_t kRemoteSsrc = 4321;
   static constexpr uint32_t kMediaSsrc1 = 1234;
   static constexpr uint32_t kMediaSsrc2 = 1235;
@@ -1087,12 +1027,10 @@ TEST(RtcpTransceiverImplTest, ReceivesNack) {
   rtcp_transceiver.ReceivePacket(nack.Build(), config.clock->CurrentTime());
 }
 
-TEST(RtcpTransceiverImplTest, RequestKeyFrameWithPictureLossIndication) {
+TEST_F(RtcpTransceiverImplTest, RequestKeyFrameWithPictureLossIndication) {
   const uint32_t kSenderSsrc = 1234;
   const uint32_t kRemoteSsrc = 4321;
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.feedback_ssrc = kSenderSsrc;
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
@@ -1108,7 +1046,7 @@ TEST(RtcpTransceiverImplTest, RequestKeyFrameWithPictureLossIndication) {
   EXPECT_EQ(rtcp_parser.pli()->media_ssrc(), kRemoteSsrc);
 }
 
-TEST(RtcpTransceiverImplTest, ReceivesPictureLossIndication) {
+TEST_F(RtcpTransceiverImplTest, ReceivesPictureLossIndication) {
   static constexpr uint32_t kRemoteSsrc = 4321;
   static constexpr uint32_t kMediaSsrc1 = 1234;
   static constexpr uint32_t kMediaSsrc2 = 1235;
@@ -1129,12 +1067,10 @@ TEST(RtcpTransceiverImplTest, ReceivesPictureLossIndication) {
   rtcp_transceiver.ReceivePacket(pli.Build(), config.clock->CurrentTime());
 }
 
-TEST(RtcpTransceiverImplTest, RequestKeyFrameWithFullIntraRequest) {
+TEST_F(RtcpTransceiverImplTest, RequestKeyFrameWithFullIntraRequest) {
   const uint32_t kSenderSsrc = 1234;
   const uint32_t kRemoteSsrcs[] = {4321, 5321};
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.feedback_ssrc = kSenderSsrc;
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
@@ -1150,10 +1086,8 @@ TEST(RtcpTransceiverImplTest, RequestKeyFrameWithFullIntraRequest) {
   EXPECT_EQ(rtcp_parser.fir()->requests()[1].ssrc, kRemoteSsrcs[1]);
 }
 
-TEST(RtcpTransceiverImplTest, RequestKeyFrameWithFirIncreaseSeqNoPerSsrc) {
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+TEST_F(RtcpTransceiverImplTest, RequestKeyFrameWithFirIncreaseSeqNoPerSsrc) {
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -1182,10 +1116,8 @@ TEST(RtcpTransceiverImplTest, RequestKeyFrameWithFirIncreaseSeqNoPerSsrc) {
   EXPECT_EQ(rtcp_parser.fir()->requests()[1].seq_nr, fir_sequence_number1 + 1);
 }
 
-TEST(RtcpTransceiverImplTest, SendFirDoesNotIncreaseSeqNoIfOldRequest) {
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+TEST_F(RtcpTransceiverImplTest, SendFirDoesNotIncreaseSeqNoIfOldRequest) {
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -1209,7 +1141,7 @@ TEST(RtcpTransceiverImplTest, SendFirDoesNotIncreaseSeqNoIfOldRequest) {
   EXPECT_EQ(rtcp_parser.fir()->requests()[1].seq_nr, fir_sequence_number1);
 }
 
-TEST(RtcpTransceiverImplTest, ReceivesFir) {
+TEST_F(RtcpTransceiverImplTest, ReceivesFir) {
   static constexpr uint32_t kRemoteSsrc = 4321;
   static constexpr uint32_t kMediaSsrc1 = 1234;
   static constexpr uint32_t kMediaSsrc2 = 1235;
@@ -1231,7 +1163,7 @@ TEST(RtcpTransceiverImplTest, ReceivesFir) {
   rtcp_transceiver.ReceivePacket(fir.Build(), config.clock->CurrentTime());
 }
 
-TEST(RtcpTransceiverImplTest, IgnoresReceivedFirWithRepeatedSequenceNumber) {
+TEST_F(RtcpTransceiverImplTest, IgnoresReceivedFirWithRepeatedSequenceNumber) {
   static constexpr uint32_t kRemoteSsrc = 4321;
   static constexpr uint32_t kMediaSsrc1 = 1234;
   static constexpr uint32_t kMediaSsrc2 = 1235;
@@ -1261,7 +1193,7 @@ TEST(RtcpTransceiverImplTest, IgnoresReceivedFirWithRepeatedSequenceNumber) {
   rtcp_transceiver.ReceivePacket(fir2.Build(), config.clock->CurrentTime());
 }
 
-TEST(RtcpTransceiverImplTest, ReceivedFirTracksSequenceNumberPerRemoteSsrc) {
+TEST_F(RtcpTransceiverImplTest, ReceivedFirTracksSequenceNumberPerRemoteSsrc) {
   static constexpr uint32_t kRemoteSsrc1 = 4321;
   static constexpr uint32_t kRemoteSsrc2 = 4323;
   static constexpr uint32_t kMediaSsrc = 1234;
@@ -1286,11 +1218,9 @@ TEST(RtcpTransceiverImplTest, ReceivedFirTracksSequenceNumberPerRemoteSsrc) {
   rtcp_transceiver.ReceivePacket(fir2.Build(), config.clock->CurrentTime());
 }
 
-TEST(RtcpTransceiverImplTest, KeyFrameRequestCreatesCompoundPacket) {
+TEST_F(RtcpTransceiverImplTest, KeyFrameRequestCreatesCompoundPacket) {
   const uint32_t kRemoteSsrcs[] = {4321};
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   // Turn periodic off to ensure sent rtcp packet is explicitly requested.
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
@@ -1307,11 +1237,9 @@ TEST(RtcpTransceiverImplTest, KeyFrameRequestCreatesCompoundPacket) {
   EXPECT_EQ(rtcp_parser.receiver_report()->num_packets(), 1);
 }
 
-TEST(RtcpTransceiverImplTest, KeyFrameRequestCreatesReducedSizePacket) {
+TEST_F(RtcpTransceiverImplTest, KeyFrameRequestCreatesReducedSizePacket) {
   const uint32_t kRemoteSsrcs[] = {4321};
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   // Turn periodic off to ensure sent rtcp packet is explicitly requested.
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
@@ -1328,11 +1256,9 @@ TEST(RtcpTransceiverImplTest, KeyFrameRequestCreatesReducedSizePacket) {
   EXPECT_EQ(rtcp_parser.receiver_report()->num_packets(), 0);
 }
 
-TEST(RtcpTransceiverImplTest, SendsXrRrtrWhenEnabled) {
+TEST_F(RtcpTransceiverImplTest, SendsXrRrtrWhenEnabled) {
   const uint32_t kSenderSsrc = 4321;
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.feedback_ssrc = kSenderSsrc;
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
@@ -1342,7 +1268,7 @@ TEST(RtcpTransceiverImplTest, SendsXrRrtrWhenEnabled) {
   RtcpTransceiverImpl rtcp_transceiver(config);
 
   rtcp_transceiver.SendCompoundPacket();
-  NtpTime ntp_time_now = clock.CurrentNtpTime();
+  NtpTime ntp_time_now = config.clock->CurrentNtpTime();
 
   EXPECT_EQ(rtcp_parser.xr()->num_packets(), 1);
   EXPECT_EQ(rtcp_parser.xr()->sender_ssrc(), kSenderSsrc);
@@ -1350,11 +1276,9 @@ TEST(RtcpTransceiverImplTest, SendsXrRrtrWhenEnabled) {
   EXPECT_EQ(rtcp_parser.xr()->rrtr()->ntp(), ntp_time_now);
 }
 
-TEST(RtcpTransceiverImplTest, RepliesToRrtrWhenEnabled) {
+TEST_F(RtcpTransceiverImplTest, RepliesToRrtrWhenEnabled) {
   static constexpr uint32_t kSenderSsrc[] = {4321, 9876};
-  SimulatedClock clock(0);
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   config.reply_to_non_sender_rtt_measurement = true;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -1366,14 +1290,14 @@ TEST(RtcpTransceiverImplTest, RepliesToRrtrWhenEnabled) {
   rrtr.SetNtp(NtpTime(uint64_t{0x1111'2222'3333'4444}));
   xr.SetRrtr(rrtr);
   xr.SetSenderSsrc(kSenderSsrc[0]);
-  rtcp_transceiver.ReceivePacket(xr.Build(), clock.CurrentTime());
-  clock.AdvanceTime(TimeDelta::Millis(1'500));
+  rtcp_transceiver.ReceivePacket(xr.Build(), CurrentTime());
+  AdvanceTime(TimeDelta::Millis(1'500));
 
   rrtr.SetNtp(NtpTime(uint64_t{0x4444'5555'6666'7777}));
   xr.SetRrtr(rrtr);
   xr.SetSenderSsrc(kSenderSsrc[1]);
-  rtcp_transceiver.ReceivePacket(xr.Build(), clock.CurrentTime());
-  clock.AdvanceTime(TimeDelta::Millis(500));
+  rtcp_transceiver.ReceivePacket(xr.Build(), CurrentTime());
+  AdvanceTime(TimeDelta::Millis(500));
 
   rtcp_transceiver.SendCompoundPacket();
 
@@ -1387,12 +1311,10 @@ TEST(RtcpTransceiverImplTest, RepliesToRrtrWhenEnabled) {
                                         /*delay=*/kComactNtpOneSecond / 2)));
 }
 
-TEST(RtcpTransceiverImplTest, CanReplyToRrtrOnceForAllLocalSsrcs) {
+TEST_F(RtcpTransceiverImplTest, CanReplyToRrtrOnceForAllLocalSsrcs) {
   static constexpr uint32_t kRemoteSsrc = 4321;
   static constexpr uint32_t kLocalSsrcs[] = {1234, 5678};
-  SimulatedClock clock(0);
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   config.reply_to_non_sender_rtt_measurement = true;
   config.reply_to_non_sender_rtt_mesaurments_on_all_ssrcs = false;
   RtcpPacketParser rtcp_parser;
@@ -1410,20 +1332,18 @@ TEST(RtcpTransceiverImplTest, CanReplyToRrtrOnceForAllLocalSsrcs) {
   rrtr.SetNtp(NtpTime(uint64_t{0x1111'2222'3333'4444}));
   xr.SetRrtr(rrtr);
   xr.SetSenderSsrc(kRemoteSsrc);
-  rtcp_transceiver.ReceivePacket(xr.Build(), clock.CurrentTime());
-  clock.AdvanceTime(TimeDelta::Millis(1'500));
+  rtcp_transceiver.ReceivePacket(xr.Build(), CurrentTime());
+  AdvanceTime(TimeDelta::Millis(1'500));
 
   rtcp_transceiver.SendCompoundPacket();
 
   EXPECT_EQ(rtcp_parser.xr()->num_packets(), 1);
 }
 
-TEST(RtcpTransceiverImplTest, CanReplyToRrtrForEachLocalSsrc) {
+TEST_F(RtcpTransceiverImplTest, CanReplyToRrtrForEachLocalSsrc) {
   static constexpr uint32_t kRemoteSsrc = 4321;
   static constexpr uint32_t kLocalSsrc[] = {1234, 5678};
-  SimulatedClock clock(0);
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   config.reply_to_non_sender_rtt_measurement = true;
   config.reply_to_non_sender_rtt_mesaurments_on_all_ssrcs = true;
   RtcpPacketParser rtcp_parser;
@@ -1441,18 +1361,16 @@ TEST(RtcpTransceiverImplTest, CanReplyToRrtrForEachLocalSsrc) {
   rrtr.SetNtp(NtpTime(uint64_t{0x1111'2222'3333'4444}));
   xr.SetRrtr(rrtr);
   xr.SetSenderSsrc(kRemoteSsrc);
-  rtcp_transceiver.ReceivePacket(xr.Build(), clock.CurrentTime());
-  clock.AdvanceTime(TimeDelta::Millis(1'500));
+  rtcp_transceiver.ReceivePacket(xr.Build(), CurrentTime());
+  AdvanceTime(TimeDelta::Millis(1'500));
 
   rtcp_transceiver.SendCompoundPacket();
 
   EXPECT_EQ(rtcp_parser.xr()->num_packets(), 2);
 }
 
-TEST(RtcpTransceiverImplTest, SendsNoXrRrtrWhenDisabled) {
-  SimulatedClock clock(0);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+TEST_F(RtcpTransceiverImplTest, SendsNoXrRrtrWhenDisabled) {
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.schedule_periodic_compound_packets = false;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -1468,7 +1386,7 @@ TEST(RtcpTransceiverImplTest, SendsNoXrRrtrWhenDisabled) {
   EXPECT_FALSE(rtcp_parser.xr()->rrtr());
 }
 
-TEST(RtcpTransceiverImplTest, PassRttFromDlrrToLinkObserver) {
+TEST_F(RtcpTransceiverImplTest, PassRttFromDlrrToLinkObserver) {
   const uint32_t kSenderSsrc = 4321;
   MockNetworkLinkRtcpObserver link_observer;
   RtcpTransceiverConfig config = DefaultTestConfig();
@@ -1491,7 +1409,7 @@ TEST(RtcpTransceiverImplTest, PassRttFromDlrrToLinkObserver) {
   rtcp_transceiver.ReceivePacket(xr.Build(), receive_time);
 }
 
-TEST(RtcpTransceiverImplTest, CalculatesRoundTripTimeFromReportBlocks) {
+TEST_F(RtcpTransceiverImplTest, CalculatesRoundTripTimeFromReportBlocks) {
   MockNetworkLinkRtcpObserver link_observer;
   RtcpTransceiverConfig config = DefaultTestConfig();
   config.network_link_observer = &link_observer;
@@ -1516,14 +1434,12 @@ TEST(RtcpTransceiverImplTest, CalculatesRoundTripTimeFromReportBlocks) {
   rtcp_transceiver.ReceivePacket(rr.Build(), receive_time);
 }
 
-TEST(RtcpTransceiverImplTest, IgnoresUnknownSsrcInDlrr) {
+TEST_F(RtcpTransceiverImplTest, IgnoresUnknownSsrcInDlrr) {
   const uint32_t kSenderSsrc = 4321;
   const uint32_t kUnknownSsrc = 4322;
-  SimulatedClock clock(0);
   MockNetworkLinkRtcpObserver link_observer;
   MockTransport null_transport;
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.feedback_ssrc = kSenderSsrc;
   config.schedule_periodic_compound_packets = false;
   config.outgoing_transport = &null_transport;
@@ -1534,7 +1450,7 @@ TEST(RtcpTransceiverImplTest, IgnoresUnknownSsrcInDlrr) {
   Timestamp time = Timestamp::Micros(12345678);
   webrtc::rtcp::ReceiveTimeInfo rti;
   rti.ssrc = kUnknownSsrc;
-  rti.last_rr = CompactNtp(clock.ConvertTimestampToNtpTime(time));
+  rti.last_rr = CompactNtp(config.clock->ConvertTimestampToNtpTime(time));
   webrtc::rtcp::ExtendedReports xr;
   xr.AddDlrrItem(rti);
   auto raw_packet = xr.Build();
@@ -1543,7 +1459,7 @@ TEST(RtcpTransceiverImplTest, IgnoresUnknownSsrcInDlrr) {
   rtcp_transceiver.ReceivePacket(raw_packet, time + TimeDelta::Millis(100));
 }
 
-TEST(RtcpTransceiverImplTest, ParsesTransportFeedback) {
+TEST_F(RtcpTransceiverImplTest, ParsesTransportFeedback) {
   MockNetworkLinkRtcpObserver link_observer;
   RtcpTransceiverConfig config = DefaultTestConfig();
   config.network_link_observer = &link_observer;
@@ -1563,7 +1479,7 @@ TEST(RtcpTransceiverImplTest, ParsesTransportFeedback) {
   rtcp_transceiver.ReceivePacket(tb.Build(), receive_time);
 }
 
-TEST(RtcpTransceiverImplTest, ParsesRemb) {
+TEST_F(RtcpTransceiverImplTest, ParsesRemb) {
   MockNetworkLinkRtcpObserver link_observer;
   RtcpTransceiverConfig config = DefaultTestConfig();
   config.network_link_observer = &link_observer;
@@ -1579,8 +1495,8 @@ TEST(RtcpTransceiverImplTest, ParsesRemb) {
   rtcp_transceiver.ReceivePacket(remb.Build(), receive_time);
 }
 
-TEST(RtcpTransceiverImplTest,
-     CombinesReportBlocksFromSenderAndReceiverReports) {
+TEST_F(RtcpTransceiverImplTest,
+       CombinesReportBlocksFromSenderAndRecieverReports) {
   MockNetworkLinkRtcpObserver link_observer;
   RtcpTransceiverConfig config = DefaultTestConfig();
   config.network_link_observer = &link_observer;
@@ -1605,8 +1521,8 @@ TEST(RtcpTransceiverImplTest,
   rtcp_transceiver.ReceivePacket(packet.Build(), receive_time);
 }
 
-TEST(RtcpTransceiverImplTest,
-     CallbackOnReportBlocksFromSenderAndReceiverReports) {
+TEST_F(RtcpTransceiverImplTest,
+       CallbackOnReportBlocksFromSenderAndReceiverReports) {
   static constexpr uint32_t kRemoteSsrc = 5678;
   // Has registered sender, report block attached to sender report.
   static constexpr uint32_t kMediaSsrc1 = 1234;
@@ -1653,7 +1569,7 @@ TEST(RtcpTransceiverImplTest,
   rtcp_transceiver.ReceivePacket(packet.Build(), receive_time);
 }
 
-TEST(RtcpTransceiverImplTest, FailsToRegisterTwoSendersWithTheSameSsrc) {
+TEST_F(RtcpTransceiverImplTest, FailsToRegisterTwoSendersWithTheSameSsrc) {
   RtcpTransceiverImpl rtcp_transceiver(DefaultTestConfig());
   MockRtpStreamRtcpHandler sender1;
   MockRtpStreamRtcpHandler sender2;
@@ -1666,12 +1582,10 @@ TEST(RtcpTransceiverImplTest, FailsToRegisterTwoSendersWithTheSameSsrc) {
   EXPECT_FALSE(rtcp_transceiver.RemoveMediaSender(/*local_ssrc=*/10001));
 }
 
-TEST(RtcpTransceiverImplTest, SendsSenderReport) {
+TEST_F(RtcpTransceiverImplTest, SendsSenderReport) {
   static constexpr uint32_t kFeedbackSsrc = 123;
   static constexpr uint32_t kSenderSsrc = 12345;
-  SimulatedClock clock(100'000'000);
-  RtcpTransceiverConfig config;
-  config.clock = &clock;
+  RtcpTransceiverConfig config = DefaultTestConfig();
   config.feedback_ssrc = kFeedbackSsrc;
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
@@ -1683,8 +1597,7 @@ TEST(RtcpTransceiverImplTest, SendsSenderReport) {
   sender_stats.set_num_sent_packets(10);
   sender_stats.set_num_sent_bytes(1000);
   sender_stats.set_last_rtp_timestamp(0x3333);
-  sender_stats.set_last_capture_time(clock.CurrentTime() -
-                                     TimeDelta::Seconds(2));
+  sender_stats.set_last_capture_time(CurrentTime() - TimeDelta::Seconds(2));
   sender_stats.set_last_clock_rate(0x1000);
   MockRtpStreamRtcpHandler sender;
   ON_CALL(sender, SentStats).WillByDefault(Return(sender_stats));
@@ -1694,14 +1607,15 @@ TEST(RtcpTransceiverImplTest, SendsSenderReport) {
 
   ASSERT_GT(rtcp_parser.sender_report()->num_packets(), 0);
   EXPECT_EQ(rtcp_parser.sender_report()->sender_ssrc(), kSenderSsrc);
-  EXPECT_EQ(rtcp_parser.sender_report()->ntp(), clock.CurrentNtpTime());
+  EXPECT_EQ(rtcp_parser.sender_report()->ntp(),
+            time_controller().GetClock()->CurrentNtpTime());
   EXPECT_EQ(rtcp_parser.sender_report()->rtp_timestamp(), 0x3333u + 0x2000u);
   EXPECT_EQ(rtcp_parser.sender_report()->sender_packet_count(), 10u);
   EXPECT_EQ(rtcp_parser.sender_report()->sender_octet_count(), 1000u);
 }
 
-TEST(RtcpTransceiverImplTest,
-     MaySendBothSenderReportAndReceiverReportInTheSamePacket) {
+TEST_F(RtcpTransceiverImplTest,
+       MaySendBothSenderReportAndReceiverReportInTheSamePacket) {
   RtcpPacketParser rtcp_parser;
   RtcpParserTransport transport(&rtcp_parser);
   std::vector<ReportBlock> statistics_report_blocks(40);
@@ -1728,18 +1642,16 @@ TEST(RtcpTransceiverImplTest,
   EXPECT_THAT(rtcp_parser.receiver_report()->report_blocks(), SizeIs(9));
 }
 
-TEST(RtcpTransceiverImplTest, RotatesSendersWhenAllSenderReportDoNotFit) {
+TEST_F(RtcpTransceiverImplTest, RotatesSendersWhenAllSenderReportDoNotFit) {
   // Send 6 compound packet, each should contain 5 sender reports,
   // each of 6 senders should be mentioned 5 times.
   static constexpr int kNumSenders = 6;
   static constexpr uint32_t kSenderSsrc[kNumSenders] = {10, 20, 30, 40, 50, 60};
   static constexpr int kSendersPerPacket = 5;
-  SimulatedClock clock(100'000'000);
   // RtcpPacketParser remembers only latest block for each type, but this test
   // is about sending multiple sender reports in the same packet, thus need
   // a more advance parser: RtcpTranceiver
   RtcpTransceiverConfig receiver_config = DefaultTestConfig();
-  receiver_config.clock = &clock;
   RtcpTransceiverImpl rtcp_receiver(receiver_config);
   // Main expectatation: all senders are spread equally across multiple packets.
   NiceMock<MockMediaReceiverRtcpObserver> receiver[kNumSenders];
@@ -1755,11 +1667,10 @@ TEST(RtcpTransceiverImplTest, RotatesSendersWhenAllSenderReportDoNotFit) {
       .Times(kNumSenders)
       .WillRepeatedly([&](const uint8_t* data, size_t size) {
         rtcp_receiver.ReceivePacket(rtc::MakeArrayView(data, size),
-                                    clock.CurrentTime());
+                                    CurrentTime());
         return true;
       });
   RtcpTransceiverConfig config = DefaultTestConfig();
-  config.clock = &clock;
   config.outgoing_transport = &transport;
   // Limit packet to have space just for kSendersPerPacket sender reports.
   // Sender report without report blocks require 28 bytes.
@@ -1776,7 +1687,7 @@ TEST(RtcpTransceiverImplTest, RotatesSendersWhenAllSenderReportDoNotFit) {
   }
 }
 
-TEST(RtcpTransceiverImplTest, SkipsSenderReportForInactiveSender) {
+TEST_F(RtcpTransceiverImplTest, SkipsSenderReportForInactiveSender) {
   static constexpr uint32_t kSenderSsrc[] = {12345, 23456};
   RtcpTransceiverConfig config = DefaultTestConfig();
   RtcpPacketParser rtcp_parser;