Use GlobalSimulatedTimeController in PortTest

Bug: webrtc:381524905,webrtc:42223992,webrtc:469327588
Change-Id: If4bb795c0ab03e889fbe71b968c4be786a6a6964
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/458301
Commit-Queue: Tomas Gunnarsson <tommi@webrtc.org>
Auto-Submit: Evan Shrubsole <eshr@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#47271}
diff --git a/p2p/BUILD.gn b/p2p/BUILD.gn
index a18edbb..bc12178 100644
--- a/p2p/BUILD.gn
+++ b/p2p/BUILD.gn
@@ -1220,6 +1220,7 @@
       "../rtc_base:timeutils",
       "../rtc_base/network:received_packet",
       "../rtc_base/network:sent_packet",
+      "../rtc_base/system:unused",
       "../system_wrappers:metrics",
       "../test:create_test_environment",
       "../test:create_test_field_trials",
diff --git a/p2p/base/port_unittest.cc b/p2p/base/port_unittest.cc
index 82b005c..45d1d90 100644
--- a/p2p/base/port_unittest.cc
+++ b/p2p/base/port_unittest.cc
@@ -25,7 +25,6 @@
 #include "api/async_dns_resolver.h"
 #include "api/candidate.h"
 #include "api/environment/environment.h"
-#include "api/environment/environment_factory.h"
 #include "api/field_trials.h"
 #include "api/packet_socket_factory.h"
 #include "api/test/mock_packet_socket_factory.h"
@@ -56,8 +55,6 @@
 #include "rtc_base/checks.h"
 #include "rtc_base/crypto_random.h"
 #include "rtc_base/dscp.h"
-#include "rtc_base/fake_clock.h"
-#include "rtc_base/gunit.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/net_helper.h"
 #include "rtc_base/network.h"
@@ -65,12 +62,14 @@
 #include "rtc_base/network_constants.h"
 #include "rtc_base/socket.h"
 #include "rtc_base/socket_address.h"
+#include "rtc_base/system/unused.h"
 #include "rtc_base/thread.h"
 #include "rtc_base/virtual_socket_server.h"
 #include "test/create_test_environment.h"
 #include "test/create_test_field_trials.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
+#include "test/time_controller/simulated_time_controller.h"
 #include "test/wait_until.h"
 
 namespace webrtc {
@@ -82,8 +81,8 @@
 using ::testing::NotNull;
 using ::testing::Return;
 
-constexpr int kDefaultTimeout = 3000;
-constexpr int kShortTimeout = 1000;
+constexpr TimeDelta kDefaultTimeout = TimeDelta::Millis(3000);
+constexpr TimeDelta kShortTimeout = TimeDelta::Millis(1000);
 constexpr TimeDelta kMaxExpectedSimulatedRtt = TimeDelta::Millis(200);
 constexpr TimeDelta kEpsilon = TimeDelta::Millis(1);
 const SocketAddress kLocalAddr1("192.168.1.2", 0);
@@ -132,7 +131,6 @@
   return msg.Write(buf);
 }
 
-
 bool GetStunMessageFromBufferWriter(TestPort* port,
                                     ByteBufferWriter* buf,
                                     const SocketAddress& addr,
@@ -146,20 +144,22 @@
                                 TestPort* lport,
                                 Connection* rconn,
                                 TestPort* rport,
-                                ScopedFakeClock* clock,
+                                GlobalSimulatedTimeController& time_controller,
                                 int64_t ms) {
   lconn->Ping();
-  ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, IsTrue(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return lport->last_stun_msg(); }, IsTrue(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller}),
+      IsRtcOk());
   ASSERT_GT(lport->last_stun_buf().size(), 0u);
   rconn->OnReadPacket(
       ReceivedIpPacket(lport->last_stun_buf(), SocketAddress(), std::nullopt));
 
-  clock->AdvanceTime(TimeDelta::Millis(ms));
-  ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, IsTrue(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  time_controller.AdvanceTime(TimeDelta::Millis(ms));
+  ASSERT_THAT(
+      WaitUntil([&] { return rport->last_stun_msg(); }, IsTrue(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller}),
+      IsRtcOk());
   ASSERT_GT(rport->last_stun_buf().size(), 0u);
   lconn->OnReadPacket(
       ReceivedIpPacket(rport->last_stun_buf(), SocketAddress(), std::nullopt));
@@ -168,7 +168,9 @@
 class TestChannel {
  public:
   // Takes ownership of `p1` (but not `p2`).
-  explicit TestChannel(std::unique_ptr<Port> p1) : port_(std::move(p1)) {
+  TestChannel(std::unique_ptr<Port> p1,
+              GlobalSimulatedTimeController& time_controller)
+      : time_controller_(time_controller), port_(std::move(p1)) {
     port_->SubscribePortComplete(this,
                                  [this](Port* port) { OnPortComplete(port); });
     port_->SubscribeUnknownAddress(
@@ -188,7 +190,10 @@
   const SocketAddress& remote_address() { return remote_address_; }
   std::string remote_fragment() { return remote_frag_; }
 
-  void Start() { port_->PrepareAddress(); }
+  void Start() {
+    port_->PrepareAddress();
+    time_controller_.AdvanceTime(TimeDelta::Zero());
+  }
   void CreateConnection(const Candidate& remote_candidate) {
     RTC_DCHECK(!conn_);
     conn_ = port_->CreateConnection(remote_candidate, Port::ORIGIN_MESSAGE);
@@ -298,6 +303,7 @@
     connection_ready_to_send_ = true;
   }
 
+  GlobalSimulatedTimeController& time_controller_;
   IceMode ice_mode_ = ICEMODE_FULL;
   std::unique_ptr<Port> port_;
 
@@ -314,14 +320,16 @@
  public:
   PortTest()
       : ss_(new VirtualSocketServer()),
-        main_(ss_.get()),
+        time_controller_(Timestamp::Millis(1000), ss_.get()),
+        main_(time_controller_.GetMainThread()),
+        env_(CreateTestEnvironment({.time = &time_controller_})),
         socket_factory_(ss_.get()),
         nat_factory1_(ss_.get(), kNatAddr1, SocketAddress()),
         nat_factory2_(ss_.get(), kNatAddr2, SocketAddress()),
         nat_socket_factory1_(&nat_factory1_),
         nat_socket_factory2_(&nat_factory2_),
-        stun_server_(TestStunServer::Create(env_, kStunAddr, *ss_, main_)),
-        turn_server_(env_, &main_, ss_.get(), kTurnUdpIntAddr, kTurnUdpExtAddr),
+        stun_server_(TestStunServer::Create(env_, kStunAddr, *ss_, *main_)),
+        turn_server_(env_, main_, ss_.get(), kTurnUdpIntAddr, kTurnUdpExtAddr),
         username_(CreateRandomString(ICE_UFRAG_LENGTH)),
         password_(CreateRandomString(ICE_PWD_LENGTH)),
         role_conflict_(false),
@@ -331,10 +339,13 @@
     // Workaround for tests that trigger async destruction of objects that we
     // need to give an opportunity here to run, before proceeding with other
     // teardown.
-    Thread::Current()->ProcessMessages(0);
+    time_controller_.AdvanceTime(TimeDelta::Zero());
   }
 
  protected:
+  VirtualSocketServer* vss() { return ss_.get(); }
+  const Environment& env() const { return env_; }
+
   std::string password() { return password_; }
 
   void TestLocalToLocal() {
@@ -442,7 +453,7 @@
   std::unique_ptr<UDPPort> CreateUdpPort(const SocketAddress& addr,
                                          PacketSocketFactory* socket_factory) {
     auto port = UDPPort::Create({.env = env_,
-                                 .network_thread = &main_,
+                                 .network_thread = main_,
                                  .socket_factory = socket_factory,
                                  .network = MakeNetwork(addr),
                                  .ice_username_fragment = username_,
@@ -458,7 +469,7 @@
       PacketSocketFactory* socket_factory) {
     auto port = UDPPort::Create(
         {.env = env_,
-         .network_thread = &main_,
+         .network_thread = main_,
          .socket_factory = socket_factory,
          .network = MakeNetworkMultipleAddrs(global_addr, link_local_addr),
          .ice_username_fragment = username_,
@@ -473,7 +484,7 @@
   std::unique_ptr<TCPPort> CreateTcpPort(const SocketAddress& addr,
                                          PacketSocketFactory* socket_factory) {
     auto port = TCPPort::Create({.env = env_,
-                                 .network_thread = &main_,
+                                 .network_thread = main_,
                                  .socket_factory = socket_factory,
                                  .network = MakeNetwork(addr),
                                  .ice_username_fragment = username_,
@@ -488,7 +499,7 @@
     ServerAddresses stun_servers;
     stun_servers.insert(kStunAddr);
     auto port = StunPort::Create({.env = env_,
-                                  .network_thread = &main_,
+                                  .network_thread = main_,
                                   .socket_factory = socket_factory,
                                   .network = MakeNetwork(addr),
                                   .ice_username_fragment = username_,
@@ -520,7 +531,7 @@
     config.credentials = kRelayCredentials;
     ProtocolAddress server_address(server_addr, int_proto);
     CreateRelayPortArgs args = {.env = env_};
-    args.network_thread = &main_;
+    args.network_thread = main_;
     args.socket_factory = socket_factory;
     args.network = MakeNetwork(addr);
     args.username = username_;
@@ -535,8 +546,8 @@
 
   std::unique_ptr<NATServer> CreateNatServer(const SocketAddress& addr,
                                              NATType type) {
-    return std::make_unique<NATServer>(env_, type, main_, ss_.get(), addr, addr,
-                                       main_, ss_.get(), addr);
+    return std::make_unique<NATServer>(env_, type, *main_, ss_.get(), addr,
+                                       addr, *main_, ss_.get(), addr);
   }
   static const char* StunName(NATType type) {
     switch (type) {
@@ -586,20 +597,23 @@
   // TCP reconnecting mechanism before entering this function.
   void ConnectStartedChannels(TestChannel* ch1, TestChannel* ch2) {
     ASSERT_TRUE(ch1->conn());
-    EXPECT_THAT(WaitUntil([&] { return ch1->conn()->connected(); }, IsTrue(),
-                          {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-                IsRtcOk());  // for TCP connect
+    EXPECT_THAT(
+        WaitUntil([&] { return ch1->conn()->connected(); }, IsTrue(),
+                  {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+        IsRtcOk());  // for TCP connect
     ch1->Ping();
-    EXPECT_TRUE(WaitUntil([&] { return !ch2->remote_address().IsNil(); },
-                          {.timeout = TimeDelta::Millis(kShortTimeout)}));
+    EXPECT_TRUE(
+        WaitUntil([&] { return !ch2->remote_address().IsNil(); },
+                  {.timeout = kShortTimeout, .clock = &time_controller_}));
 
     // Send a ping from dst to src.
     ch2->AcceptConnection(GetCandidate(ch1->port()));
     ch2->Ping();
-    EXPECT_THAT(WaitUntil([&] { return ch2->conn()->write_state(); },
-                          Eq(Connection::STATE_WRITABLE),
-                          {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-                IsRtcOk());
+    EXPECT_THAT(
+        WaitUntil([&] { return ch2->conn()->write_state(); },
+                  Eq(Connection::STATE_WRITABLE),
+                  {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+        IsRtcOk());
   }
 
   // This connects and disconnects the provided channels in the same sequence as
@@ -628,12 +642,14 @@
                                  tcp_conn2->socket()->GetLocalAddress()));
 
     // Wait for both OnClose are delivered.
-    EXPECT_THAT(WaitUntil([&] { return !ch1->conn()->connected(); }, IsTrue(),
-                          {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-                IsRtcOk());
-    EXPECT_THAT(WaitUntil([&] { return !ch2->conn()->connected(); }, IsTrue(),
-                          {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-                IsRtcOk());
+    EXPECT_THAT(
+        WaitUntil([&] { return !ch1->conn()->connected(); }, IsTrue(),
+                  {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+        IsRtcOk());
+    EXPECT_THAT(
+        WaitUntil([&] { return !ch2->conn()->connected(); }, IsTrue(),
+                  {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+        IsRtcOk());
 
     // Ensure redundant SignalClose events on TcpConnection won't break tcp
     // reconnection. Chromium will fire SignalClose for all outstanding IPC
@@ -644,9 +660,10 @@
     // Speed up destroying ch2's connection such that the test is ready to
     // accept a new connection from ch1 before ch1's connection destroys itself.
     ch2->Stop();
-    EXPECT_THAT(WaitUntil([&] { return ch2->conn(); }, IsNull(),
-                          {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-                IsRtcOk());
+    EXPECT_THAT(
+        WaitUntil([&] { return ch2->conn(); }, IsNull(),
+                  {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+        IsRtcOk());
   }
 
   void TestTcpReconnect(bool ping_after_disconnected,
@@ -660,30 +677,32 @@
     port2->set_component(ICE_CANDIDATE_COMPONENT_DEFAULT);
 
     // Set up channels and ensure both ports will be deleted.
-    TestChannel ch1(std::move(port1));
-    TestChannel ch2(std::move(port2));
+    TestChannel ch1(std::move(port1), time_controller_);
+    TestChannel ch2(std::move(port2), time_controller_);
     EXPECT_EQ(0, ch1.complete_count());
     EXPECT_EQ(0, ch2.complete_count());
 
     ch1.Start();
     ch2.Start();
-    ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
-                          {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-                IsRtcOk());
-    ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
-                          {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-                IsRtcOk());
+    ASSERT_THAT(
+        WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+                  {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+        IsRtcOk());
+    ASSERT_THAT(
+        WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+                  {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+        IsRtcOk());
 
     // Initial connecting the channel, create connection on channel1.
     ch1.CreateConnection(GetCandidate(ch2.port()));
     ConnectStartedChannels(&ch1, &ch2);
 
     // Shorten the timeout period.
-    const int kTcpReconnectTimeout = kDefaultTimeout;
+    const TimeDelta kTcpReconnectTimeout = kDefaultTimeout;
     static_cast<TCPConnection*>(ch1.conn())
-        ->set_reconnection_timeout(kTcpReconnectTimeout);
+        ->set_reconnection_timeout(kTcpReconnectTimeout.ms());
     static_cast<TCPConnection*>(ch2.conn())
-        ->set_reconnection_timeout(kTcpReconnectTimeout);
+        ->set_reconnection_timeout(kTcpReconnectTimeout.ms());
 
     EXPECT_FALSE(ch1.connection_ready_to_send());
     EXPECT_FALSE(ch2.connection_ready_to_send());
@@ -705,15 +724,17 @@
       }
 
       // Wait for channel's outgoing TCPConnection connected.
-      EXPECT_THAT(WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
-                            {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-                  IsRtcOk());
+      EXPECT_THAT(
+          WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
+                    {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+          IsRtcOk());
 
       // Verify that we could still connect channels.
       ConnectStartedChannels(&ch1, &ch2);
       EXPECT_THAT(
-          WaitUntil([&] { return ch1.connection_ready_to_send(); }, IsTrue(),
-                    {.timeout = TimeDelta::Millis(kTcpReconnectTimeout)}),
+          WaitUntil(
+              [&] { return ch1.connection_ready_to_send(); }, IsTrue(),
+              {.timeout = kTcpReconnectTimeout, .clock = &time_controller_}),
           IsRtcOk());
       // Channel2 is the passive one so a new connection is created during
       // reconnect. This new connection should never have issued ENOTCONN
@@ -724,8 +745,8 @@
       // Since the reconnection never happens, the connections should have been
       // destroyed after the timeout.
       EXPECT_THAT(WaitUntil([&] { return !ch1.conn(); }, IsTrue(),
-                            {.timeout = TimeDelta::Millis(kTcpReconnectTimeout +
-                                                          kDefaultTimeout)}),
+                            {.timeout = kTcpReconnectTimeout + kDefaultTimeout,
+                             .clock = &time_controller_}),
                   IsRtcOk());
       EXPECT_TRUE(!ch2.conn());
     }
@@ -733,12 +754,14 @@
     // Tear down and ensure that goes smoothly.
     ch1.Stop();
     ch2.Stop();
-    EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, IsNull(),
-                          {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-                IsRtcOk());
-    EXPECT_THAT(WaitUntil([&] { return ch2.conn(); }, IsNull(),
-                          {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-                IsRtcOk());
+    EXPECT_THAT(
+        WaitUntil([&] { return ch1.conn(); }, IsNull(),
+                  {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+        IsRtcOk());
+    EXPECT_THAT(
+        WaitUntil([&] { return ch2.conn(); }, IsNull(),
+                  {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+        IsRtcOk());
   }
 
   std::unique_ptr<IceMessage> CreateStunMessage(StunMessageType type) {
@@ -758,12 +781,14 @@
       absl::string_view username,
       absl::string_view password,
       const FieldTrialsView* field_trials = nullptr) {
-    Port::PortParametersRef args = {.env = CreateEnvironment(field_trials),
-                                    .network_thread = &main_,
-                                    .socket_factory = &socket_factory_,
-                                    .network = MakeNetwork(addr),
-                                    .ice_username_fragment = username,
-                                    .ice_password = password};
+    Port::PortParametersRef args = {
+        .env = CreateTestEnvironment(
+            {.field_trials = field_trials, .time = &time_controller_}),
+        .network_thread = main_,
+        .socket_factory = &socket_factory_,
+        .network = MakeNetwork(addr),
+        .ice_username_fragment = username,
+        .ice_password = password};
     auto port = std::make_unique<TestPort>(args, 0, 0);
     port->SubscribeRoleConflict([this]() { OnRoleConflict(); });
     return port;
@@ -783,7 +808,7 @@
                                            absl::string_view username,
                                            absl::string_view password) {
     Port::PortParametersRef args = {.env = env_,
-                                    .network_thread = &main_,
+                                    .network_thread = main_,
                                     .socket_factory = &socket_factory_,
                                     .network = network,
                                     .ice_username_fragment = username,
@@ -796,7 +821,7 @@
   std::unique_ptr<TestPort> CreateRawTestPort() {
     Port::PortParametersRef args = {
         .env = env_,
-        .network_thread = &main_,
+        .network_thread = main_,
         .socket_factory = &socket_factory_,
         .network = MakeNetwork(kLocalAddr1),
     };
@@ -818,18 +843,16 @@
     return &nat_socket_factory1_;
   }
 
-  VirtualSocketServer* vss() { return ss_.get(); }
+ protected:
+  std::unique_ptr<VirtualSocketServer> ss_;
+  GlobalSimulatedTimeController time_controller_;
+  Thread* main_;
+  const Environment env_;
 
-  const Environment& env() const { return env_; }
-
- private:
-  const Environment env_ = CreateTestEnvironment();
   // When a "create port" helper method is called with an IP, we create a
   // Network with that IP and add it to this list. Using a list instead of a
   // vector so that when it grows, pointers aren't invalidated.
   std::list<Network> networks_;
-  std::unique_ptr<VirtualSocketServer> ss_;
-  AutoSocketServerThread main_;
   BasicPacketSocketFactory socket_factory_;
   std::unique_ptr<NATServer> nat_server1_;
   std::unique_ptr<NATServer> nat_server2_;
@@ -853,40 +876,43 @@
                                 bool same_addr1,
                                 bool same_addr2,
                                 bool possible) {
-  ScopedFakeClock clock;
   RTC_LOG(LS_INFO) << "Test: " << name1 << " to " << name2 << ": ";
   port1->set_component(ICE_CANDIDATE_COMPONENT_DEFAULT);
   port2->set_component(ICE_CANDIDATE_COMPONENT_DEFAULT);
 
   // Set up channels and ensure both ports will be deleted.
-  TestChannel ch1(std::move(port1));
-  TestChannel ch2(std::move(port2));
+  TestChannel ch1(std::move(port1), time_controller_);
+  TestChannel ch2(std::move(port2), time_controller_);
   EXPECT_EQ(0, ch1.complete_count());
   EXPECT_EQ(0, ch2.complete_count());
 
   // Acquire addresses.
   ch1.Start();
   ch2.Start();
-  ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());
-  ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
 
   // Send a ping from src to dst. This may or may not make it.
   ch1.CreateConnection(GetCandidate(ch2.port()));
   ASSERT_TRUE(ch1.conn() != nullptr);
-  EXPECT_THAT(WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());  // for TCP connect
-  ch1.Ping();
-  SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock);
 
+  EXPECT_THAT(
+      WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());  // for TCP connect
+  ch1.Ping();
   if (accept) {
+    EXPECT_THAT(
+        WaitUntil([&] { return !ch2.remote_address().IsNil(); }, IsTrue(),
+                  {.timeout = kShortTimeout, .clock = &time_controller_}),
+        IsRtcOk());
+
     // We are able to send a ping from src to dst. This is the case when
     // sending to UDP ports and cone NATs.
     EXPECT_TRUE(ch1.remote_address().IsNil());
@@ -901,12 +927,13 @@
     // Send a ping from dst to src.
     ch2.AcceptConnection(GetCandidate(ch1.port()));
     ASSERT_TRUE(ch2.conn() != nullptr);
+
     ch2.Ping();
-    EXPECT_THAT(WaitUntil([&] { return ch2.conn()->write_state(); },
-                          Eq(Connection::STATE_WRITABLE),
-                          {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                           .clock = &clock}),
-                IsRtcOk());
+    EXPECT_THAT(
+        WaitUntil([&] { return ch2.conn()->write_state(); },
+                  Eq(Connection::STATE_WRITABLE),
+                  {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+        IsRtcOk());
   } else {
     // We can't send a ping from src to dst, so flip it around. This will happen
     // when the destination NAT is addr/port restricted or symmetric.
@@ -916,9 +943,12 @@
     // Send a ping from dst to src. Again, this may or may not make it.
     ch2.CreateConnection(GetCandidate(ch1.port()));
     ASSERT_TRUE(ch2.conn() != nullptr);
+
     ch2.Ping();
-    SIMULATED_WAIT(ch2.conn()->write_state() == Connection::STATE_WRITABLE,
-                   kShortTimeout, clock);
+    RTC_UNUSED(
+        WaitUntil([&] { return ch2.conn()->write_state(); },
+                  Eq(Connection::STATE_WRITABLE),
+                  {.timeout = kShortTimeout, .clock = &time_controller_}));
 
     if (same_addr1 && same_addr2) {
       // The new ping got back to the source.
@@ -929,25 +959,24 @@
       // through.  So we will have to do another.
       if (ch1.conn()->write_state() == Connection::STATE_WRITE_INIT) {
         ch1.Ping();
-        EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); },
-                              Eq(Connection::STATE_WRITABLE),
-                              {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                               .clock = &clock}),
-                    IsRtcOk());
+        EXPECT_THAT(
+            WaitUntil([&] { return ch1.conn()->write_state(); },
+                      Eq(Connection::STATE_WRITABLE),
+                      {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+            IsRtcOk());
       }
     } else if (!same_addr1 && possible) {
       // The new ping went to the candidate address, but that address was bad.
       // This will happen when the source NAT is symmetric.
-      EXPECT_TRUE(ch1.remote_address().IsNil());
-      EXPECT_TRUE(ch2.remote_address().IsNil());
+      // With simulated time and some NAT types (like Turn/AR-Nat), the packet
+      // can be delivered early.
 
       // However, since we have now sent a ping to the source IP, we should be
       // able to get a ping from it. This gives us the real source address.
       ch1.Ping();
       EXPECT_THAT(
-          WaitUntil(
-              [&] { return !ch2.remote_address().IsNil(); }, IsTrue(),
-              {.timeout = TimeDelta::Millis(kDefaultTimeout), .clock = &clock}),
+          WaitUntil([&] { return !ch2.remote_address().IsNil(); }, IsTrue(),
+                    {.timeout = kDefaultTimeout, .clock = &time_controller_}),
           IsRtcOk());
       EXPECT_FALSE(ch2.conn()->receiving());
       EXPECT_TRUE(ch1.remote_address().IsNil());
@@ -955,12 +984,13 @@
       // Pick up the actual address and establish the connection.
       ch2.AcceptConnection(GetCandidate(ch1.port()));
       ASSERT_TRUE(ch2.conn() != nullptr);
+
       ch2.Ping();
-      EXPECT_THAT(WaitUntil([&] { return ch2.conn()->write_state(); },
-                            Eq(Connection::STATE_WRITABLE),
-                            {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                             .clock = &clock}),
-                  IsRtcOk());
+      EXPECT_THAT(
+          WaitUntil([&] { return ch2.conn()->write_state(); },
+                    Eq(Connection::STATE_WRITABLE),
+                    {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+          IsRtcOk());
     } else if (!same_addr2 && possible) {
       // The new ping came in, but from an unexpected address. This will happen
       // when the destination NAT is symmetric.
@@ -969,18 +999,21 @@
 
       // Update our address and complete the connection.
       ch1.AcceptConnection(GetCandidate(ch2.port()));
+
       ch1.Ping();
-      EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); },
-                            Eq(Connection::STATE_WRITABLE),
-                            {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                             .clock = &clock}),
-                  IsRtcOk());
+      EXPECT_THAT(
+          WaitUntil([&] { return ch1.conn()->write_state(); },
+                    Eq(Connection::STATE_WRITABLE),
+                    {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+          IsRtcOk());
     } else {  // (!possible)
       // There should be s no way for the pings to reach each other. Check it.
       EXPECT_TRUE(ch1.remote_address().IsNil());
       EXPECT_TRUE(ch2.remote_address().IsNil());
       ch1.Ping();
-      SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock);
+      RTC_UNUSED(
+          WaitUntil([&] { return !ch2.remote_address().IsNil(); }, IsTrue(),
+                    {.timeout = kShortTimeout, .clock = &time_controller_}));
       EXPECT_TRUE(ch1.remote_address().IsNil());
       EXPECT_TRUE(ch2.remote_address().IsNil());
     }
@@ -990,9 +1023,13 @@
   ASSERT_TRUE(ch1.conn() != nullptr);
   ASSERT_TRUE(ch2.conn() != nullptr);
   if (possible) {
-    EXPECT_TRUE(ch1.conn()->receiving());
+    EXPECT_THAT(WaitUntil([&] { return ch1.conn()->receiving(); }, IsTrue(),
+                          {.clock = &time_controller_}),
+                IsRtcOk());
     EXPECT_EQ(Connection::STATE_WRITABLE, ch1.conn()->write_state());
-    EXPECT_TRUE(ch2.conn()->receiving());
+    EXPECT_THAT(WaitUntil([&] { return ch2.conn()->receiving(); }, IsTrue(),
+                          {.clock = &time_controller_}),
+                IsRtcOk());
     EXPECT_EQ(Connection::STATE_WRITABLE, ch2.conn()->write_state());
   } else {
     EXPECT_FALSE(ch1.conn()->receiving());
@@ -1004,14 +1041,14 @@
   // Tear down and ensure that goes smoothly.
   ch1.Stop();
   ch2.Stop();
-  EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, IsNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());
-  EXPECT_THAT(WaitUntil([&] { return ch2.conn(); }, IsNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());
+  EXPECT_THAT(
+      WaitUntil([&] { return ch1.conn(); }, IsNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
+  EXPECT_THAT(
+      WaitUntil([&] { return ch2.conn(); }, IsNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
 }
 
 class FakePacketSocketFactory : public PacketSocketFactory {
@@ -1301,13 +1338,14 @@
   port1->set_component(ICE_CANDIDATE_COMPONENT_DEFAULT);
 
   // Set up a channel and ensure the port will be deleted.
-  TestChannel ch1(std::move(port1));
+  TestChannel ch1(std::move(port1), time_controller_);
   EXPECT_EQ(0, ch1.complete_count());
 
   ch1.Start();
-  ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
 
   std::unique_ptr<Socket> server(
       vss()->CreateSocket(kLocalAddr2.family(), SOCK_STREAM));
@@ -1319,9 +1357,10 @@
 
   ch1.CreateConnection(c);
   EXPECT_TRUE(ch1.conn());
-  EXPECT_THAT(WaitUntil([&] { return !ch1.conn(); }, IsTrue(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());  // for TCP connect
+  EXPECT_THAT(
+      WaitUntil([&] { return !ch1.conn(); }, IsTrue(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());  // for TCP connect
 }
 
 /* TODO(?): Enable these once testrelayserver can accept external TCP.
@@ -1351,17 +1390,19 @@
 // ii) it has not received anything for kDeadConnectionReceiveTimeout since
 //     last receiving.
 TEST_F(PortTest, TestConnectionDead) {
-  TestChannel ch1(CreateUdpPort(kLocalAddr1));
-  TestChannel ch2(CreateUdpPort(kLocalAddr2));
+  TestChannel ch1(CreateUdpPort(kLocalAddr1), time_controller_);
+  TestChannel ch2(CreateUdpPort(kLocalAddr2), time_controller_);
   // Acquire address.
   ch1.Start();
   ch2.Start();
-  ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
-  ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
 
   // Test case that the connection has never received anything.
   Timestamp before_created = env().clock().CurrentTime();
@@ -1371,18 +1412,19 @@
   ASSERT_NE(conn, nullptr);
   // It is not dead if it is after kMinConnectionLifetime but not pruned.
   conn->UpdateState(after_created + kMinConnectionLifetime + kEpsilon);
-  Thread::Current()->ProcessMessages(0);
+  time_controller_.AdvanceTime(TimeDelta::Zero());
   EXPECT_TRUE(ch1.conn() != nullptr);
   // It is not dead if it is before kMinConnectionLifetime and pruned.
   conn->UpdateState(before_created + kMinConnectionLifetime - kEpsilon);
   conn->Prune();
-  Thread::Current()->ProcessMessages(0);
+  time_controller_.AdvanceTime(TimeDelta::Zero());
   EXPECT_TRUE(ch1.conn() != nullptr);
   // It will be dead after kMinConnectionLifetime and pruned.
   conn->UpdateState(after_created + kMinConnectionLifetime + kEpsilon);
-  EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  EXPECT_THAT(
+      WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
 
   // Test case that the connection has received something.
   // Create a connection again and receive a ping.
@@ -1395,27 +1437,30 @@
   // The connection will be dead after kDeadConnectionReceiveTimeout
   conn->UpdateState(before_last_receiving + kDeadConnectionReceiveTimeout -
                     kEpsilon);
-  Thread::Current()->ProcessMessages(100);
+  time_controller_.AdvanceTime(TimeDelta::Zero());
   EXPECT_TRUE(ch1.conn() != nullptr);
   conn->UpdateState(after_last_receiving + kDeadConnectionReceiveTimeout +
                     kEpsilon);
-  EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  EXPECT_THAT(
+      WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
 }
 
 TEST_F(PortTest, TestConnectionDeadWithDeadConnectionTimeout) {
-  TestChannel ch1(CreateUdpPort(kLocalAddr1));
-  TestChannel ch2(CreateUdpPort(kLocalAddr2));
+  TestChannel ch1(CreateUdpPort(kLocalAddr1), time_controller_);
+  TestChannel ch2(CreateUdpPort(kLocalAddr2), time_controller_);
   // Acquire address.
   ch1.Start();
   ch2.Start();
-  ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
-  ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
 
   // Note: set field trials manually since they are parsed by
   // P2PTransportChannel but P2PTransportChannel is not used in this test.
@@ -1433,12 +1478,13 @@
   Timestamp after_last_receiving = env().clock().CurrentTime();
   // The connection will be dead after 90s
   conn->UpdateState(before_last_receiving + TimeDelta::Seconds(90) - kEpsilon);
-  Thread::Current()->ProcessMessages(100);
+  time_controller_.AdvanceTime(TimeDelta::Zero());
   EXPECT_TRUE(ch1.conn() != nullptr);
   conn->UpdateState(after_last_receiving + TimeDelta::Seconds(90) + kEpsilon);
-  EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  EXPECT_THAT(
+      WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
 }
 
 TEST_F(PortTest, TestConnectionDeadOutstandingPing) {
@@ -1449,17 +1495,19 @@
   port2->SetIceRole(ICEROLE_CONTROLLED);
   port2->SetIceTiebreaker(kTiebreaker2);
 
-  TestChannel ch1(std::move(port1));
-  TestChannel ch2(std::move(port2));
+  TestChannel ch1(std::move(port1), time_controller_);
+  TestChannel ch2(std::move(port2), time_controller_);
   // Acquire address.
   ch1.Start();
   ch2.Start();
-  ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
-  ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
 
   // Note: set field trials manually since they are parsed by
   // P2PTransportChannel but P2PTransportChannel is not used in this test.
@@ -1480,13 +1528,14 @@
   // The connection will be dead 30s after the ping was sent.
   conn->UpdateState(send_ping_timestamp + kDeadConnectionReceiveTimeout -
                     kEpsilon);
-  Thread::Current()->ProcessMessages(100);
+  time_controller_.AdvanceTime(TimeDelta::Zero());
   EXPECT_TRUE(ch1.conn() != nullptr);
   conn->UpdateState(send_ping_timestamp + kDeadConnectionReceiveTimeout +
                     kEpsilon);
-  EXPECT_THAT(WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  EXPECT_THAT(
+      WaitUntil([&] { return ch1.conn(); }, Eq(nullptr),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
 }
 
 // This test case verifies standard ICE features in STUN messages. Currently it
@@ -1518,16 +1567,18 @@
       lport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
   conn->Ping();
 
-  ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   IceMessage* msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   conn->OnReadPacket(
       ReceivedIpPacket(lport->last_stun_buf(), SocketAddress(), std::nullopt));
-  ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
 
@@ -1540,9 +1591,10 @@
       lport->CreateConnection(lport->Candidates()[1], Port::ORIGIN_MESSAGE);
   conn1->Ping();
 
-  ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   std::unique_ptr<IceMessage> modified_req(
@@ -1564,9 +1616,10 @@
   conn1->OnReadPacket(ReceivedIpPacket::CreateFromLegacy(
       reinterpret_cast<const char*>(buf->Data()), buf->Length(),
       /*packet_time_us=*/-1));
-  ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type());
 }
@@ -1594,24 +1647,25 @@
       rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
   rconn->Ping();
 
-  ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   IceMessage* msg = rport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   // Send rport binding request to lport.
   lconn->OnReadPacket(
       ReceivedIpPacket(rport->last_stun_buf(), SocketAddress(), std::nullopt));
 
-  ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
   EXPECT_TRUE(role_conflict());
 }
 
 TEST_F(PortTest, TestTcpNoDelay) {
-  ScopedFakeClock clock;
   auto port1 = CreateTcpPort(kLocalAddr1);
   port1->SetIceRole(ICEROLE_CONTROLLING);
   int option_value = -1;
@@ -1624,28 +1678,30 @@
 
   // Set up a connection, and verify that option is set on connected sockets at
   // both ends.
-  TestChannel ch1(std::move(port1));
-  TestChannel ch2(std::move(port2));
+  TestChannel ch1(std::move(port1), time_controller_);
+  TestChannel ch2(std::move(port2), time_controller_);
   // Acquire addresses.
   ch1.Start();
   ch2.Start();
-  ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());
-  ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   // Connect and send a ping from src to dst.
   ch1.CreateConnection(GetCandidate(ch2.port()));
   ASSERT_TRUE(ch1.conn() != nullptr);
-  EXPECT_THAT(WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());  // for TCP connect
+  EXPECT_THAT(
+      WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());  // for TCP connect
   ch1.Ping();
-  SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock);
+  EXPECT_THAT(WaitUntil([&] { return !ch2.remote_address().IsNil(); }, IsTrue(),
+                        {.clock = &time_controller_}),
+              IsRtcOk());
 
   // Accept the connection.
   ch2.AcceptConnection(GetCandidate(ch1.port()));
@@ -1917,9 +1973,10 @@
   lconn->Ping();
 
   // Check that it's a proper BINDING-REQUEST.
-  ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   IceMessage* msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   EXPECT_FALSE(msg->IsLegacy());
@@ -2021,9 +2078,10 @@
   rconn->Ping();
   rconn->Ping();
   rconn->Ping();
-  ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   msg = rport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   const StunUInt64Attribute* ice_controlled_attr =
@@ -2094,9 +2152,10 @@
   // Send ping (including the nomination value) from `lconn` to `rconn`. This
   // should set the remote nomination of `rconn`.
   lconn->Ping();
-  ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, IsTrue(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return lport->last_stun_msg(); }, IsTrue(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   ASSERT_GT(lport->last_stun_buf().size(), 0u);
   rconn->OnReadPacket(
       ReceivedIpPacket(lport->last_stun_buf(), SocketAddress(), std::nullopt));
@@ -2109,9 +2168,10 @@
 
   // This should result in an acknowledgment sent back from `rconn` to `lconn`,
   // updating the acknowledged nomination of `lconn`.
-  ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, IsTrue(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return rport->last_stun_msg(); }, IsTrue(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   ASSERT_GT(rport->last_stun_buf().size(), 0u);
   lconn->OnReadPacket(
       ReceivedIpPacket(rport->last_stun_buf(), SocketAddress(), std::nullopt));
@@ -2124,8 +2184,6 @@
 }
 
 TEST_F(PortTest, TestRoundTripTime) {
-  ScopedFakeClock clock;
-
   auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass");
   auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
   lport->SetIceRole(ICEROLE_CONTROLLING);
@@ -2145,20 +2203,20 @@
   EXPECT_EQ(0u, lconn->stats().total_round_trip_time_ms);
   EXPECT_FALSE(lconn->stats().current_round_trip_time_ms);
 
-  SendPingAndReceiveResponse(lconn, lport.get(), rconn, rport.get(), &clock,
-                             10);
+  SendPingAndReceiveResponse(lconn, lport.get(), rconn, rport.get(),
+                             time_controller_, 10);
   EXPECT_EQ(10u, lconn->stats().total_round_trip_time_ms);
   ASSERT_TRUE(lconn->stats().current_round_trip_time_ms);
   EXPECT_EQ(10u, *lconn->stats().current_round_trip_time_ms);
 
-  SendPingAndReceiveResponse(lconn, lport.get(), rconn, rport.get(), &clock,
-                             20);
+  SendPingAndReceiveResponse(lconn, lport.get(), rconn, rport.get(),
+                             time_controller_, 20);
   EXPECT_EQ(30u, lconn->stats().total_round_trip_time_ms);
   ASSERT_TRUE(lconn->stats().current_round_trip_time_ms);
   EXPECT_EQ(20u, *lconn->stats().current_round_trip_time_ms);
 
-  SendPingAndReceiveResponse(lconn, lport.get(), rconn, rport.get(), &clock,
-                             30);
+  SendPingAndReceiveResponse(lconn, lport.get(), rconn, rport.get(),
+                             time_controller_, 30);
   EXPECT_EQ(60u, lconn->stats().total_round_trip_time_ms);
   ASSERT_TRUE(lconn->stats().current_round_trip_time_ms);
   EXPECT_EQ(30u, *lconn->stats().current_round_trip_time_ms);
@@ -2179,9 +2237,10 @@
   Connection* lconn =
       lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE);
   lconn->Ping();
-  ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   IceMessage* msg = lport->last_stun_msg();
   const StunUInt64Attribute* ice_controlling_attr =
       msg->GetUInt64(STUN_ATTR_ICE_CONTROLLING);
@@ -2239,9 +2298,10 @@
   // message is handled in rconn, The rconn's remote candidate will have cost
   // kNetworkCostHigh;
   EXPECT_EQ(kNetworkCostLow, rconn->remote_candidate().network_cost());
-  ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   IceMessage* msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   // Pass the binding request to rport.
@@ -2249,9 +2309,10 @@
       ReceivedIpPacket(lport->last_stun_buf(), SocketAddress(), std::nullopt));
 
   // Wait until rport sends the response and then check the remote network cost.
-  ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   EXPECT_EQ(kNetworkCostHigh, rconn->remote_candidate().network_cost());
 }
 
@@ -2272,9 +2333,10 @@
   Connection* lconn =
       lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE);
   lconn->Ping();
-  ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   IceMessage* msg = lport->last_stun_msg();
   const StunUInt32Attribute* network_info_attr =
       msg->GetUInt32(STUN_ATTR_GOOG_NETWORK_INFO);
@@ -2292,9 +2354,10 @@
   Connection* rconn =
       rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
   rconn->Ping();
-  ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   msg = rport->last_stun_msg();
   network_info_attr = msg->GetUInt32(STUN_ATTR_GOOG_NETWORK_INFO);
   ASSERT_TRUE(network_info_attr != nullptr);
@@ -2581,16 +2644,18 @@
 
   // Send request.
   lconn->Ping();
-  ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   rconn->OnReadPacket(
       ReceivedIpPacket(lport->last_stun_buf(), SocketAddress(), std::nullopt));
 
   // Intercept request and add comprehension required attribute.
-  ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   auto modified_response = rport->last_stun_msg()->Clone();
   modified_response->AddAttribute(StunAttribute::CreateUInt32(0x7777));
   modified_response->RemoveAttribute(STUN_ATTR_FINGERPRINT);
@@ -2670,23 +2735,25 @@
       rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
   rconn->Ping();
 
-  ASSERT_THAT(WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return rport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   IceMessage* msg = rport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   // Send rport binding request to lport.
   lconn->OnReadPacket(
       ReceivedIpPacket(rport->last_stun_buf(), SocketAddress(), std::nullopt));
 
-  ASSERT_THAT(WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return lport->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
   Timestamp last_ping_received1 = lconn->LastPingReceived();
 
   // Adding a delay of 100ms.
-  Thread::Current()->ProcessMessages(100);
+  time_controller_.AdvanceTime(TimeDelta::Millis(100));
   // Pinging lconn using stun indication message.
   lconn->OnReadPacket(ReceivedIpPacket::CreateFromLegacy(
       buf->Data(), buf->Length(), /*packet_time_us=*/-1));
@@ -2801,9 +2868,10 @@
             tcpport2->Candidates()[0].foundation());
   auto stunport = CreateStunPort(kLocalAddr1, nat_socket_factory1());
   stunport->PrepareAddress();
-  ASSERT_THAT(WaitUntil([&] { return stunport->Candidates().size(); }, Eq(1U),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return stunport->Candidates().size(); }, Eq(1U),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   EXPECT_NE(tcpport1->Candidates()[0].foundation(),
             stunport->Candidates()[0].foundation());
   EXPECT_NE(tcpport2->Candidates()[0].foundation(),
@@ -2816,9 +2884,10 @@
   auto turnport1 =
       CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP);
   turnport1->PrepareAddress();
-  ASSERT_THAT(WaitUntil([&] { return turnport1->Candidates().size(); }, Eq(1U),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return turnport1->Candidates().size(); }, Eq(1U),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   EXPECT_NE(udpport1->Candidates()[0].foundation(),
             turnport1->Candidates()[0].foundation());
   EXPECT_NE(udpport2->Candidates()[0].foundation(),
@@ -2828,9 +2897,10 @@
   auto turnport2 =
       CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP);
   turnport2->PrepareAddress();
-  ASSERT_THAT(WaitUntil([&] { return turnport2->Candidates().size(); }, Eq(1U),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return turnport2->Candidates().size(); }, Eq(1U),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   EXPECT_EQ(turnport1->Candidates()[0].foundation(),
             turnport2->Candidates()[0].foundation());
 
@@ -2842,9 +2912,10 @@
   auto turnport3 = CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP,
                                   PROTO_UDP, kTurnUdpIntAddr2);
   turnport3->PrepareAddress();
-  ASSERT_THAT(WaitUntil([&] { return turnport3->Candidates().size(); }, Eq(1U),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return turnport3->Candidates().size(); }, Eq(1U),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   EXPECT_NE(turnport3->Candidates()[0].foundation(),
             turnport2->Candidates()[0].foundation());
 
@@ -2855,9 +2926,10 @@
   auto turnport4 =
       CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_TCP, PROTO_UDP);
   turnport4->PrepareAddress();
-  ASSERT_THAT(WaitUntil([&] { return turnport4->Candidates().size(); }, Eq(1U),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return turnport4->Candidates().size(); }, Eq(1U),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   EXPECT_NE(turnport2->Candidates()[0].foundation(),
             turnport4->Candidates()[0].foundation());
 }
@@ -2875,9 +2947,10 @@
   // socket address.
   auto stunport = CreateStunPort(kLocalAddr1, nat_socket_factory1());
   stunport->PrepareAddress();
-  ASSERT_THAT(WaitUntil([&] { return stunport->Candidates().size(); }, Eq(1U),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return stunport->Candidates().size(); }, Eq(1U),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   // Check STUN candidate address.
   EXPECT_EQ(stunport->Candidates()[0].address().ipaddr(), kNatAddr1.ipaddr());
   // Check STUN candidate related address.
@@ -2888,9 +2961,10 @@
   auto turnport =
       CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP);
   turnport->PrepareAddress();
-  ASSERT_THAT(WaitUntil([&] { return turnport->Candidates().size(); }, Eq(1U),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return turnport->Candidates().size(); }, Eq(1U),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   EXPECT_EQ(kTurnUdpExtAddr.ipaddr(),
             turnport->Candidates()[0].address().ipaddr());
   EXPECT_EQ(kNatAddr1.ipaddr(),
@@ -3004,39 +3078,40 @@
 // the default setup where the RTT is deterministically one, which generates an
 // estimate given by `MINIMUM_RTT` = 100.
 TEST_F(PortTest, TestWritableState) {
-  ScopedFakeClock clock;
   auto port1 = CreateUdpPort(kLocalAddr1);
   port1->SetIceRole(ICEROLE_CONTROLLING);
   auto port2 = CreateUdpPort(kLocalAddr2);
   port2->SetIceRole(ICEROLE_CONTROLLED);
 
   // Set up channels.
-  TestChannel ch1(std::move(port1));
-  TestChannel ch2(std::move(port2));
+  TestChannel ch1(std::move(port1), time_controller_);
+  TestChannel ch2(std::move(port2), time_controller_);
 
   // Acquire addresses.
   ch1.Start();
   ch2.Start();
-  ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());
-  ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
 
   // Send a ping from src to dst.
   ch1.CreateConnection(GetCandidate(ch2.port()));
   ASSERT_TRUE(ch1.conn() != nullptr);
   EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state());
   // for TCP connect
-  EXPECT_THAT(WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());
+  EXPECT_THAT(
+      WaitUntil([&] { return ch1.conn()->connected(); }, IsTrue(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   ch1.Ping();
-  SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock);
+  EXPECT_THAT(WaitUntil([&] { return !ch2.remote_address().IsNil(); }, IsTrue(),
+                        {.clock = &time_controller_}),
+              IsRtcOk());
 
   // Data should be sendable before the connection is accepted.
   char data[] = "abcd";
@@ -3047,11 +3122,11 @@
   // Accept the connection to return the binding response, transition to
   // writable, and allow data to be sent.
   ch2.AcceptConnection(GetCandidate(ch1.port()));
-  EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); },
-                        Eq(Connection::STATE_WRITABLE),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());
+  EXPECT_THAT(
+      WaitUntil([&] { return ch1.conn()->write_state(); },
+                Eq(Connection::STATE_WRITABLE),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   EXPECT_EQ(data_size, ch1.conn()->Send(data, data_size, options));
 
   // Ask the connection to update state as if enough time has passed to lose
@@ -3071,11 +3146,11 @@
 
   // And now allow the other side to process the pings and send binding
   // responses.
-  EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); },
-                        Eq(Connection::STATE_WRITABLE),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());
+  EXPECT_THAT(
+      WaitUntil([&] { return ch1.conn()->write_state(); },
+                Eq(Connection::STATE_WRITABLE),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   // Wait long enough for a full timeout (past however long we've already
   // waited).
   for (uint32_t i = 1; i <= kConnectionWriteConnectFailures; ++i) {
@@ -3097,42 +3172,43 @@
 // the default value given by `kConnectionWriteConnectTimeout` and
 // `kConnectionWriteConnectFailures`.
 TEST_F(PortTest, TestWritableStateWithConfiguredThreshold) {
-  ScopedFakeClock clock;
   auto port1 = CreateUdpPort(kLocalAddr1);
   port1->SetIceRole(ICEROLE_CONTROLLING);
   auto port2 = CreateUdpPort(kLocalAddr2);
   port2->SetIceRole(ICEROLE_CONTROLLED);
 
   // Set up channels.
-  TestChannel ch1(std::move(port1));
-  TestChannel ch2(std::move(port2));
+  TestChannel ch1(std::move(port1), time_controller_);
+  TestChannel ch2(std::move(port2), time_controller_);
 
   // Acquire addresses.
   ch1.Start();
   ch2.Start();
-  ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());
-  ASSERT_THAT(WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch2.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
 
   // Send a ping from src to dst.
   ch1.CreateConnection(GetCandidate(ch2.port()));
   ASSERT_TRUE(ch1.conn() != nullptr);
   ch1.Ping();
-  SIMULATED_WAIT(!ch2.remote_address().IsNil(), kShortTimeout, clock);
+  EXPECT_THAT(WaitUntil([&] { return !ch2.remote_address().IsNil(); }, IsTrue(),
+                        {.clock = &time_controller_}),
+              IsRtcOk());
 
   // Accept the connection to return the binding response, transition to
   // writable, and allow data to be sent.
   ch2.AcceptConnection(GetCandidate(ch1.port()));
-  EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); },
-                        Eq(Connection::STATE_WRITABLE),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout),
-                         .clock = &clock}),
-              IsRtcOk());
+  EXPECT_THAT(
+      WaitUntil([&] { return ch1.conn()->write_state(); },
+                Eq(Connection::STATE_WRITABLE),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
 
   ch1.conn()->SetUnwritableTimeout(TimeDelta::Seconds(1));
   ch1.conn()->set_unwritable_min_checks(3);
@@ -3167,8 +3243,8 @@
   port2->SetIceRole(ICEROLE_CONTROLLED);
 
   // Set up channels.
-  TestChannel ch1(std::move(port1));
-  TestChannel ch2(std::move(port2));
+  TestChannel ch1(std::move(port1), time_controller_);
+  TestChannel ch2(std::move(port2), time_controller_);
 
   // Acquire addresses.
   ch1.Start();
@@ -3180,11 +3256,14 @@
 
   // Attempt to go directly to write timeout.
   for (uint32_t i = 1; i <= kConnectionWriteConnectFailures; ++i) {
-    ch1.Ping(Timestamp::Millis(i));
+    time_controller_.AdvanceTime(TimeDelta::Millis(1));
+    ch1.Ping();
   }
-  ch1.conn()->UpdateState(Timestamp::Zero() + kConnectionWriteTimeout +
-                          kMaxExpectedSimulatedRtt);
-  EXPECT_EQ(Connection::STATE_WRITE_TIMEOUT, ch1.conn()->write_state());
+  time_controller_.AdvanceTime(kConnectionWriteTimeout);
+  ch1.conn()->UpdateState(env_.clock().CurrentTime());
+  // The connection should be destroyed because no data received before the
+  // write timeout.
+  EXPECT_THAT(ch1.conn(), IsNull());
 }
 
 // This test verifies the connection setup between ICEMODE_FULL
@@ -3199,16 +3278,17 @@
   auto ice_lite_port = CreateTestPort(kLocalAddr2, "rfrag", "rpass",
                                       ICEROLE_CONTROLLED, kTiebreaker2);
   // Setup TestChannel. This behaves like FULL mode client.
-  TestChannel ch1(std::move(ice_full_port));
+  TestChannel ch1(std::move(ice_full_port), time_controller_);
   ch1.SetIceMode(ICEMODE_FULL);
 
   // Start gathering candidates.
   ch1.Start();
   ice_lite_port->PrepareAddress();
 
-  ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   ASSERT_FALSE(ice_lite_port->Candidates().empty());
 
   ch1.CreateConnection(GetCandidate(ice_lite_port.get()));
@@ -3223,7 +3303,7 @@
   // from port.
   ASSERT_THAT(
       WaitUntil([&] { return ice_full_port_ptr->last_stun_msg(); }, NotNull(),
-                {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
       IsRtcOk());
   IceMessage* msg = ice_full_port_ptr->last_stun_msg();
   EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) == nullptr);
@@ -3242,13 +3322,15 @@
                                             SocketAddress(), std::nullopt));
 
   // Verifying full mode connection becomes writable from the response.
-  EXPECT_THAT(WaitUntil([&] { return ch1.conn()->write_state(); },
-                        Eq(Connection::STATE_WRITABLE),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
-  EXPECT_THAT(WaitUntil([&] { return ch1.nominated(); }, IsTrue(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  EXPECT_THAT(
+      WaitUntil([&] { return ch1.conn()->write_state(); },
+                Eq(Connection::STATE_WRITABLE),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
+  EXPECT_THAT(
+      WaitUntil([&] { return ch1.nominated(); }, IsTrue(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
 
   // Clear existing stun messsages. Otherwise we will process old stun
   // message right after we send ping.
@@ -3257,7 +3339,7 @@
   ch1.Ping();
   ASSERT_THAT(
       WaitUntil([&] { return ice_full_port_ptr->last_stun_msg(); }, NotNull(),
-                {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
       IsRtcOk());
   msg = ice_full_port_ptr->last_stun_msg();
   EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) != nullptr);
@@ -3321,7 +3403,7 @@
   auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED,
                               kTiebreaker2);
 
-  TestChannel ch1(std::move(port1_unique));
+  TestChannel ch1(std::move(port1_unique), time_controller_);
   // Block usage of STUN_ATTR_USE_CANDIDATE so that
   // ch1.conn() will sent GOOG_PING_REQUEST directly.
   // This only makes test a bit shorter...
@@ -3330,9 +3412,10 @@
   ch1.Start();
   port2->PrepareAddress();
 
-  ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   ASSERT_FALSE(port2->Candidates().empty());
 
   ch1.CreateConnection(GetCandidate(port2.get()));
@@ -3343,9 +3426,10 @@
   // Send ping.
   ch1.Ping();
 
-  ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   const IceMessage* request1 = port1->last_stun_msg();
 
   ASSERT_EQ(trials.enable_goog_ping,
@@ -3373,9 +3457,10 @@
   port2->Reset();
 
   ch1.Ping();
-  ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   const IceMessage* request2 = port1->last_stun_msg();
 
   // It should be a GOOG_PING if both of these are TRUE
@@ -3417,7 +3502,7 @@
   auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED,
                               kTiebreaker2);
 
-  TestChannel ch1(std::move(port1_unique));
+  TestChannel ch1(std::move(port1_unique), time_controller_);
   // Block usage of STUN_ATTR_USE_CANDIDATE so that
   // ch1.conn() will sent GOOG_PING_REQUEST directly.
   // This only makes test a bit shorter...
@@ -3426,9 +3511,10 @@
   ch1.Start();
   port2->PrepareAddress();
 
-  ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   ASSERT_FALSE(port2->Candidates().empty());
 
   ch1.CreateConnection(GetCandidate(port2.get()));
@@ -3439,9 +3525,10 @@
   // Send ping.
   ch1.Ping();
 
-  ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   const IceMessage* request1 = port1->last_stun_msg();
 
   ASSERT_TRUE(GetSupportedGoogPingVersion(request1) &&
@@ -3490,7 +3577,7 @@
   auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED,
                               kTiebreaker2);
 
-  TestChannel ch1(std::move(port1_unique));
+  TestChannel ch1(std::move(port1_unique), time_controller_);
   // Block usage of STUN_ATTR_USE_CANDIDATE so that
   // ch1.conn() will sent GOOG_PING_REQUEST directly.
   // This only makes test a bit shorter...
@@ -3499,9 +3586,10 @@
   ch1.Start();
   port2->PrepareAddress();
 
-  ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   ASSERT_FALSE(port2->Candidates().empty());
 
   ch1.CreateConnection(GetCandidate(port2.get()));
@@ -3512,9 +3600,10 @@
   // Send ping.
   ch1.Ping();
 
-  ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   const IceMessage* request1 = port1->last_stun_msg();
 
   ASSERT_TRUE(GetSupportedGoogPingVersion(request1) &&
@@ -3563,9 +3652,10 @@
   port2->Reset();
 
   ch1.Ping();
-  ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
 
   // This should now be a STUN_BINDING...without a kGoogPingVersion
   const IceMessage* request2 = port1->last_stun_msg();
@@ -3595,7 +3685,7 @@
   auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED,
                               kTiebreaker2);
 
-  TestChannel ch1(std::move(port1_unique));
+  TestChannel ch1(std::move(port1_unique), time_controller_);
   // Block usage of STUN_ATTR_USE_CANDIDATE so that
   // ch1.conn() will sent GOOG_PING_REQUEST directly.
   // This only makes test a bit shorter...
@@ -3604,9 +3694,10 @@
   ch1.Start();
   port2->PrepareAddress();
 
-  ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   ASSERT_FALSE(port2->Candidates().empty());
 
   ch1.CreateConnection(GetCandidate(port2.get()));
@@ -3617,9 +3708,10 @@
   // Send ping.
   ch1.Ping();
 
-  ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   const IceMessage* msg = port1->last_stun_msg();
   auto* con =
       port2->CreateConnection(port1->Candidates()[0], Port::ORIGIN_MESSAGE);
@@ -3641,9 +3733,10 @@
   port2->Reset();
 
   ch1.Ping();
-  ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   const IceMessage* msg2 = port1->last_stun_msg();
 
   // It should be a GOOG_PING if both of these are TRUE
@@ -3664,9 +3757,10 @@
   ch1.conn()->set_use_candidate_attr(!ch1.conn()->use_candidate_attr());
 
   ch1.Ping();
-  ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   const IceMessage* msg3 = port1->last_stun_msg();
 
   // It should be a STUN_BINDING_REQUEST
@@ -3687,7 +3781,7 @@
   auto port2 = CreateTestPort(kLocalAddr2, "rfrag", "rpass", ICEROLE_CONTROLLED,
                               kTiebreaker2);
 
-  TestChannel ch1(std::move(port1_unique));
+  TestChannel ch1(std::move(port1_unique), time_controller_);
   // Block usage of STUN_ATTR_USE_CANDIDATE so that
   // ch1.conn() will sent GOOG_PING_REQUEST directly.
   // This only makes test a bit shorter...
@@ -3696,9 +3790,10 @@
   ch1.Start();
   port2->PrepareAddress();
 
-  ASSERT_THAT(WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return ch1.complete_count(); }, Eq(1),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   ASSERT_FALSE(port2->Candidates().empty());
 
   ch1.CreateConnection(GetCandidate(port2.get()));
@@ -3709,9 +3804,10 @@
   // Send ping.
   ch1.Ping();
 
-  ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   const IceMessage* msg = port1->last_stun_msg();
   auto* con =
       port2->CreateConnection(port1->Candidates()[0], Port::ORIGIN_MESSAGE);
@@ -3733,9 +3829,10 @@
   port2->Reset();
 
   ch1.Ping();
-  ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   const IceMessage* msg2 = port1->last_stun_msg();
 
   // It should be a GOOG_PING.
@@ -3763,9 +3860,10 @@
   port2->Reset();
 
   ch1.Ping();
-  ASSERT_THAT(WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
-                        {.timeout = TimeDelta::Millis(kDefaultTimeout)}),
-              IsRtcOk());
+  ASSERT_THAT(
+      WaitUntil([&] { return port1->last_stun_msg(); }, NotNull(),
+                {.timeout = kDefaultTimeout, .clock = &time_controller_}),
+      IsRtcOk());
   const IceMessage* msg3 = port1->last_stun_msg();
 
   // It should be a STUN_BINDING_REQUEST
@@ -3778,7 +3876,6 @@
 // port will time out after connectivity is lost, if they are not marked as
 // "keep alive until pruned."
 TEST_F(PortTest, TestPortTimeoutIfNotKeptAlive) {
-  ScopedFakeClock clock;
   int timeout_delay = 100;
   auto port1 = CreateUdpPort(kLocalAddr1);
   ConnectToSignalDestroyed(port1.get());
@@ -3793,23 +3890,22 @@
   port2->SetIceTiebreaker(kTiebreaker2);
 
   // Set up channels and ensure both ports will be deleted.
-  TestChannel ch1(std::move(port1));
-  TestChannel ch2(std::move(port2));
+  TestChannel ch1(std::move(port1), time_controller_);
+  TestChannel ch2(std::move(port2), time_controller_);
 
   // Simulate a connection that succeeds, and then is destroyed.
   StartConnectAndStopChannels(&ch1, &ch2);
   // After the connection is destroyed, the port will be destroyed because
   // none of them is marked as "keep alive until pruned.
-  EXPECT_THAT(
-      WaitUntil([&] { return ports_destroyed(); }, Eq(2), {.clock = &clock}),
-      IsRtcOk());
+  EXPECT_THAT(WaitUntil([&] { return ports_destroyed(); }, Eq(2),
+                        {.clock = &time_controller_}),
+              IsRtcOk());
 }
 
 // Test that if after all connection are destroyed, new connections are created
 // and destroyed again, ports won't be destroyed until a timeout period passes
 // after the last set of connections are all destroyed.
 TEST_F(PortTest, TestPortTimeoutAfterNewConnectionCreatedAndDestroyed) {
-  ScopedFakeClock clock;
   int timeout_delay = 100;
   auto port1 = CreateUdpPort(kLocalAddr1);
   ConnectToSignalDestroyed(port1.get());
@@ -3825,12 +3921,12 @@
   port2->SetIceTiebreaker(kTiebreaker2);
 
   // Set up channels and ensure both ports will be deleted.
-  TestChannel ch1(std::move(port1));
-  TestChannel ch2(std::move(port2));
+  TestChannel ch1(std::move(port1), time_controller_);
+  TestChannel ch2(std::move(port2), time_controller_);
 
   // Simulate a connection that succeeds, and then is destroyed.
   StartConnectAndStopChannels(&ch1, &ch2);
-  SIMULATED_WAIT(ports_destroyed() > 0, 80, clock);
+  time_controller_.AdvanceTime(TimeDelta::Millis(80));
   EXPECT_EQ(0, ports_destroyed());
 
   // Start the second set of connection and destroy them.
@@ -3839,20 +3935,19 @@
   ch1.Stop();
   ch2.Stop();
 
-  SIMULATED_WAIT(ports_destroyed() > 0, 80, clock);
+  time_controller_.AdvanceTime(TimeDelta::Millis(80));
   EXPECT_EQ(0, ports_destroyed());
 
   // The ports on both sides should be destroyed after timeout.
-  EXPECT_THAT(
-      WaitUntil([&] { return ports_destroyed(); }, Eq(2), {.clock = &clock}),
-      IsRtcOk());
+  EXPECT_THAT(WaitUntil([&] { return ports_destroyed(); }, Eq(2),
+                        {.clock = &time_controller_}),
+              IsRtcOk());
 }
 
 // This test case verifies that neither the controlling port nor the controlled
 // port will time out after connectivity is lost if they are marked as "keep
 // alive until pruned". They will time out after they are pruned.
 TEST_F(PortTest, TestPortNotTimeoutUntilPruned) {
-  ScopedFakeClock clock;
   int timeout_delay = 100;
   auto port1 = CreateUdpPort(kLocalAddr1);
   ConnectToSignalDestroyed(port1.get());
@@ -3872,23 +3967,23 @@
   port2->set_component(ICE_CANDIDATE_COMPONENT_DEFAULT);
 
   // Set up channels and keep the port alive.
-  TestChannel ch1(std::move(port1));
-  TestChannel ch2(std::move(port2));
+  TestChannel ch1(std::move(port1), time_controller_);
+  TestChannel ch2(std::move(port2), time_controller_);
   // Simulate a connection that succeeds, and then is destroyed. But ports
   // are kept alive. Ports won't be destroyed.
   StartConnectAndStopChannels(&ch1, &ch2);
   ch1.port()->KeepAliveUntilPruned();
   ch2.port()->KeepAliveUntilPruned();
-  SIMULATED_WAIT(ports_destroyed() > 0, 150, clock);
+  time_controller_.AdvanceTime(TimeDelta::Millis(150));
   EXPECT_EQ(0, ports_destroyed());
 
   // If they are pruned now, they will be destroyed right away.
   ch1.port()->Prune();
   ch2.port()->Prune();
   // The ports on both sides should be destroyed after timeout.
-  EXPECT_THAT(
-      WaitUntil([&] { return ports_destroyed(); }, Eq(2), {.clock = &clock}),
-      IsRtcOk());
+  EXPECT_THAT(WaitUntil([&] { return ports_destroyed(); }, Eq(2),
+                        {.clock = &time_controller_}),
+              IsRtcOk());
 }
 
 TEST_F(PortTest, TestSupportsProtocol) {
@@ -3951,7 +4046,7 @@
   EXPECT_EQ(2u, conn_in_use->remote_candidate().generation());
 
   // Make sure the new connection was not deleted.
-  Thread::Current()->ProcessMessages(300);
+  time_controller_.AdvanceTime(TimeDelta::Millis(300));
   EXPECT_TRUE(port->GetConnection(address) != nullptr);
 }