diff --git a/rtc_base/ssl_stream_adapter_unittest.cc b/rtc_base/ssl_stream_adapter_unittest.cc
index 3534b1c9ae..01c3529d0a 100644
--- a/rtc_base/ssl_stream_adapter_unittest.cc
+++ b/rtc_base/ssl_stream_adapter_unittest.cc
@@ -583,20 +583,19 @@ class SSLStreamAdapterTestBase : public ::testing::Test,
 
     // Now run the handshake
     if (expect_success) {
-      EXPECT_TRUE_WAIT((client_ssl_->GetState() == rtc::SS_OPEN) &&
-                           (server_ssl_->GetState() == rtc::SS_OPEN),
-                       handshake_wait_);
+      EXPECT_TRUE_SIMULATED_WAIT((client_ssl_->GetState() == rtc::SS_OPEN) &&
+                                     (server_ssl_->GetState() == rtc::SS_OPEN),
+                                 handshake_wait_, clock_);
     } else {
-      EXPECT_TRUE_WAIT(client_ssl_->GetState() == rtc::SS_CLOSED,
-                       handshake_wait_);
+      EXPECT_TRUE_SIMULATED_WAIT(client_ssl_->GetState() == rtc::SS_CLOSED,
+                                 handshake_wait_, clock_);
     }
   }
 
   // This tests that we give up after 12 DTLS resends.
   // Only works for BoringSSL which allows advancing the fake clock.
   void TestHandshakeTimeout() {
-    rtc::ScopedFakeClock clock;
-    int64_t time_start = clock.TimeNanos();
+    int64_t time_start = clock_.TimeNanos();
     webrtc::TimeDelta time_increment = webrtc::TimeDelta::Millis(1000);
 
     if (!dtls_) {
@@ -624,12 +623,12 @@ class SSLStreamAdapterTestBase : public ::testing::Test,
     // Now wait for the handshake to timeout (or fail after an hour of simulated
     // time).
     while (client_ssl_->GetState() == rtc::SS_OPENING &&
-           (rtc::TimeDiff(clock.TimeNanos(), time_start) <
+           (rtc::TimeDiff(clock_.TimeNanos(), time_start) <
             3600 * rtc::kNumNanosecsPerSec)) {
-      EXPECT_TRUE_WAIT(!((client_ssl_->GetState() == rtc::SS_OPEN) &&
-                         (server_ssl_->GetState() == rtc::SS_OPEN)),
-                       1000);
-      clock.AdvanceTime(time_increment);
+      EXPECT_TRUE_SIMULATED_WAIT(!((client_ssl_->GetState() == rtc::SS_OPEN) &&
+                                   (server_ssl_->GetState() == rtc::SS_OPEN)),
+                                 1000, clock_);
+      clock_.AdvanceTime(time_increment);
     }
     EXPECT_EQ(client_ssl_->GetState(), rtc::SS_CLOSED);
   }
@@ -653,9 +652,9 @@ class SSLStreamAdapterTestBase : public ::testing::Test,
     ASSERT_EQ(0, client_ssl_->StartSSL());
 
     // Now run the handshake.
-    EXPECT_TRUE_WAIT(
+    EXPECT_TRUE_SIMULATED_WAIT(
         client_ssl_->IsTlsConnected() && server_ssl_->IsTlsConnected(),
-        handshake_wait_);
+        handshake_wait_, clock_);
 
     // Until the identity has been verified, the state should still be
     // SS_OPENING and writes should return SR_BLOCK.
@@ -856,6 +855,7 @@ class SSLStreamAdapterTestBase : public ::testing::Test,
   }
 
   rtc::AutoThread main_thread_;
+  rtc::ScopedFakeClock clock_;
   std::string client_cert_pem_;
   std::string client_private_key_pem_;
   rtc::KeyParams client_key_type_;
@@ -973,14 +973,15 @@ class SSLStreamAdapterTestDTLSBase : public SSLStreamAdapterTestBase {
 
     WriteData();
 
-    EXPECT_TRUE_WAIT(sent_ == count_, 10000);
+    EXPECT_TRUE_SIMULATED_WAIT(sent_ == count_, 10000, clock_);
     RTC_LOG(LS_INFO) << "sent_ == " << sent_;
 
     if (damage_) {
-      WAIT(false, 2000);
+      SIMULATED_WAIT(false, 2000, clock_);
       EXPECT_EQ(0U, received_.size());
     } else if (loss_ == 0) {
-      EXPECT_EQ_WAIT(static_cast<size_t>(sent_), received_.size(), 1000);
+      EXPECT_EQ_SIMULATED_WAIT(static_cast<size_t>(sent_), received_.size(),
+                               1000, clock_);
     } else {
       RTC_LOG(LS_INFO) << "Sent " << sent_ << " packets; received "
                        << received_.size();