Using fake clock for TURN port tests and un-disabling some tests.

webrtc/p2p/base/turnport_unittest.cc

 /*
  *  Copyright 2012 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #if defined(WEBRTC_POSIX)
 #include <dirent.h>
 #endif
 
 #include <memory>
 
 #include "webrtc/p2p/base/basicpacketsocketfactory.h"
 #include "webrtc/p2p/base/p2pconstants.h"
 #include "webrtc/p2p/base/portallocator.h"
 #include "webrtc/p2p/base/tcpport.h"
 #include "webrtc/p2p/base/testturnserver.h"
 #include "webrtc/p2p/base/turnport.h"
 #include "webrtc/p2p/base/udpport.h"
 #include "webrtc/base/asynctcpsocket.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/dscp.h"
+#include "webrtc/base/fakeclock.h"
 #include "webrtc/base/firewallsocketserver.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/physicalsocketserver.h"
 #include "webrtc/base/socketaddress.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/virtualsocketserver.h"
 
 using rtc::SocketAddress;
-using cricket::Connection;
-using cricket::Port;
-using cricket::PortInterface;
-using cricket::TurnPort;
-using cricket::UDPPort;
 
 static const SocketAddress kLocalAddr1("11.11.11.11", 0);
 static const SocketAddress kLocalAddr2("22.22.22.22", 0);
 static const SocketAddress kLocalIPv6Addr(
     "2401:fa00:4:1000:be30:5bff:fee5:c3", 0);
 static const SocketAddress kLocalIPv6Addr2(
     "2401:fa00:4:2000:be30:5bff:fee5:d4", 0);
 static const SocketAddress kTurnUdpIntAddr("99.99.99.3",
                                            cricket::TURN_SERVER_PORT);
 static const SocketAddress kTurnTcpIntAddr("99.99.99.4",
@@ skipping 10 matching lines @@
     "2400:4030:1:2c00:be30:abcd:efab:cdef", cricket::TURN_SERVER_PORT);
 
 static const char kCandidateFoundation[] = "foundation";
 static const char kIceUfrag1[] = "TESTICEUFRAG0001";
 static const char kIceUfrag2[] = "TESTICEUFRAG0002";
 static const char kIcePwd1[] = "TESTICEPWD00000000000001";
 static const char kIcePwd2[] = "TESTICEPWD00000000000002";
 static const char kTurnUsername[] = "test";
 static const char kTurnPassword[] = "test";
 static const char kTestOrigin[] = "http://example.com";
-static const unsigned int kTimeout = 1000;
+// This test configures the virtual socket server to simulate delay so that we
+// can verify operations take no more than the expected number of round trips.
+static constexpr unsigned int kSimulatedRtt = 50;
+// Connection destruction may happen asynchronously, but it should only
+// take one simulated clock tick.
+static constexpr unsigned int kConnectionDestructionDelay = 1;
+// This used to be 1 second, but that's not always enough for getaddrinfo().
+// See: https://bugs.chromium.org/p/webrtc/issues/detail?id=5191
+static constexpr unsigned int kResolverTimeout = 10000;
 
 static const cricket::ProtocolAddress kTurnUdpProtoAddr(
     kTurnUdpIntAddr, cricket::PROTO_UDP);
 static const cricket::ProtocolAddress kTurnTcpProtoAddr(
     kTurnTcpIntAddr, cricket::PROTO_TCP);
 static const cricket::ProtocolAddress kTurnUdpIPv6ProtoAddr(
     kTurnUdpIPv6IntAddr, cricket::PROTO_UDP);
 
 static const unsigned int MSG_TESTFINISH = 0;
 
 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
 static int GetFDCount() {
   struct dirent *dp;
   int fd_count = 0;
   DIR *dir = opendir("/proc/self/fd/");
   while ((dp = readdir(dir)) != NULL) {
     if (dp->d_name[0] == '.')
       continue;
     ++fd_count;
   }
   closedir(dir);
   return fd_count;
 }
 #endif
 
+namespace cricket {
+
 class TurnPortTestVirtualSocketServer : public rtc::VirtualSocketServer {
  public:
   explicit TurnPortTestVirtualSocketServer(SocketServer* ss)
-      : VirtualSocketServer(ss) {}
+      : VirtualSocketServer(ss) {
+    // This configures the virtual socket server to always add a simulated
+    // delay of exactly half of kSimulatedRtt.
+    set_delay_mean(kSimulatedRtt / 2);
+    UpdateDelayDistribution();
+  }
 
   using rtc::VirtualSocketServer::LookupBinding;
 };
 
 class TestConnectionWrapper : public sigslot::has_slots<> {
  public:
   TestConnectionWrapper(Connection* conn) : connection_(conn) {
     conn->SignalDestroyed.connect(
         this, &TestConnectionWrapper::OnConnectionDestroyed);
   }
 
   Connection* connection() { return connection_; }
 
  private:
   void OnConnectionDestroyed(Connection* conn) {
     ASSERT_TRUE(conn == connection_);
     connection_ = nullptr;
   }
 
   Connection* connection_;
 };
 
+// Note: This test uses a fake clock with a simulated network round trip
+// (between local port and TURN server) of kSimulatedRtt.
 class TurnPortTest : public testing::Test,
                      public sigslot::has_slots<>,
                      public rtc::MessageHandler {
  public:
   TurnPortTest()
       : main_(rtc::Thread::Current()),
         pss_(new rtc::PhysicalSocketServer),
         ss_(new TurnPortTestVirtualSocketServer(pss_.get())),
         ss_scope_(ss_.get()),
         network_("unittest", "unittest", rtc::IPAddress(INADDR_ANY), 32),
         socket_factory_(rtc::Thread::Current()),
         turn_server_(main_, kTurnUdpIntAddr, kTurnUdpExtAddr),
         turn_ready_(false),
         turn_error_(false),
         turn_unknown_address_(false),
         turn_create_permission_success_(false),
         udp_ready_(false),
         test_finish_(false) {
+    // Some code uses "last received time == 0" to represent "nothing received
+    // so far", so we need to start the fake clock at a nonzero time...
+    // TODO(deadbeef): Fix this.
+    fake_clock_.AdvanceTime(rtc::TimeDelta::FromSeconds(1));
     network_.AddIP(rtc::IPAddress(INADDR_ANY));
   }
 
   virtual void OnMessage(rtc::Message* msg) {
     ASSERT(msg->message_id == MSG_TESTFINISH);
     if (msg->message_id == MSG_TESTFINISH)
       test_finish_ = true;
   }
 
   void ConnectSignalAddressReadyToSetLocalhostAsAltenertativeLocalAddress() {
@@ skipping 10 matching lines @@
     SocketAddress local_address("127.0.0.1", 2000);
     socket->SetAlternativeLocalAddress(local_address);
   }
 
   void OnTurnPortComplete(Port* port) {
     turn_ready_ = true;
   }
   void OnTurnPortError(Port* port) {
     turn_error_ = true;
   }
-  void OnTurnUnknownAddress(PortInterface* port, const SocketAddress& addr,
-                            cricket::ProtocolType proto,
-                            cricket::IceMessage* msg, const std::string& rf,
+  void OnTurnUnknownAddress(PortInterface* port,
+                            const SocketAddress& addr,
+                            ProtocolType proto,
+                            IceMessage* msg,
+                            const std::string& rf,
                             bool /*port_muxed*/) {
     turn_unknown_address_ = true;
   }
   void OnTurnCreatePermissionResult(TurnPort* port,
                                     const SocketAddress& addr,
                                     int code) {
     // Ignoring the address.
     turn_create_permission_success_ = (code == 0);
   }
 
@@ skipping 20 matching lines @@
   }
   rtc::AsyncSocket* CreateServerSocket(const SocketAddress addr) {
     rtc::AsyncSocket* socket = ss_->CreateAsyncSocket(SOCK_STREAM);
     EXPECT_GE(socket->Bind(addr), 0);
     EXPECT_GE(socket->Listen(5), 0);
     return socket;
   }
 
   void CreateTurnPort(const std::string& username,
                       const std::string& password,
-                      const cricket::ProtocolAddress& server_address) {
+                      const ProtocolAddress& server_address) {
     CreateTurnPort(kLocalAddr1, username, password, server_address);
   }
   void CreateTurnPort(const rtc::SocketAddress& local_address,
                       const std::string& username,
                       const std::string& password,
-                      const cricket::ProtocolAddress& server_address) {
-    cricket::RelayCredentials credentials(username, password);
+                      const ProtocolAddress& server_address) {
+    RelayCredentials credentials(username, password);
     turn_port_.reset(TurnPort::Create(main_, &socket_factory_, &network_,
                                  local_address.ipaddr(), 0, 0,
                                  kIceUfrag1, kIcePwd1,
                                  server_address, credentials, 0,
                                  std::string()));
     // This TURN port will be the controlling.
-    turn_port_->SetIceRole(cricket::ICEROLE_CONTROLLING);
+    turn_port_->SetIceRole(ICEROLE_CONTROLLING);
     ConnectSignals();
   }
 
   // Should be identical to CreateTurnPort but specifies an origin value
   // when creating the instance of TurnPort.
   void CreateTurnPortWithOrigin(const rtc::SocketAddress& local_address,
                                 const std::string& username,
                                 const std::string& password,
-                                const cricket::ProtocolAddress& server_address,
+                                const ProtocolAddress& server_address,
                                 const std::string& origin) {
-    cricket::RelayCredentials credentials(username, password);
+    RelayCredentials credentials(username, password);
     turn_port_.reset(TurnPort::Create(main_, &socket_factory_, &network_,
                                  local_address.ipaddr(), 0, 0,
                                  kIceUfrag1, kIcePwd1,
                                  server_address, credentials, 0,
                                  origin));
     // This TURN port will be the controlling.
-    turn_port_->SetIceRole(cricket::ICEROLE_CONTROLLING);
+    turn_port_->SetIceRole(ICEROLE_CONTROLLING);
     ConnectSignals();
   }
 
   void CreateSharedTurnPort(const std::string& username,
                             const std::string& password,
-                            const cricket::ProtocolAddress& server_address) {
-    ASSERT(server_address.proto == cricket::PROTO_UDP);
+                            const ProtocolAddress& server_address) {
+    ASSERT(server_address.proto == PROTO_UDP);
 
     if (!socket_) {
       socket_.reset(socket_factory_.CreateUdpSocket(
           rtc::SocketAddress(kLocalAddr1.ipaddr(), 0), 0, 0));
       ASSERT_TRUE(socket_ != NULL);
       socket_->SignalReadPacket.connect(
           this, &TurnPortTest::OnSocketReadPacket);
     }
 
-    cricket::RelayCredentials credentials(username, password);
-    turn_port_.reset(cricket::TurnPort::Create(
-        main_, &socket_factory_, &network_, socket_.get(),
-        kIceUfrag1, kIcePwd1, server_address, credentials, 0, std::string()));
+    RelayCredentials credentials(username, password);
+    turn_port_.reset(TurnPort::Create(
+        main_, &socket_factory_, &network_, socket_.get(), kIceUfrag1, kIcePwd1,
+        server_address, credentials, 0, std::string()));
     // This TURN port will be the controlling.
-    turn_port_->SetIceRole(cricket::ICEROLE_CONTROLLING);
+    turn_port_->SetIceRole(ICEROLE_CONTROLLING);
     ConnectSignals();
   }
 
   void ConnectSignals() {
     turn_port_->SignalPortComplete.connect(this,
         &TurnPortTest::OnTurnPortComplete);
     turn_port_->SignalPortError.connect(this,
         &TurnPortTest::OnTurnPortError);
     turn_port_->SignalUnknownAddress.connect(this,
         &TurnPortTest::OnTurnUnknownAddress);
     turn_port_->SignalCreatePermissionResult.connect(this,
         &TurnPortTest::OnTurnCreatePermissionResult);
     turn_port_->SignalTurnRefreshResult.connect(
         this, &TurnPortTest::OnTurnRefreshResult);
   }
 
   void CreateUdpPort() { CreateUdpPort(kLocalAddr2); }
 
   void CreateUdpPort(const SocketAddress& address) {
     udp_port_.reset(UDPPort::Create(main_, &socket_factory_, &network_,
                                     address.ipaddr(), 0, 0, kIceUfrag2,
                                     kIcePwd2, std::string(), false));
     // UDP port will be controlled.
-    udp_port_->SetIceRole(cricket::ICEROLE_CONTROLLED);
+    udp_port_->SetIceRole(ICEROLE_CONTROLLED);
     udp_port_->SignalPortComplete.connect(
         this, &TurnPortTest::OnUdpPortComplete);
   }
 
-  void PrepareTurnAndUdpPorts() {
+  void PrepareTurnAndUdpPorts(ProtocolType protocol_type) {
     // turn_port_ should have been created.
     ASSERT_TRUE(turn_port_ != nullptr);
     turn_port_->PrepareAddress();
-    ASSERT_TRUE_WAIT(turn_ready_, kTimeout);
+    // Two round trips are required to allocate a TURN candidate.
+    // Plus, an extra round trip is needed for TCP.
+    ASSERT_TRUE_SIMULATED_WAIT(
+        turn_ready_,
+        protocol_type == PROTO_TCP ? kSimulatedRtt * 3 : kSimulatedRtt * 2,
+        fake_clock_);
 
     CreateUdpPort();
     udp_port_->PrepareAddress();
-    ASSERT_TRUE_WAIT(udp_ready_, kTimeout);
+    ASSERT_TRUE_SIMULATED_WAIT(udp_ready_, kSimulatedRtt, fake_clock_);
   }
 
   bool CheckConnectionFailedAndPruned(Connection* conn) {
     return conn && !conn->active() && conn->state() == Connection::STATE_FAILED;
   }
 
   // Checks that |turn_port_| has a nonempty set of connections and they are all
   // failed and pruned.
   bool CheckAllConnectionsFailedAndPruned() {
     auto& connections = turn_port_->connections();
     if (connections.empty()) {
       return false;
     }
     for (auto kv : connections) {
       if (!CheckConnectionFailedAndPruned(kv.second)) {
         return false;
       }
     }
     return true;
   }
 
-  void TestTurnAlternateServer(cricket::ProtocolType protocol_type) {
+  void TestTurnAlternateServer(ProtocolType protocol_type) {
     std::vector<rtc::SocketAddress> redirect_addresses;
     redirect_addresses.push_back(kTurnAlternateIntAddr);
 
-    cricket::TestTurnRedirector redirector(redirect_addresses);
+    TestTurnRedirector redirector(redirect_addresses);
 
     turn_server_.AddInternalSocket(kTurnIntAddr, protocol_type);
     turn_server_.AddInternalSocket(kTurnAlternateIntAddr, protocol_type);
     turn_server_.set_redirect_hook(&redirector);
     CreateTurnPort(kTurnUsername, kTurnPassword,
-                   cricket::ProtocolAddress(kTurnIntAddr, protocol_type));
+                   ProtocolAddress(kTurnIntAddr, protocol_type));
 
     // Retrieve the address before we run the state machine.
     const SocketAddress old_addr = turn_port_->server_address().address;
 
     turn_port_->PrepareAddress();
-    EXPECT_TRUE_WAIT(turn_ready_, kTimeout * 100);
+    // Extra round trip due to "use alternate server" error response.
+    EXPECT_TRUE_SIMULATED_WAIT(
+        turn_ready_,
+        (protocol_type == PROTO_TCP ? kSimulatedRtt * 4 : kSimulatedRtt * 3),
+        fake_clock_);
     // Retrieve the address again, the turn port's address should be
     // changed.
     const SocketAddress new_addr = turn_port_->server_address().address;
     EXPECT_NE(old_addr, new_addr);
     ASSERT_EQ(1U, turn_port_->Candidates().size());
     EXPECT_EQ(kTurnUdpExtAddr.ipaddr(),
               turn_port_->Candidates()[0].address().ipaddr());
     EXPECT_NE(0, turn_port_->Candidates()[0].address().port());
   }
 
-  void TestTurnAlternateServerV4toV6(cricket::ProtocolType protocol_type) {
+  void TestTurnAlternateServerV4toV6(ProtocolType protocol_type) {
     std::vector<rtc::SocketAddress> redirect_addresses;
     redirect_addresses.push_back(kTurnIPv6IntAddr);
 
-    cricket::TestTurnRedirector redirector(redirect_addresses);
+    TestTurnRedirector redirector(redirect_addresses);
     turn_server_.AddInternalSocket(kTurnIntAddr, protocol_type);
     turn_server_.set_redirect_hook(&redirector);
     CreateTurnPort(kTurnUsername, kTurnPassword,
-                   cricket::ProtocolAddress(kTurnIntAddr, protocol_type));
+                   ProtocolAddress(kTurnIntAddr, protocol_type));
     turn_port_->PrepareAddress();
-    EXPECT_TRUE_WAIT(turn_error_, kTimeout);
+    EXPECT_TRUE_SIMULATED_WAIT(turn_error_, kSimulatedRtt * 2, fake_clock_);
   }
 
-  void TestTurnAlternateServerPingPong(cricket::ProtocolType protocol_type) {
+  void TestTurnAlternateServerPingPong(ProtocolType protocol_type) {
     std::vector<rtc::SocketAddress> redirect_addresses;
     redirect_addresses.push_back(kTurnAlternateIntAddr);
     redirect_addresses.push_back(kTurnIntAddr);
 
-    cricket::TestTurnRedirector redirector(redirect_addresses);
+    TestTurnRedirector redirector(redirect_addresses);
 
     turn_server_.AddInternalSocket(kTurnIntAddr, protocol_type);
     turn_server_.AddInternalSocket(kTurnAlternateIntAddr, protocol_type);
     turn_server_.set_redirect_hook(&redirector);
     CreateTurnPort(kTurnUsername, kTurnPassword,
-                   cricket::ProtocolAddress(kTurnIntAddr, protocol_type));
+                   ProtocolAddress(kTurnIntAddr, protocol_type));
 
     turn_port_->PrepareAddress();
-    EXPECT_TRUE_WAIT(turn_error_, kTimeout);
+    // Extra round trip due to "use alternate server" error response.
+    EXPECT_TRUE_SIMULATED_WAIT(
+        turn_error_,
+        (protocol_type == PROTO_TCP ? kSimulatedRtt * 4 : kSimulatedRtt * 3),
+        fake_clock_);
     ASSERT_EQ(0U, turn_port_->Candidates().size());
     rtc::SocketAddress address;
     // Verify that we have exhausted all alternate servers instead of
     // failure caused by other errors.
     EXPECT_FALSE(redirector.ShouldRedirect(address, &address));
   }
 
-  void TestTurnAlternateServerDetectRepetition(
-      cricket::ProtocolType protocol_type) {
+  void TestTurnAlternateServerDetectRepetition(ProtocolType protocol_type) {
     std::vector<rtc::SocketAddress> redirect_addresses;
     redirect_addresses.push_back(kTurnAlternateIntAddr);
     redirect_addresses.push_back(kTurnAlternateIntAddr);
 
-    cricket::TestTurnRedirector redirector(redirect_addresses);
+    TestTurnRedirector redirector(redirect_addresses);
 
     turn_server_.AddInternalSocket(kTurnIntAddr, protocol_type);
     turn_server_.AddInternalSocket(kTurnAlternateIntAddr, protocol_type);
     turn_server_.set_redirect_hook(&redirector);
     CreateTurnPort(kTurnUsername, kTurnPassword,
-                   cricket::ProtocolAddress(kTurnIntAddr, protocol_type));
+                   ProtocolAddress(kTurnIntAddr, protocol_type));
 
     turn_port_->PrepareAddress();
-    EXPECT_TRUE_WAIT(turn_error_, kTimeout);
+    // Extra round trip due to "use alternate server" error response.
+    EXPECT_TRUE_SIMULATED_WAIT(
+        turn_error_,
+        (protocol_type == PROTO_TCP ? kSimulatedRtt * 4 : kSimulatedRtt * 3),
+        fake_clock_);
     ASSERT_EQ(0U, turn_port_->Candidates().size());
   }
 
-  void TestTurnConnection() {
+  void TestTurnConnection(ProtocolType protocol_type) {
     // Create ports and prepare addresses.
-    PrepareTurnAndUdpPorts();
+    PrepareTurnAndUdpPorts(protocol_type);
 
     // Send ping from UDP to TURN.
     Connection* conn1 = udp_port_->CreateConnection(
                     turn_port_->Candidates()[0], Port::ORIGIN_MESSAGE);
     ASSERT_TRUE(conn1 != NULL);
     conn1->Ping(0);
-    WAIT(!turn_unknown_address_, kTimeout);
+    SIMULATED_WAIT(!turn_unknown_address_, kSimulatedRtt * 2, fake_clock_);
     EXPECT_FALSE(turn_unknown_address_);
     EXPECT_FALSE(conn1->receiving());
     EXPECT_EQ(Connection::STATE_WRITE_INIT, conn1->write_state());
 
     // Send ping from TURN to UDP.
     Connection* conn2 = turn_port_->CreateConnection(
                     udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE);
     ASSERT_TRUE(conn2 != NULL);
-    ASSERT_TRUE_WAIT(turn_create_permission_success_, kTimeout);
+    ASSERT_TRUE_SIMULATED_WAIT(turn_create_permission_success_, kSimulatedRtt,
+                               fake_clock_);
     conn2->Ping(0);
 
-    EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, conn2->write_state(), kTimeout);
+    // Two hops from TURN port to UDP port through TURN server, thus two RTTs.
+    EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn2->write_state(),
+                             kSimulatedRtt * 2, fake_clock_);
     EXPECT_TRUE(conn1->receiving());
     EXPECT_TRUE(conn2->receiving());
     EXPECT_EQ(Connection::STATE_WRITE_INIT, conn1->write_state());
 
     // Send another ping from UDP to TURN.
     conn1->Ping(0);
-    EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, conn1->write_state(), kTimeout);
+    EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn1->write_state(),
+                             kSimulatedRtt * 2, fake_clock_);
     EXPECT_TRUE(conn2->receiving());
   }
 
   void TestDestroyTurnConnection() {
-    PrepareTurnAndUdpPorts();
+    PrepareTurnAndUdpPorts(PROTO_UDP);
 
     // Create connections on both ends.
     Connection* conn1 = udp_port_->CreateConnection(turn_port_->Candidates()[0],
                                                     Port::ORIGIN_MESSAGE);
     Connection* conn2 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                                      Port::ORIGIN_MESSAGE);
     ASSERT_TRUE(conn2 != NULL);
-    ASSERT_TRUE_WAIT(turn_create_permission_success_, kTimeout);
+    ASSERT_TRUE_SIMULATED_WAIT(turn_create_permission_success_, kSimulatedRtt,
+                               fake_clock_);
     // Make sure turn connection can receive.
     conn1->Ping(0);
-    EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, conn1->write_state(), kTimeout);
+    EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn1->write_state(),
+                             kSimulatedRtt * 2, fake_clock_);
     EXPECT_FALSE(turn_unknown_address_);
 
-    // Destroy the connection on the turn port. The TurnEntry is still
-    // there. So the turn port gets ping from unknown address if it is pinged.
+    // Destroy the connection on the TURN port. The TurnEntry still exists, so
+    // the TURN port should still process a ping from an unknown address.
     conn2->Destroy();
     conn1->Ping(0);
-    EXPECT_TRUE_WAIT(turn_unknown_address_, kTimeout);
+    EXPECT_TRUE_SIMULATED_WAIT(turn_unknown_address_, kSimulatedRtt,
+                               fake_clock_);
 
     // Flush all requests in the invoker to destroy the TurnEntry.
-    // However, the TURN port should still signal the unknown address.
+    // Expect that it still processes an incoming ping and signals the
+    // unknown address.
     turn_unknown_address_ = false;
     turn_port_->invoker()->Flush(rtc::Thread::Current());
     conn1->Ping(0);
-    EXPECT_TRUE_WAIT(turn_unknown_address_, kTimeout);
+    EXPECT_TRUE_SIMULATED_WAIT(turn_unknown_address_, kSimulatedRtt,
+                               fake_clock_);
 
     // If the connection is created again, it will start to receive pings.
     conn2 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                          Port::ORIGIN_MESSAGE);
     conn1->Ping(0);
-    EXPECT_TRUE_WAIT(conn2->receiving(), kTimeout);
+    EXPECT_TRUE_SIMULATED_WAIT(conn2->receiving(), kSimulatedRtt, fake_clock_);
   }
 
-  void TestTurnSendData() {
-    PrepareTurnAndUdpPorts();
+  void TestTurnSendData(ProtocolType protocol_type) {
+    PrepareTurnAndUdpPorts(protocol_type);
 
     // Create connections and send pings.
     Connection* conn1 = turn_port_->CreateConnection(
         udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE);
     Connection* conn2 = udp_port_->CreateConnection(
         turn_port_->Candidates()[0], Port::ORIGIN_MESSAGE);
     ASSERT_TRUE(conn1 != NULL);
     ASSERT_TRUE(conn2 != NULL);
     conn1->SignalReadPacket.connect(static_cast<TurnPortTest*>(this),
                                     &TurnPortTest::OnTurnReadPacket);
     conn2->SignalReadPacket.connect(static_cast<TurnPortTest*>(this),
                                     &TurnPortTest::OnUdpReadPacket);
     conn1->Ping(0);
-    EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, conn1->write_state(), kTimeout);
+    EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn1->write_state(),
+                             kSimulatedRtt * 2, fake_clock_);
     conn2->Ping(0);
-    EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, conn2->write_state(), kTimeout);
+    EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn2->write_state(),
+                             kSimulatedRtt * 2, fake_clock_);
 
     // Send some data.
     size_t num_packets = 256;
     for (size_t i = 0; i < num_packets; ++i) {
       unsigned char buf[256] = { 0 };
       for (size_t j = 0; j < i + 1; ++j) {
         buf[j] = 0xFF - static_cast<unsigned char>(j);
       }
       conn1->Send(buf, i + 1, options);
       conn2->Send(buf, i + 1, options);
-      main_->ProcessMessages(0);
+      SIMULATED_WAIT(false, kSimulatedRtt, fake_clock_);
     }
 
     // Check the data.
-    ASSERT_EQ_WAIT(num_packets, turn_packets_.size(), kTimeout);
-    ASSERT_EQ_WAIT(num_packets, udp_packets_.size(), kTimeout);
+    ASSERT_EQ(num_packets, turn_packets_.size());
+    ASSERT_EQ(num_packets, udp_packets_.size());
     for (size_t i = 0; i < num_packets; ++i) {
       EXPECT_EQ(i + 1, turn_packets_[i].size());
       EXPECT_EQ(i + 1, udp_packets_[i].size());
       EXPECT_EQ(turn_packets_[i], udp_packets_[i]);
     }
   }
 
  protected:
+  rtc::ScopedFakeClock fake_clock_;
   rtc::Thread* main_;
   std::unique_ptr<rtc::PhysicalSocketServer> pss_;
   std::unique_ptr<TurnPortTestVirtualSocketServer> ss_;
   rtc::SocketServerScope ss_scope_;
   rtc::Network network_;
   rtc::BasicPacketSocketFactory socket_factory_;
   std::unique_ptr<rtc::AsyncPacketSocket> socket_;
-  cricket::TestTurnServer turn_server_;
+  TestTurnServer turn_server_;
   std::unique_ptr<TurnPort> turn_port_;
   std::unique_ptr<UDPPort> udp_port_;
   bool turn_ready_;
   bool turn_error_;
   bool turn_unknown_address_;
   bool turn_create_permission_success_;
   bool udp_ready_;
   bool test_finish_;
   bool turn_refresh_success_ = false;
   std::vector<rtc::Buffer> turn_packets_;
   std::vector<rtc::Buffer> udp_packets_;
   rtc::PacketOptions options;
 };
 
 // Do a normal TURN allocation.
 TEST_F(TurnPortTest, TestTurnAllocate) {
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
   EXPECT_EQ(0, turn_port_->SetOption(rtc::Socket::OPT_SNDBUF, 10*1024));
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 2, fake_clock_);
   ASSERT_EQ(1U, turn_port_->Candidates().size());
   EXPECT_EQ(kTurnUdpExtAddr.ipaddr(),
             turn_port_->Candidates()[0].address().ipaddr());
   EXPECT_NE(0, turn_port_->Candidates()[0].address().port());
 }
 
 // Testing a normal UDP allocation using TCP connection.
 TEST_F(TurnPortTest, TestTurnTcpAllocate) {
-  turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
+  turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
   EXPECT_EQ(0, turn_port_->SetOption(rtc::Socket::OPT_SNDBUF, 10*1024));
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 3, fake_clock_);
   ASSERT_EQ(1U, turn_port_->Candidates().size());
   EXPECT_EQ(kTurnUdpExtAddr.ipaddr(),
             turn_port_->Candidates()[0].address().ipaddr());
   EXPECT_NE(0, turn_port_->Candidates()[0].address().port());
 }
 
 // Test case for WebRTC issue 3927 where a proxy binds to the local host address
 // instead the address that TurnPort originally bound to. The candidate pair
 // impacted by this behavior should still be used.
 TEST_F(TurnPortTest, TestTurnTcpAllocationWhenProxyChangesAddressToLocalHost) {
-  turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
+  turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
   EXPECT_EQ(0, turn_port_->SetOption(rtc::Socket::OPT_SNDBUF, 10 * 1024));
   turn_port_->PrepareAddress();
   ConnectSignalAddressReadyToSetLocalhostAsAltenertativeLocalAddress();
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 3, fake_clock_);
   ASSERT_EQ(1U, turn_port_->Candidates().size());
   EXPECT_EQ(kTurnUdpExtAddr.ipaddr(),
             turn_port_->Candidates()[0].address().ipaddr());
   EXPECT_NE(0, turn_port_->Candidates()[0].address().port());
 }
 
 // Testing turn port will attempt to create TCP socket on address resolution
 // failure.
-TEST_F(TurnPortTest, DISABLED_TestTurnTcpOnAddressResolveFailure) {
-  turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
-  CreateTurnPort(kTurnUsername, kTurnPassword, cricket::ProtocolAddress(
-      rtc::SocketAddress("www.webrtc-blah-blah.com", 3478),
-      cricket::PROTO_TCP));
+TEST_F(TurnPortTest, TestTurnTcpOnAddressResolveFailure) {
+  turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
+  CreateTurnPort(kTurnUsername, kTurnPassword,
+                 ProtocolAddress(rtc::SocketAddress("www.google.invalid", 3478),
+                                 PROTO_TCP));
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_error_, kTimeout);
+  EXPECT_TRUE_WAIT(turn_error_, kResolverTimeout);
   // As VSS doesn't provide a DNS resolution, name resolve will fail. TurnPort
   // will proceed in creating a TCP socket which will fail as there is no
   // server on the above domain and error will be set to SOCKET_ERROR.
   EXPECT_EQ(SOCKET_ERROR, turn_port_->error());
 }
 
 // In case of UDP on address resolve failure, TurnPort will not create socket
 // and return allocate failure.
-TEST_F(TurnPortTest, DISABLED_TestTurnUdpOnAddressResolveFailure) {
-  CreateTurnPort(kTurnUsername, kTurnPassword, cricket::ProtocolAddress(
-      rtc::SocketAddress("www.webrtc-blah-blah.com", 3478),
-      cricket::PROTO_UDP));
+TEST_F(TurnPortTest, TestTurnUdpOnAddressResolveFailure) {
+  CreateTurnPort(kTurnUsername, kTurnPassword,
+                 ProtocolAddress(rtc::SocketAddress("www.google.invalid", 3478),
+                                 PROTO_UDP));
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_error_, kTimeout);
+  EXPECT_TRUE_WAIT(turn_error_, kResolverTimeout);
   // Error from turn port will not be socket error.
   EXPECT_NE(SOCKET_ERROR, turn_port_->error());
 }
 
 // Try to do a TURN allocation with an invalid password.
 TEST_F(TurnPortTest, TestTurnAllocateBadPassword) {
   CreateTurnPort(kTurnUsername, "bad", kTurnUdpProtoAddr);
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_error_, kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_error_, kSimulatedRtt * 2, fake_clock_);
   ASSERT_EQ(0U, turn_port_->Candidates().size());
 }
 
 // Tests that TURN port nonce will be reset when receiving an ALLOCATE MISMATCH
 // error.
 TEST_F(TurnPortTest, TestTurnAllocateNonceResetAfterAllocateMismatch) {
   // Do a normal allocation first.
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 2, fake_clock_);
   rtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
   // Destroy the turnport while keeping the drop probability to 1 to
   // suppress the release of the allocation at the server.
   ss_->set_drop_probability(1.0);
   turn_port_.reset();
-  rtc::Thread::Current()->ProcessMessages(0);
+  SIMULATED_WAIT(false, kSimulatedRtt, fake_clock_);
   ss_->set_drop_probability(0.0);
 
   // Force the socket server to assign the same port.
   ss_->SetNextPortForTesting(first_addr.port());
   turn_ready_ = false;
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
 
   // It is expected that the turn port will first get a nonce from the server
   // using timestamp |ts_before| but then get an allocate mismatch error and
   // receive an even newer nonce based on the system clock. |ts_before| is
   // chosen so that the two NONCEs generated by the server will be different.
   int64_t ts_before = rtc::TimeMillis() - 1;
   std::string first_nonce =
       turn_server_.server()->SetTimestampForNextNonce(ts_before);
   turn_port_->PrepareAddress();
 
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  // Four round trips; first we'll get "stale nonce", then
+  // "allocate mismatch", then "stale nonce" again, then finally it will
+  // succeed.
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 4, fake_clock_);
   EXPECT_NE(first_nonce, turn_port_->nonce());
 }
 
 // Tests that a new local address is created after
 // STUN_ERROR_ALLOCATION_MISMATCH.
 TEST_F(TurnPortTest, TestTurnAllocateMismatch) {
   // Do a normal allocation first.
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 2, fake_clock_);
   rtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
 
   // Clear connected_ flag on turnport to suppress the release of
   // the allocation.
   turn_port_->OnSocketClose(turn_port_->socket(), 0);
 
   // Forces the socket server to assign the same port.
   ss_->SetNextPortForTesting(first_addr.port());
 
   turn_ready_ = false;
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
   turn_port_->PrepareAddress();
 
   // Verifies that the new port has the same address.
   EXPECT_EQ(first_addr, turn_port_->socket()->GetLocalAddress());
 
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  // Four round trips; first we'll get "stale nonce", then
+  // "allocate mismatch", then "stale nonce" again, then finally it will
+  // succeed.
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 4, fake_clock_);
 
   // Verifies that the new port has a different address now.
   EXPECT_NE(first_addr, turn_port_->socket()->GetLocalAddress());
 
   // Verify that all packets received from the shared socket are ignored.
   std::string test_packet = "Test packet";
   EXPECT_FALSE(turn_port_->HandleIncomingPacket(
       socket_.get(), test_packet.data(), test_packet.size(),
       rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0),
       rtc::CreatePacketTime(0)));
 }
 
 // Tests that a shared-socket-TurnPort creates its own socket after
 // STUN_ERROR_ALLOCATION_MISMATCH.
 TEST_F(TurnPortTest, TestSharedSocketAllocateMismatch) {
   // Do a normal allocation first.
   CreateSharedTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 2, fake_clock_);
   rtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
 
   // Clear connected_ flag on turnport to suppress the release of
   // the allocation.
   turn_port_->OnSocketClose(turn_port_->socket(), 0);
 
   turn_ready_ = false;
   CreateSharedTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
 
   // Verifies that the new port has the same address.
   EXPECT_EQ(first_addr, turn_port_->socket()->GetLocalAddress());
   EXPECT_TRUE(turn_port_->SharedSocket());
 
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  // Extra 2 round trips due to allocate mismatch.
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 4, fake_clock_);
 
   // Verifies that the new port has a different address now.
   EXPECT_NE(first_addr, turn_port_->socket()->GetLocalAddress());
   EXPECT_FALSE(turn_port_->SharedSocket());
 }
 
 TEST_F(TurnPortTest, TestTurnTcpAllocateMismatch) {
-  turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
+  turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
 
   // Do a normal allocation first.
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 3, fake_clock_);
   rtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
 
   // Clear connected_ flag on turnport to suppress the release of
   // the allocation.
   turn_port_->OnSocketClose(turn_port_->socket(), 0);
 
   // Forces the socket server to assign the same port.
   ss_->SetNextPortForTesting(first_addr.port());
 
   turn_ready_ = false;
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
   turn_port_->PrepareAddress();
 
   // Verifies that the new port has the same address.
   EXPECT_EQ(first_addr, turn_port_->socket()->GetLocalAddress());
 
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  // Extra 2 round trips due to allocate mismatch.
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 5, fake_clock_);
 
   // Verifies that the new port has a different address now.
   EXPECT_NE(first_addr, turn_port_->socket()->GetLocalAddress());
 }
 
 TEST_F(TurnPortTest, TestRefreshRequestGetsErrorResponse) {
-  rtc::ScopedFakeClock clock;
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
-  PrepareTurnAndUdpPorts();
+  PrepareTurnAndUdpPorts(PROTO_UDP);
   turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                Port::ORIGIN_MESSAGE);
   // Set bad credentials.
-  cricket::RelayCredentials bad_credentials("bad_user", "bad_pwd");
+  RelayCredentials bad_credentials("bad_user", "bad_pwd");
   turn_port_->set_credentials(bad_credentials);
   turn_refresh_success_ = false;
   // This sends out the first RefreshRequest with correct credentials.
   // When this succeeds, it will schedule a new RefreshRequest with the bad
   // credential.
-  turn_port_->FlushRequests(cricket::TURN_REFRESH_REQUEST);
-  EXPECT_TRUE_SIMULATED_WAIT(turn_refresh_success_, kTimeout, clock);
+  turn_port_->FlushRequests(TURN_REFRESH_REQUEST);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_refresh_success_, kSimulatedRtt, fake_clock_);
   // Flush it again, it will receive a bad response.
-  turn_port_->FlushRequests(cricket::TURN_REFRESH_REQUEST);
-  EXPECT_TRUE_SIMULATED_WAIT(!turn_refresh_success_, kTimeout, clock);
-  EXPECT_TRUE_SIMULATED_WAIT(!turn_port_->connected(), kTimeout, clock);
-  EXPECT_TRUE_SIMULATED_WAIT(CheckAllConnectionsFailedAndPruned(), kTimeout,
-                             clock);
-  EXPECT_TRUE_SIMULATED_WAIT(!turn_port_->HasRequests(), kTimeout, clock);
+  turn_port_->FlushRequests(TURN_REFRESH_REQUEST);
+  EXPECT_TRUE_SIMULATED_WAIT(!turn_refresh_success_, kSimulatedRtt,
+                             fake_clock_);
+  EXPECT_FALSE(turn_port_->connected());
+  EXPECT_TRUE(CheckAllConnectionsFailedAndPruned());
+  EXPECT_FALSE(turn_port_->HasRequests());
 }
 
 // Test that TurnPort will not handle any incoming packets once it has been
 // closed.
 TEST_F(TurnPortTest, TestStopProcessingPacketsAfterClosed) {
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
-  PrepareTurnAndUdpPorts();
+  PrepareTurnAndUdpPorts(PROTO_UDP);
   Connection* conn1 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                                    Port::ORIGIN_MESSAGE);
   Connection* conn2 = udp_port_->CreateConnection(turn_port_->Candidates()[0],
                                                   Port::ORIGIN_MESSAGE);
   ASSERT_TRUE(conn1 != NULL);
   ASSERT_TRUE(conn2 != NULL);
   // Make sure conn2 is writable.
   conn2->Ping(0);
-  EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, conn2->write_state(), kTimeout);
+  EXPECT_EQ_SIMULATED_WAIT(Connection::STATE_WRITABLE, conn2->write_state(),
+                           kSimulatedRtt * 2, fake_clock_);
 
   turn_port_->Close();
-  rtc::Thread::Current()->ProcessMessages(0);
+  SIMULATED_WAIT(false, kSimulatedRtt, fake_clock_);
   turn_unknown_address_ = false;
   conn2->Ping(0);
-  rtc::Thread::Current()->ProcessMessages(500);
+  SIMULATED_WAIT(false, kSimulatedRtt, fake_clock_);
   // Since the turn port does not handle packets any more, it should not
   // SignalUnknownAddress.
   EXPECT_FALSE(turn_unknown_address_);
 }
 
 // Test that CreateConnection will return null if port becomes disconnected.
 TEST_F(TurnPortTest, TestCreateConnectionWhenSocketClosed) {
-  turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
+  turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
-  PrepareTurnAndUdpPorts();
+  PrepareTurnAndUdpPorts(PROTO_TCP);
   // Create a connection.
   Connection* conn1 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                                    Port::ORIGIN_MESSAGE);
   ASSERT_TRUE(conn1 != NULL);
 
   // Close the socket and create a connection again.
   turn_port_->OnSocketClose(turn_port_->socket(), 1);
   conn1 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                        Port::ORIGIN_MESSAGE);
   ASSERT_TRUE(conn1 == NULL);
 }
 
 // Tests that when a TCP socket is closed, the respective TURN connection will
 // be destroyed.
 TEST_F(TurnPortTest, TestSocketCloseWillDestroyConnection) {
-  turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
+  turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
-  PrepareTurnAndUdpPorts();
+  PrepareTurnAndUdpPorts(PROTO_TCP);
   Connection* conn = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                                   Port::ORIGIN_MESSAGE);
   EXPECT_NE(nullptr, conn);
   EXPECT_TRUE(!turn_port_->connections().empty());
   turn_port_->socket()->SignalClose(turn_port_->socket(), 1);
-  EXPECT_TRUE_WAIT(turn_port_->connections().empty(), kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_port_->connections().empty(),
+                             kConnectionDestructionDelay, fake_clock_);
 }
 
 // Test try-alternate-server feature.
 TEST_F(TurnPortTest, TestTurnAlternateServerUDP) {
-  TestTurnAlternateServer(cricket::PROTO_UDP);
+  TestTurnAlternateServer(PROTO_UDP);
 }
 
 TEST_F(TurnPortTest, TestTurnAlternateServerTCP) {
-  TestTurnAlternateServer(cricket::PROTO_TCP);
+  TestTurnAlternateServer(PROTO_TCP);
 }
 
 // Test that we fail when we redirect to an address different from
 // current IP family.
 TEST_F(TurnPortTest, TestTurnAlternateServerV4toV6UDP) {
-  TestTurnAlternateServerV4toV6(cricket::PROTO_UDP);
+  TestTurnAlternateServerV4toV6(PROTO_UDP);
 }
 
 TEST_F(TurnPortTest, TestTurnAlternateServerV4toV6TCP) {
-  TestTurnAlternateServerV4toV6(cricket::PROTO_TCP);
+  TestTurnAlternateServerV4toV6(PROTO_TCP);
 }
 
 // Test try-alternate-server catches the case of pingpong.
 TEST_F(TurnPortTest, TestTurnAlternateServerPingPongUDP) {
-  TestTurnAlternateServerPingPong(cricket::PROTO_UDP);
+  TestTurnAlternateServerPingPong(PROTO_UDP);
 }
 
 TEST_F(TurnPortTest, TestTurnAlternateServerPingPongTCP) {
-  TestTurnAlternateServerPingPong(cricket::PROTO_TCP);
+  TestTurnAlternateServerPingPong(PROTO_TCP);
 }
 
 // Test try-alternate-server catch the case of repeated server.
 TEST_F(TurnPortTest, TestTurnAlternateServerDetectRepetitionUDP) {
-  TestTurnAlternateServerDetectRepetition(cricket::PROTO_UDP);
+  TestTurnAlternateServerDetectRepetition(PROTO_UDP);
 }
 
 TEST_F(TurnPortTest, TestTurnAlternateServerDetectRepetitionTCP) {
-  TestTurnAlternateServerDetectRepetition(cricket::PROTO_TCP);
+  TestTurnAlternateServerDetectRepetition(PROTO_TCP);
 }
 
 // Do a TURN allocation and try to send a packet to it from the outside.
 // The packet should be dropped. Then, try to send a packet from TURN to the
 // outside. It should reach its destination. Finally, try again from the
 // outside. It should now work as well.
 TEST_F(TurnPortTest, TestTurnConnection) {
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
-  TestTurnConnection();
+  TestTurnConnection(PROTO_UDP);
 }
 
 // Similar to above, except that this test will use the shared socket.
 TEST_F(TurnPortTest, TestTurnConnectionUsingSharedSocket) {
   CreateSharedTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
-  TestTurnConnection();
+  TestTurnConnection(PROTO_UDP);
 }
 
 // Test that we can establish a TCP connection with TURN server.
 TEST_F(TurnPortTest, TestTurnTcpConnection) {
-  turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
+  turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
-  TestTurnConnection();
+  TestTurnConnection(PROTO_TCP);
 }
 
 // Test that if a connection on a TURN port is destroyed, the TURN port can
 // still receive ping on that connection as if it is from an unknown address.
 // If the connection is created again, it will be used to receive ping.
 TEST_F(TurnPortTest, TestDestroyTurnConnection) {
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
   TestDestroyTurnConnection();
 }
 
 // Similar to above, except that this test will use the shared socket.
 TEST_F(TurnPortTest, TestDestroyTurnConnectionUsingSharedSocket) {
   CreateSharedTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
   TestDestroyTurnConnection();
 }
 
 // Test that we fail to create a connection when we want to use TLS over TCP.
 // This test should be removed once we have TLS support.
 TEST_F(TurnPortTest, TestTurnTlsTcpConnectionFails) {
-  cricket::ProtocolAddress secure_addr(kTurnTcpProtoAddr.address,
-                                       kTurnTcpProtoAddr.proto,
-                                       true);
+  ProtocolAddress secure_addr(kTurnTcpProtoAddr.address,
+                              kTurnTcpProtoAddr.proto, true);
   CreateTurnPort(kTurnUsername, kTurnPassword, secure_addr);
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_error_, kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_error_, kSimulatedRtt * 2, fake_clock_);
   ASSERT_EQ(0U, turn_port_->Candidates().size());
 }
 
 // Run TurnConnectionTest with one-time-use nonce feature.
 // Here server will send a 438 STALE_NONCE error message for
 // every TURN transaction.
 TEST_F(TurnPortTest, TestTurnConnectionUsingOTUNonce) {
   turn_server_.set_enable_otu_nonce(true);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
-  TestTurnConnection();
+  TestTurnConnection(PROTO_UDP);
 }
 
 // Test that CreatePermissionRequest will be scheduled after the success
 // of the first create permission request and the request will get an
 // ErrorResponse if the ufrag and pwd are incorrect.
 TEST_F(TurnPortTest, TestRefreshCreatePermissionRequest) {
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
-  PrepareTurnAndUdpPorts();
+  PrepareTurnAndUdpPorts(PROTO_UDP);
 
   Connection* conn = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                                   Port::ORIGIN_MESSAGE);
   ASSERT_TRUE(conn != NULL);
-  EXPECT_TRUE_WAIT(turn_create_permission_success_, kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_create_permission_success_, kSimulatedRtt,
+                             fake_clock_);
   turn_create_permission_success_ = false;
   // A create-permission-request should be pending.
   // After the next create-permission-response is received, it will schedule
   // another request with bad_ufrag and bad_pwd.
-  cricket::RelayCredentials bad_credentials("bad_user", "bad_pwd");
+  RelayCredentials bad_credentials("bad_user", "bad_pwd");
   turn_port_->set_credentials(bad_credentials);
-  turn_port_->FlushRequests(cricket::kAllRequests);
-  EXPECT_TRUE_WAIT(turn_create_permission_success_, kTimeout);
+  turn_port_->FlushRequests(kAllRequests);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_create_permission_success_, kSimulatedRtt,
+                             fake_clock_);
   // Flush the requests again; the create-permission-request will fail.
-  turn_port_->FlushRequests(cricket::kAllRequests);
-  EXPECT_TRUE_WAIT(!turn_create_permission_success_, kTimeout);
-  EXPECT_TRUE_WAIT(CheckConnectionFailedAndPruned(conn), kTimeout);
+  turn_port_->FlushRequests(kAllRequests);
+  EXPECT_TRUE_SIMULATED_WAIT(!turn_create_permission_success_, kSimulatedRtt,
+                             fake_clock_);
+  EXPECT_TRUE(CheckConnectionFailedAndPruned(conn));
 }
 
 TEST_F(TurnPortTest, TestChannelBindGetErrorResponse) {
-  rtc::ScopedFakeClock clock;
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
-  PrepareTurnAndUdpPorts();
+  PrepareTurnAndUdpPorts(PROTO_UDP);
   Connection* conn1 = turn_port_->CreateConnection(udp_port_->Candidates()[0],
                                                    Port::ORIGIN_MESSAGE);
   ASSERT_TRUE(conn1 != nullptr);
   Connection* conn2 = udp_port_->CreateConnection(turn_port_->Candidates()[0],
                                                   Port::ORIGIN_MESSAGE);
 
   ASSERT_TRUE(conn2 != nullptr);
   conn1->Ping(0);
-  EXPECT_TRUE_SIMULATED_WAIT(conn1->writable(), kTimeout, clock);
-  bool success =
-      turn_port_->SetEntryChannelId(udp_port_->Candidates()[0].address(), -1);
-  ASSERT_TRUE(success);
+  EXPECT_TRUE_SIMULATED_WAIT(conn1->writable(), kSimulatedRtt * 2, fake_clock_);
+  // TODO(deadbeef): SetEntryChannelId should not be a public method.
+  // Instead we should set an option on the fake TURN server to force it to
+  // send a channel bind errors.
+  ASSERT_TRUE(
+      turn_port_->SetEntryChannelId(udp_port_->Candidates()[0].address(), -1));
 
   std::string data = "ABC";
   conn1->Send(data.data(), data.length(), options);
 
-  EXPECT_TRUE_SIMULATED_WAIT(CheckConnectionFailedAndPruned(conn1), kTimeout,
-                             clock);
+  EXPECT_TRUE_SIMULATED_WAIT(CheckConnectionFailedAndPruned(conn1),
+                             kSimulatedRtt, fake_clock_);
   // Verify that no packet can be sent after a bind request error.
   conn2->SignalReadPacket.connect(static_cast<TurnPortTest*>(this),
                                   &TurnPortTest::OnUdpReadPacket);
   conn1->Send(data.data(), data.length(), options);
-  SIMULATED_WAIT(!udp_packets_.empty(), kTimeout, clock);
+  SIMULATED_WAIT(!udp_packets_.empty(), kSimulatedRtt, fake_clock_);
   EXPECT_TRUE(udp_packets_.empty());
 }
 
 // Do a TURN allocation, establish a UDP connection, and send some data.
 TEST_F(TurnPortTest, TestTurnSendDataTurnUdpToUdp) {
   // Create ports and prepare addresses.
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
-  TestTurnSendData();
-  EXPECT_EQ(cricket::UDP_PROTOCOL_NAME,
-            turn_port_->Candidates()[0].relay_protocol());
+  TestTurnSendData(PROTO_UDP);
+  EXPECT_EQ(UDP_PROTOCOL_NAME, turn_port_->Candidates()[0].relay_protocol());
 }
 
 // Do a TURN allocation, establish a TCP connection, and send some data.
 TEST_F(TurnPortTest, TestTurnSendDataTurnTcpToUdp) {
-  turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
+  turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
   // Create ports and prepare addresses.
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
-  TestTurnSendData();
-  EXPECT_EQ(cricket::TCP_PROTOCOL_NAME,
-            turn_port_->Candidates()[0].relay_protocol());
+  TestTurnSendData(PROTO_TCP);
+  EXPECT_EQ(TCP_PROTOCOL_NAME, turn_port_->Candidates()[0].relay_protocol());
 }
 
 // Test TURN fails to make a connection from IPv6 address to a server which has
 // IPv4 address.
 TEST_F(TurnPortTest, TestTurnLocalIPv6AddressServerIPv4) {
-  turn_server_.AddInternalSocket(kTurnUdpIPv6IntAddr, cricket::PROTO_UDP);
+  turn_server_.AddInternalSocket(kTurnUdpIPv6IntAddr, PROTO_UDP);
   CreateTurnPort(kLocalIPv6Addr, kTurnUsername, kTurnPassword,
                  kTurnUdpProtoAddr);
   turn_port_->PrepareAddress();
-  ASSERT_TRUE_WAIT(turn_error_, kTimeout);
+  ASSERT_TRUE_SIMULATED_WAIT(turn_error_, kSimulatedRtt, fake_clock_);
   EXPECT_TRUE(turn_port_->Candidates().empty());
 }
 
 // Test TURN make a connection from IPv6 address to a server which has
 // IPv6 intenal address. But in this test external address is a IPv4 address,
 // hence allocated address will be a IPv4 address.
 TEST_F(TurnPortTest, TestTurnLocalIPv6AddressServerIPv6ExtenalIPv4) {
-  turn_server_.AddInternalSocket(kTurnUdpIPv6IntAddr, cricket::PROTO_UDP);
+  turn_server_.AddInternalSocket(kTurnUdpIPv6IntAddr, PROTO_UDP);
   CreateTurnPort(kLocalIPv6Addr, kTurnUsername, kTurnPassword,
                  kTurnUdpIPv6ProtoAddr);
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 2, fake_clock_);
   ASSERT_EQ(1U, turn_port_->Candidates().size());
   EXPECT_EQ(kTurnUdpExtAddr.ipaddr(),
             turn_port_->Candidates()[0].address().ipaddr());
   EXPECT_NE(0, turn_port_->Candidates()[0].address().port());
 }
 
 // Tests that the local and remote candidate address families should match when
 // a connection is created. Specifically, if a TURN port has an IPv6 address,
 // its local candidate will still be an IPv4 address and it can only create
 // connections with IPv4 remote candidates.
 TEST_F(TurnPortTest, TestCandidateAddressFamilyMatch) {
-  turn_server_.AddInternalSocket(kTurnUdpIPv6IntAddr, cricket::PROTO_UDP);
+  turn_server_.AddInternalSocket(kTurnUdpIPv6IntAddr, PROTO_UDP);
 
   CreateTurnPort(kLocalIPv6Addr, kTurnUsername, kTurnPassword,
                  kTurnUdpIPv6ProtoAddr);
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 2, fake_clock_);
   ASSERT_EQ(1U, turn_port_->Candidates().size());
 
   // Create an IPv4 candidate. It will match the TURN candidate.
-  cricket::Candidate remote_candidate(cricket::ICE_CANDIDATE_COMPONENT_RTP,
-                                      "udp", kLocalAddr2, 0, "", "", "local", 0,
-                                      kCandidateFoundation);
+  Candidate remote_candidate(ICE_CANDIDATE_COMPONENT_RTP, "udp", kLocalAddr2, 0,
+                             "", "", "local", 0, kCandidateFoundation);
   remote_candidate.set_address(kLocalAddr2);
   Connection* conn =
       turn_port_->CreateConnection(remote_candidate, Port::ORIGIN_MESSAGE);
   EXPECT_NE(nullptr, conn);
 
   // Set the candidate address family to IPv6. It won't match the TURN
   // candidate.
   remote_candidate.set_address(kLocalIPv6Addr2);
   conn = turn_port_->CreateConnection(remote_candidate, Port::ORIGIN_MESSAGE);
   EXPECT_EQ(nullptr, conn);
 }
 
 TEST_F(TurnPortTest, TestOriginHeader) {
   CreateTurnPortWithOrigin(kLocalAddr1, kTurnUsername, kTurnPassword,
                            kTurnUdpProtoAddr, kTestOrigin);
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 2, fake_clock_);
   ASSERT_GT(turn_server_.server()->allocations().size(), 0U);
   SocketAddress local_address = turn_port_->GetLocalAddress();
   ASSERT_TRUE(turn_server_.FindAllocation(local_address) != NULL);
   EXPECT_EQ(kTestOrigin, turn_server_.FindAllocation(local_address)->origin());
 }
 
 // Test that a CreatePermission failure will result in the connection being
 // pruned and failed.
-TEST_F(TurnPortTest, TestConnectionFaildAndPrunedOnCreatePermissionFailure) {
-  rtc::ScopedFakeClock clock;
-  SIMULATED_WAIT(false, 101, clock);
-  turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
+TEST_F(TurnPortTest, TestConnectionFailedAndPrunedOnCreatePermissionFailure) {
+  turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
   turn_server_.server()->set_reject_private_addresses(true);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kTimeout, clock);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 3, fake_clock_);
 
   CreateUdpPort(SocketAddress("10.0.0.10", 0));
   udp_port_->PrepareAddress();
-  EXPECT_TRUE_SIMULATED_WAIT(udp_ready_, kTimeout, clock);
+  EXPECT_TRUE_SIMULATED_WAIT(udp_ready_, kSimulatedRtt, fake_clock_);
   // Create a connection.
   TestConnectionWrapper conn(turn_port_->CreateConnection(
       udp_port_->Candidates()[0], Port::ORIGIN_MESSAGE));
   EXPECT_TRUE(conn.connection() != nullptr);
 
   // Asynchronously, CreatePermission request should be sent and fail, which
   // will make the connection pruned and failed.
   EXPECT_TRUE_SIMULATED_WAIT(CheckConnectionFailedAndPruned(conn.connection()),
-                             kTimeout, clock);
-  EXPECT_TRUE_SIMULATED_WAIT(!turn_create_permission_success_, kTimeout, clock);
+                             kSimulatedRtt, fake_clock_);
+  EXPECT_TRUE_SIMULATED_WAIT(!turn_create_permission_success_, kSimulatedRtt,
+                             fake_clock_);
   // Check that the connection is not deleted asynchronously.
-  SIMULATED_WAIT(conn.connection() == nullptr, kTimeout, clock);
-  EXPECT_TRUE(conn.connection() != nullptr);
+  SIMULATED_WAIT(conn.connection() == nullptr, kConnectionDestructionDelay,
+                 fake_clock_);
+  EXPECT_NE(nullptr, conn.connection());
 }
 
 // Test that a TURN allocation is released when the port is closed.
 TEST_F(TurnPortTest, TestTurnReleaseAllocation) {
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 2, fake_clock_);
 
   ASSERT_GT(turn_server_.server()->allocations().size(), 0U);
   turn_port_.reset();
-  EXPECT_EQ_WAIT(0U, turn_server_.server()->allocations().size(), kTimeout);
+  EXPECT_EQ_SIMULATED_WAIT(0U, turn_server_.server()->allocations().size(),
+                           kSimulatedRtt, fake_clock_);
 }
 
 // Test that a TURN TCP allocation is released when the port is closed.
-TEST_F(TurnPortTest, DISABLED_TestTurnTCPReleaseAllocation) {
-  turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
+TEST_F(TurnPortTest, TestTurnTCPReleaseAllocation) {
+  turn_server_.AddInternalSocket(kTurnTcpIntAddr, PROTO_TCP);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
   turn_port_->PrepareAddress();
-  EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
+  EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 3, fake_clock_);
 
   ASSERT_GT(turn_server_.server()->allocations().size(), 0U);
   turn_port_.reset();
-  EXPECT_EQ_WAIT(0U, turn_server_.server()->allocations().size(), kTimeout);
+  EXPECT_EQ_SIMULATED_WAIT(0U, turn_server_.server()->allocations().size(),
+                           kSimulatedRtt, fake_clock_);
 }
 
 // This test verifies any FD's are not leaked after TurnPort is destroyed.
 // https://code.google.com/p/webrtc/issues/detail?id=2651
 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
-// 1 second is not always enough for getaddrinfo().
-// See: https://bugs.chromium.org/p/webrtc/issues/detail?id=5191
-static const unsigned int kResolverTimeout = 10000;
 
 TEST_F(TurnPortTest, TestResolverShutdown) {
-  turn_server_.AddInternalSocket(kTurnUdpIPv6IntAddr, cricket::PROTO_UDP);
+  turn_server_.AddInternalSocket(kTurnUdpIPv6IntAddr, PROTO_UDP);
   int last_fd_count = GetFDCount();
   // Need to supply unresolved address to kick off resolver.
   CreateTurnPort(kLocalIPv6Addr, kTurnUsername, kTurnPassword,
-                 cricket::ProtocolAddress(rtc::SocketAddress(
-                    "www.google.invalid", 3478), cricket::PROTO_UDP));
+                 ProtocolAddress(rtc::SocketAddress("www.google.invalid", 3478),
+                                 PROTO_UDP));
   turn_port_->PrepareAddress();
   ASSERT_TRUE_WAIT(turn_error_, kResolverTimeout);
   EXPECT_TRUE(turn_port_->Candidates().empty());
   turn_port_.reset();
   rtc::Thread::Current()->Post(RTC_FROM_HERE, this, MSG_TESTFINISH);
   // Waiting for above message to be processed.
-  ASSERT_TRUE_WAIT(test_finish_, kTimeout);
+  ASSERT_TRUE_SIMULATED_WAIT(test_finish_, 1, fake_clock_);
   EXPECT_EQ(last_fd_count, GetFDCount());
 }
 #endif
+
+}  // namespace cricket