Switch QuicTestClient to use QuicDefaultClient instead of QuicClient PiperOrigin-RevId: 465535182
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);