diff --git a/quiche/quic/core/http/end_to_end_test.cc b/quiche/quic/core/http/end_to_end_test.cc
index 0e2c867..50fe6a3 100644
--- a/quiche/quic/core/http/end_to_end_test.cc
+++ b/quiche/quic/core/http/end_to_end_test.cc
@@ -26,7 +26,7 @@
 #include "quiche/quic/core/quic_connection.h"
 #include "quiche/quic/core/quic_constants.h"
 #include "quiche/quic/core/quic_data_writer.h"
-#include "quiche/quic/core/quic_epoll_connection_helper.h"
+#include "quiche/quic/core/quic_default_clock.h"
 #include "quiche/quic/core/quic_error_codes.h"
 #include "quiche/quic/core/quic_framer.h"
 #include "quiche/quic/core/quic_packet_creator.h"
@@ -35,7 +35,6 @@
 #include "quiche/quic/core/quic_session.h"
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/core/quic_utils.h"
-#include "quiche/quic/platform/api/quic_epoll.h"
 #include "quiche/quic/platform/api/quic_expect_bug.h"
 #include "quiche/quic/platform/api/quic_flags.h"
 #include "quiche/quic/platform/api/quic_logging.h"
@@ -199,15 +198,15 @@
 
 class ClientDelegate : public PacketDroppingTestWriter::Delegate {
  public:
-  explicit ClientDelegate(QuicClient* client) : client_(client) {}
+  explicit ClientDelegate(QuicDefaultClient* client) : client_(client) {}
   ~ClientDelegate() override = default;
   void OnCanWrite() override {
-    QuicEpollEvent event(EPOLLOUT);
-    client_->epoll_network_helper()->OnEvent(client_->GetLatestFD(), &event);
+    client_->default_network_helper()->OnSocketEvent(
+        nullptr, client_->GetLatestFD(), kSocketEventWritable);
   }
 
  private:
-  QuicClient* client_;
+  QuicDefaultClient* client_;
 };
 
 class EndToEndTest : public QuicTestWithParam<TestParams> {
@@ -258,11 +257,12 @@
   }
 
   QuicTestClient* CreateQuicClient(QuicPacketWriterWrapper* writer) {
-    QuicTestClient* client =
-        new QuicTestClient(server_address_, server_hostname_, client_config_,
-                           client_supported_versions_,
-                           crypto_test_utils::ProofVerifierForTesting(),
-                           std::make_unique<QuicClientSessionCache>());
+    QuicTestClient* client = new QuicTestClient(
+        server_address_, server_hostname_, client_config_,
+        client_supported_versions_,
+        crypto_test_utils::ProofVerifierForTesting(),
+        std::make_unique<QuicClientSessionCache>(),
+        GetParam().event_loop->Create(QuicDefaultClock::Get()));
     client->SetUserAgentID(kTestUserAgentId);
     client->UseWriter(writer);
     if (!pre_shared_key_client_.empty()) {
@@ -449,7 +449,6 @@
       ADD_FAILURE() << "Missing MockableQuicClient";
       return false;
     }
-    static QuicEpollEvent event(EPOLLOUT);
     if (client_writer_ != nullptr) {
       QuicConnection* client_connection = GetClientConnection();
       if (client_connection == nullptr) {
@@ -2256,7 +2255,7 @@
   // Regression test for b/14677858.
   // Test that the resume write alarm is not set in QuicConnection::OnCanWrite
   // if currently connection level flow control blocked. If set, this results in
-  // an infinite loop in the EpollServer, as the alarm fires and is immediately
+  // an infinite loop in the EventLoop, as the alarm fires and is immediately
   // rescheduled.
   ASSERT_TRUE(Initialize());
   EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
@@ -3452,10 +3451,12 @@
 
   // Create a new socket before closing the old one, which will result in a new
   // ephemeral port.
-  QuicClientPeer::CreateUDPSocketAndBind(client_->client());
+  client_->client()->network_helper()->CreateUDPSocketAndBind(
+      client_->client()->server_address(), client_->client()->bind_to_address(),
+      client_->client()->local_port());
 
   // Stop listening and close the old FD.
-  QuicClientPeer::CleanUpUDPSocket(client_->client(), old_fd);
+  client_->client()->default_network_helper()->CleanUpUDPSocket(old_fd);
 
   // The packet writer needs to be updated to use the new FD.
   client_->client()->network_helper()->CreateQuicPacketWriter();
@@ -3467,19 +3468,13 @@
   // FD rather than any more complex NAT rebinding simulation.
   int new_port =
       client_->client()->network_helper()->GetLatestClientAddress().port();
-  QuicClientPeer::SetClientPort(client_->client(), new_port);
+  client_->client()->default_network_helper()->SetClientPort(new_port);
   QuicConnection* client_connection = GetClientConnection();
   ASSERT_TRUE(client_connection);
   QuicConnectionPeer::SetSelfAddress(
       client_connection,
       QuicSocketAddress(client_connection->self_address().host(), new_port));
 
-  // Register the new FD for epoll events.
-  int new_fd = client_->client()->GetLatestFD();
-  QuicEpollServer* eps = client_->epoll_server();
-  eps->RegisterFD(new_fd, client_->client()->epoll_network_helper(),
-                  EPOLLIN | EPOLLOUT | EPOLLET);
-
   // Send a second request, using the new FD.
   SendSynchronousBarRequestAndCheckResponse();
 
@@ -4707,9 +4702,6 @@
   ServerStreamThatDropsBodyFactory stream_factory;
   SetSpdyStreamFactory(&stream_factory);
   ASSERT_TRUE(Initialize());
-  // Set client's epoll server's time out to 0 to make this test be finished
-  // within a short time.
-  client_->epoll_server()->set_timeout_in_us(0);
 
   EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
   SetPacketLossPercentage(1);
@@ -4760,7 +4752,6 @@
   client->UseWriter(client_writer_);
   client->Connect();
   client_.reset(client);
-  static QuicEpollEvent event(EPOLLOUT);
   QuicConnection* client_connection = GetClientConnection();
   ASSERT_TRUE(client_connection);
   client_writer_->Initialize(
diff --git a/quiche/quic/test_tools/quic_test_client.cc b/quiche/quic/test_tools/quic_test_client.cc
index 2a82038..32b61ed 100644
--- a/quiche/quic/test_tools/quic_test_client.cc
+++ b/quiche/quic/test_tools/quic_test_client.cc
@@ -14,7 +14,8 @@
 #include "quiche/quic/core/crypto/proof_verifier.h"
 #include "quiche/quic/core/http/quic_spdy_client_stream.h"
 #include "quiche/quic/core/http/spdy_utils.h"
-#include "quiche/quic/core/quic_epoll_connection_helper.h"
+#include "quiche/quic/core/io/quic_default_event_loop.h"
+#include "quiche/quic/core/quic_default_clock.h"
 #include "quiche/quic/core/quic_packet_writer_wrapper.h"
 #include "quiche/quic/core/quic_server_id.h"
 #include "quiche/quic/core/quic_utils.h"
@@ -133,17 +134,17 @@
 };
 }  // namespace
 
-class MockableQuicClientEpollNetworkHelper
-    : public QuicClientEpollNetworkHelper {
+class MockableQuicClientDefaultNetworkHelper
+    : public QuicClientDefaultNetworkHelper {
  public:
-  using QuicClientEpollNetworkHelper::QuicClientEpollNetworkHelper;
-  ~MockableQuicClientEpollNetworkHelper() override = default;
+  using QuicClientDefaultNetworkHelper::QuicClientDefaultNetworkHelper;
+  ~MockableQuicClientDefaultNetworkHelper() override = default;
 
   void ProcessPacket(const QuicSocketAddress& self_address,
                      const QuicSocketAddress& peer_address,
                      const QuicReceivedPacket& packet) override {
-    QuicClientEpollNetworkHelper::ProcessPacket(self_address, peer_address,
-                                                packet);
+    QuicClientDefaultNetworkHelper::ProcessPacket(self_address, peer_address,
+                                                  packet);
     if (track_last_incoming_packet_) {
       last_incoming_packet_ = packet.Clone();
     }
@@ -151,7 +152,7 @@
 
   QuicPacketWriter* CreateQuicPacketWriter() override {
     QuicPacketWriter* writer =
-        QuicClientEpollNetworkHelper::CreateQuicPacketWriter();
+        QuicClientDefaultNetworkHelper::CreateQuicPacketWriter();
     if (!test_writer_) {
       return writer;
     }
@@ -188,35 +189,33 @@
 MockableQuicClient::MockableQuicClient(
     QuicSocketAddress server_address, const QuicServerId& server_id,
     const ParsedQuicVersionVector& supported_versions,
-    QuicEpollServer* epoll_server)
+    QuicEventLoop* event_loop)
     : MockableQuicClient(server_address, server_id, QuicConfig(),
-                         supported_versions, epoll_server) {}
+                         supported_versions, event_loop) {}
 
 MockableQuicClient::MockableQuicClient(
     QuicSocketAddress server_address, const QuicServerId& server_id,
     const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
-    QuicEpollServer* epoll_server)
+    QuicEventLoop* event_loop)
     : MockableQuicClient(server_address, server_id, config, supported_versions,
-                         epoll_server, nullptr) {}
+                         event_loop, nullptr) {}
 
 MockableQuicClient::MockableQuicClient(
     QuicSocketAddress server_address, const QuicServerId& server_id,
     const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
-    QuicEpollServer* epoll_server,
-    std::unique_ptr<ProofVerifier> proof_verifier)
+    QuicEventLoop* event_loop, std::unique_ptr<ProofVerifier> proof_verifier)
     : MockableQuicClient(server_address, server_id, config, supported_versions,
-                         epoll_server, std::move(proof_verifier), nullptr) {}
+                         event_loop, std::move(proof_verifier), nullptr) {}
 
 MockableQuicClient::MockableQuicClient(
     QuicSocketAddress server_address, const QuicServerId& server_id,
     const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
-    QuicEpollServer* epoll_server,
-    std::unique_ptr<ProofVerifier> proof_verifier,
+    QuicEventLoop* event_loop, std::unique_ptr<ProofVerifier> proof_verifier,
     std::unique_ptr<SessionCache> session_cache)
-    : QuicClient(
-          server_address, server_id, supported_versions, config, epoll_server,
-          std::make_unique<MockableQuicClientEpollNetworkHelper>(epoll_server,
-                                                                 this),
+    : QuicDefaultClient(
+          server_address, server_id, supported_versions, config, event_loop,
+          std::make_unique<MockableQuicClientDefaultNetworkHelper>(event_loop,
+                                                                   this),
           std::make_unique<RecordingProofVerifier>(std::move(proof_verifier)),
           std::move(session_cache)),
       override_server_connection_id_(EmptyQuicConnectionId()),
@@ -230,16 +229,16 @@
   }
 }
 
-MockableQuicClientEpollNetworkHelper*
+MockableQuicClientDefaultNetworkHelper*
 MockableQuicClient::mockable_network_helper() {
-  return static_cast<MockableQuicClientEpollNetworkHelper*>(
-      epoll_network_helper());
+  return static_cast<MockableQuicClientDefaultNetworkHelper*>(
+      default_network_helper());
 }
 
-const MockableQuicClientEpollNetworkHelper*
+const MockableQuicClientDefaultNetworkHelper*
 MockableQuicClient::mockable_network_helper() const {
-  return static_cast<const MockableQuicClientEpollNetworkHelper*>(
-      epoll_network_helper());
+  return static_cast<const MockableQuicClientDefaultNetworkHelper*>(
+      default_network_helper());
 }
 
 QuicConnectionId MockableQuicClient::GenerateNewConnectionId() {
@@ -250,7 +249,7 @@
     return QuicUtils::CreateRandomConnectionId(
         override_server_connection_id_length_);
   }
-  return QuicClient::GenerateNewConnectionId();
+  return QuicDefaultClient::GenerateNewConnectionId();
 }
 
 void MockableQuicClient::UseConnectionId(
@@ -272,7 +271,7 @@
     return QuicUtils::CreateRandomConnectionId(
         override_client_connection_id_length_);
   }
-  return QuicClient::GetClientConnectionId();
+  return QuicDefaultClient::GetClientConnectionId();
 }
 
 void MockableQuicClient::UseClientConnectionId(
@@ -314,10 +313,11 @@
 QuicTestClient::QuicTestClient(
     QuicSocketAddress server_address, const std::string& server_hostname,
     const QuicConfig& config, const ParsedQuicVersionVector& supported_versions)
-    : client_(new MockableQuicClient(
+    : event_loop_(GetDefaultEventLoop()->Create(QuicDefaultClock::Get())),
+      client_(new MockableQuicClient(
           server_address,
           QuicServerId(server_hostname, server_address.port(), false), config,
-          supported_versions, &epoll_server_)) {
+          supported_versions, event_loop_.get())) {
   Initialize();
 }
 
@@ -325,10 +325,11 @@
     QuicSocketAddress server_address, const std::string& server_hostname,
     const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
     std::unique_ptr<ProofVerifier> proof_verifier)
-    : client_(new MockableQuicClient(
+    : event_loop_(GetDefaultEventLoop()->Create(QuicDefaultClock::Get())),
+      client_(new MockableQuicClient(
           server_address,
           QuicServerId(server_hostname, server_address.port(), false), config,
-          supported_versions, &epoll_server_, std::move(proof_verifier))) {
+          supported_versions, event_loop_.get(), std::move(proof_verifier))) {
   Initialize();
 }
 
@@ -337,10 +338,26 @@
     const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
     std::unique_ptr<ProofVerifier> proof_verifier,
     std::unique_ptr<SessionCache> session_cache)
-    : client_(new MockableQuicClient(
+    : event_loop_(GetDefaultEventLoop()->Create(QuicDefaultClock::Get())),
+      client_(new MockableQuicClient(
           server_address,
           QuicServerId(server_hostname, server_address.port(), false), config,
-          supported_versions, &epoll_server_, std::move(proof_verifier),
+          supported_versions, event_loop_.get(), std::move(proof_verifier),
+          std::move(session_cache))) {
+  Initialize();
+}
+
+QuicTestClient::QuicTestClient(
+    QuicSocketAddress server_address, const std::string& server_hostname,
+    const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
+    std::unique_ptr<ProofVerifier> proof_verifier,
+    std::unique_ptr<SessionCache> session_cache,
+    std::unique_ptr<QuicEventLoop> event_loop)
+    : event_loop_(std::move(event_loop)),
+      client_(new MockableQuicClient(
+          server_address,
+          QuicServerId(server_hostname, server_address.port(), false), config,
+          supported_versions, event_loop_.get(), std::move(proof_verifier),
           std::move(session_cache))) {
   Initialize();
 }
@@ -636,24 +653,15 @@
 }
 
 bool QuicTestClient::WaitUntil(int timeout_ms, std::function<bool()> trigger) {
-  int64_t timeout_us = timeout_ms * kNumMicrosPerMilli;
-  int64_t old_timeout_us = epoll_server()->timeout_in_us_for_test();
-  if (timeout_us > 0) {
-    epoll_server()->set_timeout_in_us(timeout_us);
-  }
-  const QuicClock* clock =
-      QuicConnectionPeer::GetHelper(client()->session()->connection())
-          ->GetClock();
-  QuicTime end_waiting_time =
-      clock->Now() + QuicTime::Delta::FromMicroseconds(timeout_us);
+  QuicTime::Delta timeout = QuicTime::Delta::FromMilliseconds(timeout_ms);
+  const QuicClock* clock = client()->session()->connection()->clock();
+  QuicTime end_waiting_time = clock->Now() + timeout;
   while (connected() && !(trigger && trigger()) &&
-         (timeout_us < 0 || clock->Now() < end_waiting_time)) {
-    client_->WaitForEvents();
+         (timeout_ms < 0 || clock->Now() < end_waiting_time)) {
+    event_loop_->RunEventLoopOnce(timeout);
+    client_->WaitForEventsPostprocessing();
   }
   ReadNextResponse();
-  if (timeout_us > 0) {
-    epoll_server()->set_timeout_in_us(old_timeout_us);
-  }
   if (trigger && !trigger()) {
     QUIC_VLOG(1) << "Client WaitUntil returning with trigger returning false.";
     return false;
@@ -837,7 +845,7 @@
     bool fin, QuicTestClient* test_client,
     quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
         ack_listener)
-    : QuicClient::QuicDataToResend(std::move(headers), body, fin),
+    : QuicDefaultClient::QuicDataToResend(std::move(headers), body, fin),
       test_client_(test_client),
       ack_listener_(std::move(ack_listener)) {}
 
diff --git a/quiche/quic/test_tools/quic_test_client.h b/quiche/quic/test_tools/quic_test_client.h
index 36cc46d..a1f7b13 100644
--- a/quiche/quic/test_tools/quic_test_client.h
+++ b/quiche/quic/test_tools/quic_test_client.h
@@ -10,13 +10,13 @@
 #include <string>
 
 #include "absl/strings/string_view.h"
+#include "quiche/quic/core/io/quic_event_loop.h"
 #include "quiche/quic/core/proto/cached_network_parameters_proto.h"
 #include "quiche/quic/core/quic_framer.h"
 #include "quiche/quic/core/quic_packet_creator.h"
 #include "quiche/quic/core/quic_packets.h"
-#include "quiche/quic/platform/api/quic_epoll.h"
 #include "quiche/quic/platform/api/quic_test.h"
-#include "quiche/quic/tools/quic_client.h"
+#include "quiche/quic/tools/quic_default_client.h"
 #include "quiche/common/quiche_linked_hash_map.h"
 #include "quiche/spdy/core/http2_header_block.h"
 
@@ -27,31 +27,31 @@
 
 namespace test {
 
-class MockableQuicClientEpollNetworkHelper;
+class MockableQuicClientDefaultNetworkHelper;
 
 // A quic client which allows mocking out reads and writes.
-class MockableQuicClient : public QuicClient {
+class MockableQuicClient : public QuicDefaultClient {
  public:
   MockableQuicClient(QuicSocketAddress server_address,
                      const QuicServerId& server_id,
                      const ParsedQuicVersionVector& supported_versions,
-                     QuicEpollServer* epoll_server);
+                     QuicEventLoop* event_loop);
 
   MockableQuicClient(QuicSocketAddress server_address,
                      const QuicServerId& server_id, const QuicConfig& config,
                      const ParsedQuicVersionVector& supported_versions,
-                     QuicEpollServer* epoll_server);
+                     QuicEventLoop* event_loop);
 
   MockableQuicClient(QuicSocketAddress server_address,
                      const QuicServerId& server_id, const QuicConfig& config,
                      const ParsedQuicVersionVector& supported_versions,
-                     QuicEpollServer* epoll_server,
+                     QuicEventLoop* event_loop,
                      std::unique_ptr<ProofVerifier> proof_verifier);
 
   MockableQuicClient(QuicSocketAddress server_address,
                      const QuicServerId& server_id, const QuicConfig& config,
                      const ParsedQuicVersionVector& supported_versions,
-                     QuicEpollServer* epoll_server,
+                     QuicEventLoop* event_loop,
                      std::unique_ptr<ProofVerifier> proof_verifier,
                      std::unique_ptr<SessionCache> session_cache);
   MockableQuicClient(const MockableQuicClient&) = delete;
@@ -73,9 +73,9 @@
   // If true, copy each packet from ProcessPacket into |last_incoming_packet|
   void set_track_last_incoming_packet(bool track);
 
-  // Casts the network helper to a MockableQuicClientEpollNetworkHelper.
-  MockableQuicClientEpollNetworkHelper* mockable_network_helper();
-  const MockableQuicClientEpollNetworkHelper* mockable_network_helper() const;
+  // Casts the network helper to a MockableQuicClientDefaultNetworkHelper.
+  MockableQuicClientDefaultNetworkHelper* mockable_network_helper();
+  const MockableQuicClientDefaultNetworkHelper* mockable_network_helper() const;
 
  private:
   // Server connection ID to use, if server_connection_id_overridden_
@@ -108,6 +108,12 @@
                  const ParsedQuicVersionVector& supported_versions,
                  std::unique_ptr<ProofVerifier> proof_verifier,
                  std::unique_ptr<SessionCache> session_cache);
+  QuicTestClient(QuicSocketAddress server_address,
+                 const std::string& server_hostname, const QuicConfig& config,
+                 const ParsedQuicVersionVector& supported_versions,
+                 std::unique_ptr<ProofVerifier> proof_verifier,
+                 std::unique_ptr<SessionCache> session_cache,
+                 std::unique_ptr<QuicEventLoop> event_loop);
 
   ~QuicTestClient() override;
 
@@ -284,7 +290,7 @@
 
   void WaitForWriteToFlush();
 
-  QuicEpollServer* epoll_server() { return &epoll_server_; }
+  QuicEventLoop* event_loop() { return event_loop_.get(); }
 
   size_t num_requests() const { return num_requests_; }
 
@@ -331,7 +337,7 @@
   QuicTestClient& operator=(const QuicTestClient&&) = delete;
 
  private:
-  class TestClientDataToResend : public QuicClient::QuicDataToResend {
+  class TestClientDataToResend : public QuicDefaultClient::QuicDataToResend {
    public:
     TestClientDataToResend(
         std::unique_ptr<spdy::Http2HeaderBlock> headers, absl::string_view body,
@@ -387,7 +393,7 @@
   // tracking its state.
   void SetLatestCreatedStream(QuicSpdyClientStream* stream);
 
-  QuicEpollServer epoll_server_;
+  std::unique_ptr<QuicEventLoop> event_loop_;
   std::unique_ptr<MockableQuicClient> client_;  // The actual client
   QuicSpdyClientStream* latest_created_stream_;
   std::map<QuicStreamId, QuicSpdyClientStream*> open_streams_;
diff --git a/quiche/quic/tools/quic_client_base.cc b/quiche/quic/tools/quic_client_base.cc
index 4a300c2..3a7dfd6 100644
--- a/quiche/quic/tools/quic_client_base.cc
+++ b/quiche/quic/tools/quic_client_base.cc
@@ -240,6 +240,10 @@
 
   network_helper_->RunEventLoop();
 
+  return WaitForEventsPostprocessing();
+}
+
+bool QuicClientBase::WaitForEventsPostprocessing() {
   QUICHE_DCHECK(session() != nullptr);
   ParsedQuicVersion version = UnsupportedQuicVersion();
   if (!connected() && CanReconnectWithDifferentVersion(&version)) {
diff --git a/quiche/quic/tools/quic_client_base.h b/quiche/quic/tools/quic_client_base.h
index 4f0c880..f241a5e 100644
--- a/quiche/quic/tools/quic_client_base.h
+++ b/quiche/quic/tools/quic_client_base.h
@@ -116,6 +116,10 @@
   // Returns true if there are any outstanding requests.
   bool WaitForEvents();
 
+  // Performs the part of WaitForEvents() that is done after the actual event
+  // loop call.
+  bool WaitForEventsPostprocessing();
+
   // Migrate to a new socket (new_host) during an active connection.
   bool MigrateSocket(const QuicIpAddress& new_host);